home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / doc / native / file.c next >
C/C++ Source or Header  |  1995-05-19  |  6KB  |  267 lines
  1. /*
  2.  * Copyright (c) 1994, 1995 by Sun Microsystems, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * @(#)file.c 95/01/31 1.4
  6.  *
  7.  * December 1994, Eugene Kuerner
  8.  *
  9.  *
  10.  * This file includes the native code used to implement methods in the
  11.  * demo package of classes.  Sepcifically, classes InputFile and
  12.  * OutputFile have native methods that interact with the underlying
  13.  * system.
  14.  *
  15.  * The prototype for the non-static functions are found in the JAVAH generated
  16.  * header file for the class.  Also, the JAVAH generated stubfile takes
  17.  * care of marshalling the function parameters from the JAVA world
  18.  * into the C world.
  19.  *
  20.  *
  21.  * version     1.0, 01 Dec 1994
  22.  * author    Eugene Kuerner
  23.  *
  24.  */
  25.  
  26.  
  27. /*
  28.  * First off, we need to include the JAVA internal header files
  29.  * for macros and function prototypes required to manipulate JAVA
  30.  * data structures and functions.
  31.  *
  32.  * SubPreamble.h includes the structure and macro definitions needed
  33.  * to convert JAVA data structures into C data structures.  For
  34.  * example, macros such as "unhand" are defined in StubPreamble.h.
  35.  *
  36.  * javaString.h defines the JAVA string maniuplation macros and
  37.  * routines needed to convert between JAVA and C strings.
  38.  *
  39.  */
  40. #include "StubPreamble.h"
  41. #include "javaString.h"
  42.  
  43.  
  44. /*
  45.  * These headers are special in that they are generated by JAVAH.  These
  46.  * include the C structure definitions for the JAVA classes.
  47.  *
  48.  */
  49. #include "demo_InputFile.h"
  50. #include "demo_OutputFile.h"
  51.  
  52.  
  53. /*
  54.  * These are some standard Unix headers we use to implement our system
  55.  * dependent native methods.
  56.  *
  57.  */
  58. #include <sys/types.h>
  59. #include <sys/param.h>
  60. #include <stdio.h>
  61. #include <fcntl.h>
  62. #include <errno.h>
  63.  
  64.  
  65. /*
  66.  * Here we define constants used by this module.  In our case we need
  67.  * to define out local path separator, because it is different from the
  68.  * one used in JAVA.  Note that JAVA's version path separator is
  69.  * defined in the JAVAH generated header files.
  70.  *
  71.  */
  72. #define    LOCAL_PATH_SEPARATOR    '/'
  73.  
  74.  
  75. /*
  76.  * static void
  77.  * convertPath(char *)
  78.  *
  79.  * This function provides C string path conversions from those
  80.  * separated by the File separator character to the system defined
  81.  * one.
  82.  *
  83.  */
  84. static void
  85. convertPath(char *str)
  86. {
  87.     while (*str != '\0') {
  88.     if ((*str == demo_InputFile_separatorChar) ||
  89.         (*str == demo_OutputFile_separatorChar)) {
  90.         *str = LOCAL_PATH_SEPARATOR;
  91.     }
  92.     str++;
  93.     }
  94.     return;
  95. }
  96.  
  97.  
  98. /*
  99.  * long
  100.  * demo_InputFile_open(struct Hdemo_InputFile *)
  101.  *
  102.  * This function implements the native method open in class InputFile
  103.  * from package demo.  This fact is evidenced by the name.  The
  104.  * function name is derived by concatenating the package name with the
  105.  * class name with the method name.  The semantics for this method are
  106.  * defined in the class file.
  107.  *
  108.  * The parameter to this function can be thought of as a "handle to
  109.  * a demo_InputFile object."  The actual makeup of this is the
  110.  * data portion of the class followed by the method table for the
  111.  * class.
  112.  *
  113.  */
  114. long 
  115. demo_InputFile_open(struct Hdemo_InputFile *this)
  116. {
  117.     int        fd;
  118.     char    buf[MAXPATHLEN];
  119.  
  120.     /*
  121.      * we need to convert JAVA path string into a C string and
  122.      * then change it to a system dependent path string.
  123.      * note that "unhand" gets the data portion of the handle to
  124.      * the C representation of the JAVA class InputFile.
  125.      *
  126.      */
  127.     javaString2CString(unhand(this)->path, buf, sizeof(buf));
  128.     convertPath(buf);
  129.  
  130.     /*
  131.      * now we actually call the system dependent routines to implement
  132.      * the method.  note that we could throw an exception via
  133.      * SignalError() instead of returning a boolean.
  134.      *
  135.      */
  136.     fd = open(buf, O_RDONLY);
  137.     if (fd < 0)
  138.         return(FALSE);
  139.  
  140.     /*
  141.      * on success we store the system fd into the class variable for
  142.      * future calls to this library.
  143.      *
  144.      */
  145.     unhand(this)->fd = fd;
  146.     return(TRUE);
  147. }
  148.  
  149.  
  150. /*
  151.  * void
  152.  * demo_InputFile_close(struct Hdemo_InputFile *)
  153.  *
  154.  * Implements the close method for class InputFile in package demo.
  155.  *
  156.  */
  157. void 
  158. demo_InputFile_close(struct Hdemo_InputFile *this)
  159. {
  160.      close(unhand(this)->fd);
  161.      unhand(this)->fd = -1;
  162.      return;
  163. }
  164.  
  165.  
  166. /*
  167.  * long 
  168.  * demo_InputFile_read(struct Hdemo_InputFile *, HArrayOfByte *, long )
  169.  *
  170.  * Implements the read method for class InputFile in package demo.
  171.  *
  172.  */
  173. long 
  174. demo_InputFile_read(struct Hdemo_InputFile *this, 
  175.             HArrayOfByte *buffer, 
  176.             long count)
  177. {
  178.     /*
  179.      * we use another macro here called obj_length which returns the
  180.      * length of an JAVA array object.  again, unhand of the Array
  181.      * object gets us the data structure portion of the object.
  182.      *
  183.      */
  184.     char *data    = unhand(buffer)->body;
  185.     int  len    = obj_length(buffer);
  186.     int  actual;
  187.  
  188.     if (len < count) {
  189.     actual = len;
  190.     }
  191.     else {
  192.     actual = count;
  193.     }
  194.     actual = read(unhand(this)->fd, data, actual);
  195.     if (actual == 0)
  196.     return(-1);
  197.     return(actual);
  198. }
  199.  
  200.  
  201. /*
  202.  * long 
  203.  * demo_OutputFile_open(struct Hdemo_OutputFile *)
  204.  *
  205.  * Implements the open method for class OutputFile in package demo.
  206.  * It is virually identical to demo_InputFile_open.  Please, refer to the
  207.  * comments for that function for more information.
  208.  *
  209.  */
  210. long 
  211. demo_OutputFile_open(struct Hdemo_OutputFile *this)
  212. {
  213.     int        fd;
  214.     char    buf[MAXPATHLEN];
  215.  
  216.     javaString2CString(unhand(this)->path, buf, sizeof(buf));
  217.     convertPath(buf);
  218.     fd = open(buf, O_RDWR|O_CREAT|O_TRUNC, 0644);
  219.     if (fd < 0)
  220.         return(FALSE);
  221.     unhand(this)->fd = fd;
  222.     return(TRUE);
  223. }
  224.  
  225.  
  226. /*
  227.  * void 
  228.  * demo_OutputFile_close(struct Hdemo_OutputFile *)
  229.  *
  230.  * Implements the close method for class OutputFile in package demo.
  231.  *
  232.  */
  233. void 
  234. demo_OutputFile_close(struct Hdemo_OutputFile *this)
  235. {
  236.     close(unhand(this)->fd);
  237.     unhand(this)->fd = -1;
  238.     return;
  239. }
  240.  
  241.  
  242. /*
  243.  * long 
  244.  * demo_OutputFile_write(struct Hdemo_OutputFile *, HArrayOfByte *, long )
  245.  *
  246.  * Implements the write method for class OutputFile in package demo.
  247.  *
  248.  */
  249. long 
  250. demo_OutputFile_write(struct Hdemo_OutputFile *this, 
  251.               HArrayOfByte *buffer, 
  252.               long count)
  253. {
  254.     char *data    = unhand(buffer)->body;
  255.     int  len    = obj_length(buffer);
  256.     int  actual;
  257.  
  258.     if (len < count) {
  259.     actual = len;
  260.     }
  261.     else {
  262.     actual = count;
  263.     }
  264.     actual = write(unhand(this)->fd, data, actual);
  265.     return(actual);
  266. }
  267.