back_end.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
bindgen.adb:         --  Cannot use pragma Import C in the Java case, so use standard
bindgen.adb:         if not Hostparm.Java_VM then
bindgen.adb:         if not Hostparm.Java_VM then
bindgen.adb:      if Hostparm.Java_VM then
bindgen.adb:      --  Override Ada_Bind_File and Bind_Main_Program for Java since
bindgen.adb:      if Hostparm.Java_VM then
bindgen.adb:      if Hostparm.Java_VM then
debug.adb:   --  dJ   Output debugging trace info for JGNAT (Java VM version of GNAT)
debug.adb:   --       consists of symbolic Java Byte Code sequences for all generated
exp_aggr.adb:      if Is_Tagged_Type (Component_Type (Typ)) and then not Java_VM then
exp_aggr.adb:         --  conversions), unless compiling for the Java VM
exp_aggr.adb:           and then not Java_VM
exp_aggr.adb:               --  works properly (unless Java_VM, where tags are implicit).
exp_aggr.adb:               if not Java_VM then
exp_aggr.adb:               --  conversions), unless compiling for the Java VM
exp_aggr.adb:               if Is_Tagged_Type (Comp_Type) and then not Java_VM then
exp_aggr.adb:      --  compiling for the Java VM where tags are implicit). It is done
exp_aggr.adb:      elsif Is_Tagged_Type (Typ) and then not Java_VM then
exp_aggr.adb:         --  No tag is needed in the case of Java_VM
exp_aggr.adb:         if Java_VM then
exp_aggr.adb:            --  (Tag adjustment is not needed if Java_VM because object
exp_aggr.adb:              and then not Java_VM
exp_aggr.adb:            elsif Java_VM then
exp_aggr.adb:            --  for the Java VM, where tags are implicit).
exp_aggr.adb:            elsif not Java_VM then
exp_attr.adb:                  if Java_VM then
exp_attr.adb:            if Java_VM then
exp_attr.adb:            if not Java_VM then
exp_ch11.adb:         if Hostparm.Java_VM then
exp_ch11.adb:      if Hostparm.Java_VM then
exp_ch11.adb:      if Present (Name (N)) and then Hostparm.Java_VM then
exp_ch3.adb:         --  Suppress the tag adjustment when Java_VM because JVM tags are
exp_ch3.adb:         if Is_Tagged_Type (Typ) and then not Java_VM then
exp_ch3.adb:         --  Suppress the tag assignment when Java_VM because JVM tags are
exp_ch3.adb:           and then not Java_VM
exp_ch3.adb:            --  Java since these types cannot embed Ada tasks anyway. Note that
exp_ch3.adb:            --         pragma Convention (Typ, Java)
exp_ch3.adb:           and then Convention (Designated_Type (Def_Id)) /= Convention_Java
exp_ch3.adb:            --  Java_VM because JVM tags are represented implicitly
exp_ch3.adb:              and then not Java_VM
exp_ch3.adb:            --  Suppress creation of a dispatch table when Java_VM because
exp_ch3.adb:            if not Java_VM then
exp_ch3.adb:            --  of a designated type with convention Java, since this is used
exp_ch3.adb:            --  when binding to Java API specs, where there's no equivalent
exp_ch3.adb:                    and then Convention (Desig_Type) /= Convention_Java)
exp_ch4.adb:            if not Java_VM then
exp_ch4.adb:               --  Suppress the tag assignment when Java_VM because JVM tags
exp_ch4.adb:                 and then not Java_VM
exp_ch4.adb:                 and then not Java_VM
exp_ch4.adb:               --  No expansion will be performed when Java_VM, as the
exp_ch4.adb:               --  (tags are not explicitly represented in Java objects,
exp_ch4.adb:               if not Java_VM then
exp_ch5.adb:         --  In the case of compiling for the Java Virtual Machine,
exp_ch5.adb:        and then not Java_VM
exp_ch5.adb:            --  in the bit packed case or the Java VM case, because addresses
exp_ch5.adb:            if not Is_Bit_Packed_Array (L_Type) and then not Java_VM then
exp_ch5.adb:            --  For the bit packed and Java VM cases we use the bounds.
exp_ch5.adb:            --  If we are generating code for the Java VM do not use
exp_ch5.adb:            if not Java_VM then
exp_ch5.adb:                                       and then not Java_VM;
exp_ch5.adb:      --  Tags are not saved and restored when Java_VM because JVM tags
exp_ch6.adb:         --  of Java subprograms. (Should this be done for other
exp_ch6.adb:         elsif Convention (Subp) = Convention_Java then
exp_ch6.adb:      --  Expansion of dispatching calls is suppressed when Java_VM, because
exp_ch6.adb:        and then not Java_VM
exp_ch6.adb:      --  initialization of the dispatch table entry when Java_VM because
exp_ch6.adb:        and then not Java_VM
exp_ch7.adb:      --  Suppress calls to SS_Mark and SS_Release if Java_VM,
exp_ch7.adb:        and then not Java_VM
exp_ch9.adb:         if Hostparm.Java_VM then
exp_util.adb:            --  A class-wide equivalent type is not needed when Java_VM
exp_util.adb:            if Expander_Active and then not Java_VM then
frontend.adb:   if not Java_VM then
gnat1drv.adb:      --  the Java VM, since representations are largely symbolic there.
gnat1drv.adb:                   or else Hostparm.Java_VM)
gnatlink.adb:   if Hostparm.Java_VM then
gnatlink.adb:      if not Hostparm.Java_VM then
gnatlink.adb:   --  Skip this step for now on the JVM since the Java interpreter will do
gnatlink.adb:--   if not Hostparm.Java_VM then
gnatlink.adb:   if Hostparm.Java_VM then
gnatlink.adb:      if not Hostparm.Java_VM then
impunit.adb:     "i-java  ",    -- Interfaces.Java
impunit.adb:     "i-javlan",    -- Interfaces.Java.Lang
impunit.adb:     "i-jalaob",    -- Interfaces.Java.Lang.Object
impunit.adb:     "i-jalasy",    -- Interfaces.Java.Lang.System
impunit.adb:     "i-jalath",    -- Interfaces.Java.Lang.Thread
j_basics.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
j_list.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
j_parser.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
j_parser.adb:      function Full_Java_Descriptor (Start : Nat_32; Last : Nat_32)
j_parser.adb:      --  Java_Descriptor, in this function the descriptor can include
j_parser.adb:      function Java_Descriptor (Start : Nat_32; Last : Nat_32) return String;
j_parser.adb:      -- Full_Java_Descriptor --
j_parser.adb:      function Full_Java_Descriptor (Start : Nat_32; Last : Nat_32)
j_parser.adb:           & Java_Descriptor (Start, Final);
j_parser.adb:      end Full_Java_Descriptor;
j_parser.adb:      -- Java_Descriptor --
j_parser.adb:      function Java_Descriptor (Start : Nat_32; Last : Nat_32) return String is
j_parser.adb:      end Java_Descriptor;
j_parser.adb:                                Java_Descriptor (Type_Entity.Start,
j_parser.adb:                                Full_Java_Descriptor (Prev_Prev_Entity.Start,
j_stack.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
j_string.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
j_table.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
j_types.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
j_utils.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
j_zip.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jarmake.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jarmake.adb:   Look_For_Java_API_Classes : Boolean := False;
jarmake.adb:   --  When set look also for classes in the Java API
jarmake.adb:   --  Java API then skip it unless Look_For_Java_API_Classes is set.
jarmake.adb:   function In_Java_API (Name : String) return Boolean;
jarmake.adb:   --  Returns True if Name is the name of a class file inside the Java API.
jarmake.adb:   -- In_Java_API --
jarmake.adb:   function In_Java_API (Name : String) return Boolean is
jarmake.adb:      if Look_For_Java_API_Classes then
jarmake.adb:   end In_Java_API;
jarmake.adb:      if In_Java_API (Class_Name) then
jarmake.adb:               if In_Java_API (Class_Name) then
jarmake.adb:               Look_For_Java_API_Classes := True;
jarmake.adb:      Put_Line ("  -j     Do not skip .class files in the Java API");
jbackend.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jdefault.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jdefault.adb:   Target               : constant String := "Java VM";
jvm-api.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm-api.adb:   --  The name of the Java package containing various Ada API classes
jvm-api.adb:   --  The name of the Java package java.lang
jvm-api.adb:   --  The name of the Java package java.io
jvm-api.adb:   --  The table of Class_Ids for various Java and Ada API classes
jvm-api.adb:   --  The table of Class_Ids for various Java interfaces
jvm-api.adb:   --  The table of Field_Ids for various Java and Ada API fields
jvm-api.adb:   --  The table of Method_Ids for various Java and Ada API methods
jvm-api.adb:      Super    : Class_Id  := Java_Lang_Object;
jvm-api.adb:      Classes (Lang_Object) := Java_Lang_Object;
jvm-api.adb:         (Acc_All, "all", Ada_Acc, Type_Of (Java_Lang_Object),
jvm-api.adb:      Add_Param (Reraise_No_Defer, Type_Of (Java_Lang_Object), "e");
jvm-api.adb:      Super    : Class_Id  := Java_Lang_Object;
jvm-code.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm-dbg.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm-emit.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm-info.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm-info.adb:   -- Java Entity Creation Operations --
jvm-map.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm-pool.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm.adb:      Super       : Class_Id  := Java_Lang_Object;
jvm.adb:            return Java_Lang_String;
jvm.adb:      Set_Superclass (Interface, Java_Lang_Object);
jvm.adb:         if Superclass (Class) /= Java_Lang_Object then
jvm.adb:   -- Java Type-related declarations and operations --
jvm.adb:      --  not generate a return statement. But the Java verifier
jvm.adb:   -- Operations for generating Java Virtual Machine instructions --
jvm.adb:               Super_Class := Java_Lang_Object;
jvm.adb:              and then Super_Class /= Java_Lang_Object
jvm.adb:              and then Super_Class /= Java_Lang_Object
jvm.adb:               pragma Assert (Class_Of_Type (Target_Type) = Java_Lang_Object);
jvm.adb:                 and then Super_Class /= Java_Lang_Object
jvm.adb:      pragma Assert (Predef_Class = Java_Lang_Object);
jvm.adb:      Set_Name       (Java_Lang_Object, Name ("Object"));
jvm.adb:      Set_Pkg_Name   (Java_Lang_Object, Str_Id ("[mscorlib]System"));
jvm.adb:      Set_Superclass (Java_Lang_Object, Null_Class);
jvm.adb:      Set_Is_Public  (Java_Lang_Object);
jvm.adb:      pragma Assert (Predef_Type = Java_Lang_Object_Type);
jvm.adb:      Set_Name      (Java_Lang_Object_Type, Name ("[mscorlib]System.Object"));
jvm.adb:      Set_Class     (Java_Lang_Object_Type, Java_Lang_Object);
jvm.adb:      pragma Assert (Predef_Class = Java_Lang_String);
jvm.adb:      Set_Name       (Java_Lang_String, Name ("String"));
jvm.adb:      Set_Pkg_Name   (Java_Lang_String, Str_Id ("[mscorlib]System"));
jvm.adb:      Set_Superclass (Java_Lang_String, Java_Lang_Object);
jvm.adb:      Set_Is_Public  (Java_Lang_String);
jvm.adb:      Set_Class     (String_Type, Java_Lang_String);
jvm.adb:      Set_Class     (JVM_String_Type, Java_Lang_String);
jvm.adb:         := New_Method (Java_Lang_Object, Name (".ctor"), Void_Type, False);
jvm2ada.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm_ada.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm_ada.adb:   --  case insensitive whereas Java is not. if a string S is present in the
jvm_ada.adb:   --  Given a Java identifier it turns it into an Ada one.
jvm_ada.adb:   --  Process the fields of the Java class file CF. If Static_Fields is
jvm_ada.adb:   --  True, only static fields from the Java file will be printed, otherwise
jvm_ada.adb:            return "Java.";
jvm_ada.adb:                     Java_Type : constant String := D (D'First + 1 .. K - 1);
jvm_ada.adb:                          & Get_Identifier (Java_Type) & ".Typ'Class";
jvm_ada.adb:                        return Get_Identifier (Java_Type) & ".Ref";
jvm_ada.adb:                        return Get_Identifier (Java_Type, Short => True);
jvm_ada.adb:               PL ("pragma Import (Java, " & Ada_Package & ", """
jvm_ada.adb:         String_List.Append ("pragma Convention (Java, Typ);", Pragma_List);
jvm_ada.adb:         PL ("pragma Convention (Java, Typ);");
jvm_ada.adb:         PL ("-- Java String to Ada String Conversion Routines --");
jvm_ada.adb:           ("pragma Import (Java, ""+"", "
jvm_ada.adb:      PL ("pragma Import (Java, " & Ada_Package
jvm_ada.adb:      --  JGNAT already contains a package Java in its library
jvm_ada.adb:      --  To be a Java package the directory name must contain only letters,
jvm_ada.adb:      --  Java API with directory java/awt/font and class java/awt/Font.class
jvm_ada.adb:      --  the Java package.
jvm_ada.adb:      PL ("pragma Import (Java, " & Ada_Name & ", """
jvm_ada.adb:                  PL ("pragma Import (Java, " & Ada_F_Name & ", """
jvm_ada.adb:                    ("pragma Import (Java, " & Ada_F_Name & ", """
jvm_ada.adb:              ("pragma Java_Constructor (" & Constructor_Name & ");",
jvm_ada.adb:              ("pragma Import (Java, " & Subprog_Name & ", """ & Name & """);",
jvm_ada.adb:         PL ("pragma Java_Interface (Typ);");
jvm_ada.adb:           ("pragma Import (Java, Except, """ & Dottify (Class_Name) & """);",
jvm_ada.adb:      PL ("with Java; use Java;");
jvm_file.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm_test.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm_view.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm_walk.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvm_walk.adb:         if Is_Java_Lang_Object (R.Constant_Pool, R.This_Class) then
jvmlist.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvmstrip.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jvmstrip.adb:      IO.Put_Line ("Strip debugging and line number information from a Java"
jx_ch11.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_ch11.adb:            --  handler entries for the predefined Java run-time exceptions
jx_ch12.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_ch3.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_ch3.adb:      --  type has convention Java. This prevents problems with types
jx_ch3.adb:         and then Convention (Repn_Type) = Convention_Java
jx_ch3.adb:           ("stand-alone object of Java-convention tagged type not allowed",
jx_ch3.adb:           ("must use access values to reference Java objects", Obj);
jx_ch3.adb:                  --  generated for a type derived from a Java API
jx_ch3.adb:                  --  call deep copy for a Java type. ???
jx_ch3.adb:      --  that implements any Java interfaces overrides each of the
jx_ch3.adb:      --  types with convention Java.
jx_ch3.adb:      if Convention (R_Type) = Convention_Java
jx_ch3.adb:               --  The designated type of the discriminant is a Java
jx_ch3.adb:            --  We disallow composite components within types with Java
jx_ch3.adb:            if Convention (R_Type) = Convention_Java then
jx_ch3.adb:                    ("composite component not allowed in Java-convention type",
jx_ch3.adb:                    ("initialization not allowed in Java-convention type",
jx_ch3.adb:            --  type has convention Java. This prevents problems with types
jx_ch3.adb:              and then Convention (Full_Type (Component)) = Convention_Java
jx_ch3.adb:                 ("component of Java-convention tagged type not allowed",
jx_ch3.adb:                 ("must use access values to reference Java objects",
jx_ch3.adb:            --  Access discriminants that denote a Java interface type
jx_ch3.adb:               if Convention (R_Type) = Convention_Java
jx_ch3.adb:               --  If the record type itself is associated with a Java
jx_ch3.adb:         --  to a Java interface.
jx_ch3.adb:      if Convention (R_Type) /= Convention_Java
jx_ch3.adb:        and then Convention (Scope (R_Type)) /= Convention_Java
jx_ch3.adb:      --  type has convention Java. This prevents problems with types
jx_ch3.adb:         and then Convention (Comp_Type) = Convention_Java
jx_ch3.adb:           ("array with components of Java-convention tagged type not allowed",
jx_ch3.adb:           ("must use access values to reference Java objects",
jx_ch3.adb:      --  be an access type designating a Java array type).
jx_ch4.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_ch4.adb:                        = Convention_Java
jx_ch4.adb:            --  conversion is unchecked, in order to satisfy the Java
jx_ch4.adb:      --  to imported Java functions returning arrays, but Ada functions
jx_ch4.adb:                  --  comes from a Java-convention package, the access
jx_ch4.adb:                  if Convention (Scope (Acc_Type)) = Convention_Java then
jx_ch4.adb:                 and then Convention (Scope (Prefix_Type)) /= Convention_Java
jx_ch4.adb:              and then Convention (Scope (Full_Type (Attr))) /= Convention_Java
jx_ch4.adb:         if JVM_Type (Left_Opnd (Expr)) = Type_Of (Java_Lang_Object) then
jx_ch4.adb:      --  type has convention Java. This prevents problems with types
jx_ch4.adb:        and then Convention (Alloc_Type) = Convention_Java
jx_ch4.adb:           ("allocator-created object of Java-convention tagged type" &
jx_ch4.adb:           ("must create object via call to Java constructor", Expr);
jx_ch4.adb:              or else Convention (Scope (Acc_Type)) = Convention_Java
jx_ch4.adb:                   and then (J_Type = Type_Of (Java_Lang_Object)
jx_ch4.adb:               if J_Type = Type_Of (Java_Lang_Object) then
jx_ch4.adb:               --  a Java interface type, then treat the selection specially
jx_ch4.adb:               --  Java interface type.
jx_ch4.adb:            --  For a call to a Java-imported function returning an
jx_ch4.adb:            --  in a package with convention Java).
jx_ch4.adb:              and then Convention (Entity (Name (Expr))) = Convention_Java
jx_ch4.adb:              and then Convention (Scope (Full_Type (Expr))) /= Convention_Java
jx_ch4.adb:            --  access type comes from a Java-convention package).
jx_ch4.adb:              and then Convention (Scope (Etype (Expr))) /= Convention_Java
jx_ch4.adb:         --  type comes from a Java-Convention package).
jx_ch4.adb:             Convention (Scope (Full_Type (Prefix (Arr)))) /= Convention_Java
jx_ch4.adb:        and then Convention (Scope (Desig_Subtype)) /= Convention_Java
jx_ch4.adb:         --  array value for a type from a Java-Convention package,
jx_ch4.adb:           = Convention_Java
jx_ch4.adb:            --  Java-imported packages (especially since at present
jx_ch5.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_ch6.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_ch6.adb:      --  as a Java interface. Note that nonabstract subprograms of
jx_ch6.adb:      --  type's scope has convention Java since the corresponding Java class
jx_ch6.adb:         --  If this is an init_proc for a type with convention Java,
jx_ch6.adb:         --  is a Java API, as well as preventing initialization of any
jx_ch6.adb:         --  of types implementing Java interfaces). For now at least
jx_ch6.adb:         --  types mapped to Java, and users should always initialize
jx_ch6.adb:           and then Convention (Full_Type (First_Param)) = Convention_Java
jx_ch6.adb:      --  (If we decide to allow stand-alone Java-convention tagged
jx_ch6.adb:            --  operations on Java Strings is implemented here but
jx_ch6.adb:               --  Ada String value from a Java String.
jx_ch6.adb:               Java_Name : constant String
jx_ch6.adb:               if Java_Name = "current_target_exception" then
jx_ch6.adb:               elsif Java_Name = "monitorenter" then
jx_ch6.adb:               elsif Java_Name = "monitorexit" then
jx_ch6.adb:               elsif Java_Name = "throw" then
jx_ch6.adb:            not (Convention (Subp) = Convention_Java and
jx_ch6.adb:         --  imported subprogram with convention Java, then dereference
jx_ch6.adb:         --  (unless the access type comes from a Java-convention unit,
jx_ch6.adb:         elsif Convention (Subp) = Convention_Java
jx_ch6.adb:           and then Convention (Scope (Full_Type (Actual))) /= Convention_Java
jx_ch6.adb:         --  the case where the subprogram is declared in a Java-convention
jx_ch6.adb:         --  If the called subprogram is declared in a Java-convention
jx_ch6.adb:         elsif Convention (Scope (Subp)) = Convention_Java then
jx_ch6.adb:                  Error_Msg_N ("call to Java method will dispatch?", Call);
jx_ch6.adb:        and then Convention (Subp) /= Convention_Java
jx_ch7.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_ch7.adb:      --  is an imported package spec with convention Java.
jx_ch7.adb:        and then Convention (Pkg_Entity) = Convention_Java
jx_ch8.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_decl.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_decl.adb:      Java_Package_Name : out String_Id;
jx_decl.adb:      Java_Class_Name   : out Name_Id);
jx_decl.adb:   --  Given a specified Java class interface name of the form
jx_decl.adb:      Java_Package_Name : out String_Id;
jx_decl.adb:      Java_Class_Name   : out Name_Id;
jx_decl.adb:      Java_Entity_Name  : out Name_Id);
jx_decl.adb:   --  Given a specified Java interface name of the form
jx_decl.adb:   --  that are associated with Java fields.
jx_decl.adb:      --  parent, which ensures that calls to Java superclass methods
jx_decl.adb:                      /= Convention_Java;
jx_decl.adb:      Java_Package_Name : out String_Id;
jx_decl.adb:      Java_Class_Name   : out Name_Id)
jx_decl.adb:      Java_Name : constant String := Str (Strval (Interface_Name));
jx_decl.adb:      Index     : Natural := Java_Name'Last;
jx_decl.adb:      while Index > 0 and then Java_Name (Index) /= '.' loop
jx_decl.adb:      Java_Class_Name := Name (Java_Name (Index + 1 .. Java_Name'Last));
jx_decl.adb:         Java_Package_Name := Str_Id (Java_Name (1 .. Index - 1));
jx_decl.adb:      elsif Is_Run_Time_Package (Java_Name (Index + 1 .. Java_Name'Last)) then
jx_decl.adb:         Java_Package_Name := Ada_Lib_Package;
jx_decl.adb:         Java_Package_Name := No_String;
jx_decl.adb:      Java_Package_Name : out String_Id;
jx_decl.adb:      Java_Class_Name   : out Name_Id;
jx_decl.adb:      Java_Entity_Name  : out Name_Id)
jx_decl.adb:      Java_Entity_Name := Name (Full_Name (Index + 1 .. Full_Name'Last));
jx_decl.adb:         Java_Class_Name   := No_Name;
jx_decl.adb:         Java_Package_Name := No_String;
jx_decl.adb:      Java_Class_Name := Name (Full_Name (Index + 1 .. Class_Last));
jx_decl.adb:         Java_Package_Name := Str_Id (Full_Name (1 .. Index - 1));
jx_decl.adb:         Java_Package_Name := Ada_Lib_Package;
jx_decl.adb:         Java_Package_Name := No_String;
jx_decl.adb:      function Java_Package (Pkg_Scope : Entity_Id) return String;
jx_decl.adb:      --  Returns the string name of the Java package name associated
jx_decl.adb:      --  with a package Pkg_Scope with convention Java. This is
jx_decl.adb:      function Java_Package (Pkg_Scope : Entity_Id) return String is
jx_decl.adb:         --  the (optional) Java package name.
jx_decl.adb:            return Java_Package (Parent_Scope)
jx_decl.adb:      end Java_Package;
jx_decl.adb:         --  If this is a Java-imported package, then return the
jx_decl.adb:         --  Java package name associated with the package itself.
jx_decl.adb:           and then Convention (N) = Convention_Java
jx_decl.adb:            return Str_Id (Java_Package (N));
jx_decl.adb:         --  If the entity is contained in a Java-imported package, return
jx_decl.adb:         --  the Java package name of the entity's enclosing package.
jx_decl.adb:           and then Convention (Scope (N)) = Convention_Java
jx_decl.adb:            return Str_Id (Java_Package (Scope (N)));
jx_decl.adb:         --  then return the Java package for the Ada library.
jx_decl.adb:      --  then return the Java package for the Ada library.
jx_decl.adb:            --  Java, we'll generate a new type.  Ada enumerations
jx_decl.adb:            if Convention (Disc_Type) /= Convention_Java then
jx_decl.adb:               Set_Map (Disc_Type, Type_Of (Java_Lang_Object));
jx_decl.adb:      Superclass  : Class_Id := Java_Lang_Object;
jx_decl.adb:         --  If type is tagged and its enclosing scope has convention Java,
jx_decl.adb:           and then Convention (Scope (Rec_Type)) = Convention_Java
jx_decl.adb:                  Java_Class_Name : String
jx_decl.adb:                  Java_Class_Name (1) := To_Upper (Java_Class_Name (1));
jx_decl.adb:                  return Name (Java_Class_Name);
jx_decl.adb:         --  Check whether this is a Java-convention type that represents
jx_decl.adb:         --  a Java interface type. It must be an abstract type with a
jx_decl.adb:         if Convention (Rec_Type) = Convention_Java
jx_decl.adb:      --  scope's superclass will have been set to Java_Lang_Object,
jx_decl.adb:         --  If the type represents a Java interface, then the
jx_decl.adb:      if Convention (Rec_Type) /= Convention_Java
jx_decl.adb:        and then Convention (Scope (Rec_Type)) /= Convention_Java
jx_decl.adb:        or else Convention (Scope (Designated_Atype)) = Convention_Java
jx_decl.adb:         --  in a Java-convention scope, then the access type is
jx_decl.adb:         --  package is imported from Java, so the class would
jx_decl.adb:         if Convention (Scope (Acc_Type)) = Convention_Java then
jx_decl.adb:      --  class name and (optional) Java package name.
jx_decl.adb:         if Convention (Obj_Or_Comp) = Convention_Java
jx_decl.adb:         --  access to a Java-convention type.
jx_decl.adb:                 (Directly_Designated_Type (Etype (Subp)))) = Convention_Java
jx_decl.adb:                       = Convention_Java))));
jx_decl.adb:        and then Convention (Subp) /= Convention_Java
jx_decl.adb:         --  ??? For now we require that imported subprograms have only Java,
jx_decl.adb:         --  C and Java is handled separately).
jx_decl.adb:      --  imported from Java).
jx_decl.adb:            --  the Java/JVM rules for overriding, which require the formal
jx_decl.adb:            --  a tagged type mapped onto a Java interface, then we have
jx_decl.adb:            elsif Convention (Controlling_Type) = Convention_Java
jx_decl.adb:         --  For Java-imported subprograms with access-to-unconstrained-array
jx_decl.adb:         if Convention (Subp) = Convention_Java
jx_decl.adb:         --  If the subprogram has convention Java, then retrieve
jx_decl.adb:         if Convention (Subp) = Convention_Java
jx_decl.adb:            --  Java-imported subprograms must have a user-provided
jx_decl.adb:            --  class name unless declared within a Java-imported
jx_decl.adb:                         or else Convention (Scope (Subp)) /= Convention_Java)
jx_decl.adb:                 ("class name required for Java import",
jx_decl.adb:         --  convention of the subprogram's is Java, we don't declare the
jx_decl.adb:         --  nondispatching method since the corresponding Java class has
jx_decl.adb:                  Convention (Subp) = Convention_Java and
jx_decl.adb:         --  For access-to-unconstrained-array formals of Java-convention
jx_decl.adb:         --  with convention Java.
jx_decl.adb:         if Convention (Subp) = Convention_Java
jx_decl.adb:                      = Convention_Java
jx_decl.adb:      if Convention (Exc) = Convention_Java
jx_drive.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_drive.adb:   --       predefined Java API classes (e.g., java.lang.String).
jx_drive.adb:   --       to generate Java byte code). Translate is applied to the various
jx_drive.adb:               if J_Source = Type_Of (Java_Lang_Object)
jx_drive.adb:                 or else J_Target = Type_Of (Java_Lang_Object)
jx_swtch.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
jx_uplev.adb:-- JGNAT -  The GNAT Ada 95 tool chain for the Java (TM) Virtual Machine is --
make.adb:      if Hostparm.Java_VM then
make.adb:         --  Java bytecode since ".class" files are generated instead.
par-prag.adb:           Pragma_Java_Constructor         |
par-prag.adb:           Pragma_Java_Interface           |
repinfo.adb:               --  enclosing package, as for some Java bindings and
sdefault.adb:   Target               : constant String := "Java VM";
sem_ch13.adb:      if Java_VM then
sem_disp.adb:      --  Expansion of dispatching calls is suppressed when Java_VM, because
sem_disp.adb:      if not Java_VM then
sem_mech.adb:               --  Note: Assembler, C++, Java, Stdcall also use C conventions
sem_mech.adb:                    Convention_Java      |
sem_prag.adb:         --  When the convention is Java, we also allow Import to be given
sem_prag.adb:         elsif C = Convention_Java
sem_prag.adb:         -- Java_Constructor --
sem_prag.adb:         --  pragma Java_Constructor ([Entity =>] LOCAL_NAME);
sem_prag.adb:         when Pragma_Java_Constructor => Java_Constructor : declare
sem_prag.adb:               --  an access type whose designated type has convention Java.
sem_prag.adb:                      (Designated_Type (Etype (Def_Id))) = Convention_Java
sem_prag.adb:                        = Convention_Java)
sem_prag.adb:                  Set_Convention     (Def_Id, Convention_Java);
sem_prag.adb:                    ("pragma% requires function returning a 'Java access type",
sem_prag.adb:         end Java_Constructor;
sem_prag.adb:         -- Java_Interface --
sem_prag.adb:         --  pragma Java_Interface ([Entity =>] LOCAL_NAME);
sem_prag.adb:         when Pragma_Java_Interface => Java_Interface : declare
sem_prag.adb:         end Java_Interface;
sem_prag.adb:      --  should occur for Java interface names.
sem_prag.adb:        or else Java_VM
snames.adb:         when Name_Java       => return Convention_Java;
usage.adb:   if not Hostparm.Java_VM then
