home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Sample.bin / readme.txt < prev    next >
Text File  |  1997-09-08  |  9KB  |  213 lines
  1. ========================
  2. README for Win32 Samples
  3. ========================
  4.  
  5. This readme.txt file provides a brief description of the contents
  6. of the subdirectories contained in this directory.  
  7.  
  8. These subdirectories try to show different possible scenarios of 
  9. building Win32 native code from Java source code.  They contain
  10. tutorial type examples.
  11.  
  12. A makefile is provided in each subdirectory to build the example.
  13. Some of the subdirectories contain Visual Cafe project(s) that
  14. are already set up to build the example.  We intentionally did 
  15. not supply project files for some of the examples because these
  16. particular ones require additional command line tools to process.
  17.  
  18. The following lines briefly describe the build process of
  19. each example.
  20.  
  21. simple
  22. --------------
  23. - Two java source files are compiled into an executable.
  24.  
  25.  
  26. staticDLL
  27. --------------
  28. - Hello2.java is compiled into hello2.dll producing an
  29.   import library (hello2.lib) in the process.
  30.   
  31. - Main2.java is compiled and linked with hello2.lib to
  32.   produce staticDLL.exe.  
  33.   
  34. - In order to run staticDLL.exe, the directory location of 
  35.   hello2.dll should be in the PATH environment variable.
  36.  
  37.  
  38. dynamicDLL
  39. --------------
  40. - Hello3.java is compiled into hello3.dll.
  41.  
  42. - Main3.java is compiled into dynamicDLL.exe.
  43.  
  44. - hello3.dll has to be registered in the Windows registry
  45.   file in order for the class Hello3 to be found when
  46.   dynamicDLL.exe is run.  Refer to the Visual Cafe on-line 
  47.   help on how to register a DLL using the snjreg tool.
  48.   
  49.  
  50. resource
  51. --------------
  52. - The example in this directory shows how to bind resources into
  53.   an executable.
  54.  
  55. - Hello4.java contains class Hello4 that is a window application.
  56.   It uses Class.getResourceAsStream() method to query a property
  57.   list file named property.list.  It will also load a GIF image
  58.   file symlogo.gif and display it on its window.
  59.  
  60. - hello4.res is a resource file generated using the snjres tool
  61.   from the file 'property.list' and the gif image file 'symlogo.gif'.
  62.   It can be generated using the following command line from the
  63.   resource\src directory:
  64.   
  65.   snjres -f hello4.res samples\resource\property.list samples\resource\symlogo.gif  
  66.   
  67.   Note that in this example we have the package name directory 
  68.   structure for the resource files.
  69.   
  70. - In the Visual Cafe project 'resource', take note that hello4.res is 
  71.   included as a compiler flag option.
  72.  
  73.  
  74. jni1
  75. --------------
  76. - The example in this directory shows how to compile a Java code
  77.   that contains a native method, into an executable.
  78.  
  79. - Hello5Impl.cpp is the C++ implementation of the native method.
  80.  
  81. - Hello5.java is compiled into a class file.  The class file is needed 
  82.   to create the C++ header file Hello5.h for Hello5Impl.cpp.  In this 
  83.   example, the header file is in jni format.
  84.   
  85. - Hello5Impl.cpp is compiled into hello5.dll producing the import
  86.   library hello5.lib as well.
  87.   
  88. - Hello5.java is then compiled and linked with hello5.lib to produce
  89.   an executable.
  90.   
  91. - Note that Microsoft's Visual C/C++ compiler will produce import
  92.   libraries in COFF format.  The sj compiler will only recognize
  93.   OMF format import libraries.  Use the COFF2OMF tool in the bin
  94.   directory to convert the import library into OMF format.
  95.  
  96.  
  97. jni2
  98. --------------
  99. - The example in this directory shows how to invoke a Win32 native 
  100.   implementation of the Java VM from within a C++ code.
  101.   
  102. - jni2.cpp contains code that calls JNI_CreateJavaVM() to create
  103.   a Java VM and it finds the Hello6 class and calls its static
  104.   method printHello(), all from the C++ code.
  105.  
  106. - Hello6.java is compiled into hello6.dll.  hello6.dll needs 
  107.   to be registered using the snjreg tool.  Refer to the Visual 
  108.   Cafe on-line help on how to register a DLL using the snjreg tool.
  109.   
  110. - jni2.cpp is compiled into jni2.exe.
  111.  
  112. - Note that the code in jni2.cpp as is will load the Java VM 
  113.   dynamically during runtime.  If static compilation with an
  114.   import library is desired, the macro STATIC has to be defined
  115.   and one can link the cpp file with the import library 
  116.   snjjni.lib (if you are using Microsoft Visual C/C++ compiler) 
  117.   or snjjni_omf.lib (if you are using Symantec C/C++ compiler).
  118.  
  119.  
  120. rmi1
  121. --------------
  122. - The example in this directory shows how to compile Java codes that
  123.   use RMI.
  124.  
  125. - In this example, there is a Hello7Server.java file that contains
  126.   the class Hello7Server which implements a remote interface defined
  127.   in Hello7.java.  The Hello7Client.java file contains the class
  128.   Hello7Client that uses RMI calls to two methods in class
  129.   Hello7Server.
  130.  
  131. - Use the makefile to build the two executables server1.exe and client1.exe.  
  132.   It will also generate the skeleton and stub source files using the rmic 
  133.   compiler.  It will then compile the skeleton and stub files into a 
  134.   DLL named hello7.dll.  
  135.  
  136. - The user will have to register hello7.dll in the host where
  137.   the server program will run.  Refer to the Visual Cafe on-line 
  138.   help on how to register a DLL using the snjreg tool.
  139.   
  140. - Before running the server program, the RMI registry has to be created 
  141.   first by running the rmiregistry tool.  There is a Win32 native version
  142.   of the rmiregistry tool called snjrmiregistry.exe.
  143.  
  144. - If you will be running the client program on a different host, you 
  145.   will need to register hello7.dll using the snjreg tool in the host
  146.   machine where the client program will run.  
  147.  
  148. - Also, you will need to supply the host name or IP address of the RMI registry 
  149.   host as a parameter in the command line, e.g.  client <registry host-name>
  150.  
  151.  
  152. rmi2
  153. --------------
  154. - The example in this directory is a slightly modified version of the
  155.   rmi1 example.  Hello8Server.java contains code that will create the
  156.   RMI registry.
  157.  
  158. - The makefile will build two executables server2.exe and client2.exe.
  159.  
  160. - It will first compile Hello8Server.java into a class file.  It then
  161.   uses that class file to generate the skeleton and the stub files
  162.   using the rmic compiler.  In building server2.exe, it compiles
  163.   Hello8Server.java, Hello8.java, Hello8Server_Skel.java (the skeleton
  164.   file) and Hello8Server_Stub.java (the stub file) together into
  165.   the server executable.  In building client2.exe, it compiles
  166.   Hello8.java, Hello8Client.java and Hello8Server_Stub.java into the
  167.   client executable.
  168.  
  169. - Note that since the RMI registry is created in the Hello8Server.java
  170.   code, this has different implications over the previous rmi1 example.
  171.  
  172.  
  173. conversion
  174. --------------
  175. - There are five subdirectories contained in this directory.  The
  176.   example in this directory tries to show steps in converting a
  177.   Java applet into a Win32 native application.  It also shows
  178.   two ways of including components into a Win32 native application
  179.   project.  Each of the subdirectories contains a Visual Cafe 
  180.   project showing a step in the conversion process.
  181.  
  182. - step1 contains a project for a Java applet.
  183.  
  184. - step2 modifies the step1 project into a Java application.  The 
  185.   file MainFrame.java is added to serve the main entry class for 
  186.   the application and as a placeholder for the applet.
  187.  
  188. - step3 tries to modify the step2 project for a Win32 application
  189.   by just changing the project options.  This project will not 
  190.   build.  Linker errors like the following ones will show up ...
  191.  
  192.   Error: out\samples\conversion\Applet1.obj(Applet1)  (65535): 
  193.      Symbol Undefined _$Classsamples_conversion_ScrollingText
  194.   Error: out\samples\conversion\Applet1.obj(Applet1)  (65535): 
  195.      Symbol Undefined _$samples_conversion_ScrollingText__4init_5__Ljava_lang_String_2II
  196.  
  197.   The java file ScrollingText.java is not included in the project and
  198.   this will cause a linker error while it will not cause any errors
  199.   in building the previous bytecode projects step1 and step2.  
  200.   
  201. - step4 added the file ScrollingText.java into the project.  The
  202.   project will now build successfully.
  203.  
  204. - step5 adds a new component called JmScale to the project by 
  205.   creating another project and adding the JmScale project as
  206.   a subproject.  The JmScale project is setup to build a DLL
  207.   from the JmScale component.  Applet1.java in the main project
  208.   is modified to contain the new component.
  209.   
  210. - Makefiles are provided as well, and they simulate the project files
  211.   in building this example.  Note that you will also get linker errors
  212.   if you use the makefile in step3 to build.
  213.