Main Page | Namespace List | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Related Pages

field.c

Go to the documentation of this file.
00001 /*!
00002  * @file field.c
00003  *
00004  * @brief Manipulate ClassFile fields.
00005  *
00006  *
00007  * @section Control
00008  *
00009  * \$URL: https://svn.apache.org/path/name/field.c $ \$Id: field.c 0 09/28/2005 dlydick $
00010  *
00011  * Copyright 2005 The Apache Software Foundation
00012  * or its licensors, as applicable.
00013  *
00014  * Licensed under the Apache License, Version 2.0 ("the License");
00015  * you may not use this file except in compliance with the License.
00016  * You may obtain a copy of the License at
00017  *
00018  *     http://www.apache.org/licenses/LICENSE-2.0
00019  *
00020  * Unless required by applicable law or agreed to in writing,
00021  * software distributed under the License is distributed on an
00022  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
00023  * either express or implied.
00024  *
00025  * See the License for the specific language governing permissions
00026  * and limitations under the License.
00027  *
00028  * @version \$LastChangedRevision: 0 $
00029  *
00030  * @date \$LastChangedDate: 09/28/2005 $
00031  *
00032  * @author \$LastChangedBy: dlydick $
00033  *         Original code contributed by Daniel Lydick on 09/28/2005.
00034  *
00035  * @section Reference
00036  *
00037  */
00038 
00039 #include "arch.h"
00040 ARCH_COPYRIGHT_APACHE(field, c, "$URL: https://svn.apache.org/path/name/field.c $ $Id: field.c 0 09/28/2005 dlydick $");
00041 
00042 
00043 #include <strings.h>
00044 
00045 #include "jvmcfg.h"
00046 #include "cfmacros.h"
00047 #include "classfile.h"
00048 #include "exit.h"
00049 #include "jvm.h"
00050 #include "jvmclass.h"
00051 #include "linkage.h"
00052 #include "utf.h"
00053 
00054 
00055 /*!
00056  * @brief Locate the field_info index for a field in a class.
00057  *
00058  * This works both with object instance fields and static class
00059  * instance fields.
00060  *
00061  *
00062  * @param  clsidx            Class index of class whose field is to be
00063  *                             located.
00064  *
00065  * @param  fldname           UTF8 constant_pool entry of name of field
00066  *                             in class.
00067  *
00068  * @param  flddesc           UTF8 constant_pool entry of description of
00069  *                             field type.
00070  *
00071  *
00072  * @returns field table index of this field in class or
00073  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink
00074  *          if not found.
00075  *
00076  *
00077  * @throws nothing.  Let caller throw an error like
00078  *         @link #JVMCLASS_JAVA_LANG_NOSUCHFIELDERROR
00079            JVMCLASS_JAVA_LANG_NOSUCHFIELDERROR@endlink if it is
00080  *         useful at that point.  The purpose of this
00081  *         function is simply to locate the field, not
00082  *         make a value judgment on the meaning of the
00083  *         search result.
00084  *
00085  */
00086 jvm_field_index field_find_by_cp_entry(jvm_class_index  clsidx,
00087                                        cp_info_dup     *fldname,
00088                                        cp_info_dup     *flddesc)
00089 {
00090     /* Prohibit invalid parameter */
00091     if (jvm_class_index_null == clsidx)
00092     {
00093         exit_throw_exception(EXIT_JVM_FIELD,
00094                              JVMCLASS_JAVA_LANG_INTERNALERROR);
00095     }
00096 
00097     /* Point to class structure, then look for field  */
00098     ClassFile *pcfs = CLASS_OBJECT_LINKAGE(clsidx)->pcfs;
00099 
00100     u2 fcount = pcfs->fields_count;
00101     jvm_field_index fldidx;
00102     for (fldidx = 0; fldidx < fcount; fldidx++)
00103     {
00104         /* If field name and description match, go run thread */
00105         if ((0 == utf_pcfs_strcmp(PTR_THIS_CP_Utf8(fldname),
00106                                  pcfs,
00107                                  pcfs->fields[fldidx]->name_index))
00108             &&
00109             (0 == utf_pcfs_strcmp(PTR_THIS_CP_Utf8(flddesc),
00110                                  pcfs,
00111                                  pcfs
00112                                    ->fields[fldidx]
00113                                      ->descriptor_index)))
00114         {
00115             return(fldidx);
00116         }
00117     }
00118 
00119     /* Not found */
00120     return(jvm_field_index_bad);
00121 
00122 } /* END of field_find_by_cp_entry() */
00123 
00124 
00125 /*!
00126  * @brief Determine if a field index is to a static class instance
00127  * field or not.
00128  *
00129  *
00130  * @param  clsidx            Class index of class whose field is to be
00131  *                             located.
00132  *
00133  * @param  fldidx            Field index in class of field to be located
00134  *
00135  *
00136  * @returns @link #rtrue rtrue@endlink if this field is a class static
00137  *          field, otherwise @link #rfalse rfalse@endlink.
00138  *
00139  *
00140  */
00141 rboolean field_index_is_class_static(jvm_class_index clsidx,
00142                                      jvm_field_index fldidx)
00143 {
00144     /* Prohibit invalid parameter */
00145     if (jvm_field_index_bad == fldidx)
00146     {
00147         return(rfalse);
00148     }
00149 
00150     jvm_field_lookup_index csflidx;
00151     for (csflidx= 0;
00152          csflidx < CLASS(clsidx).num_class_static_field_lookups;
00153          csflidx++)
00154     {
00155         /*
00156          * Report a match when field index is
00157          * found in static class fields table
00158          */
00159         if (fldidx ==
00160             (CLASS(clsidx).class_static_field_lookup)[csflidx])
00161         {
00162             return(rtrue);
00163         }
00164     }
00165 
00166     /* Not found */
00167     return(rfalse);
00168 
00169 } /* END of field_index_is_class_static() */
00170 
00171 
00172 /*!
00173  * @brief Determine if a field name/descriptor is a static class
00174  * instance field or not.
00175  *
00176  *
00177  * @param  clsidx            Class index of class whose field is to be
00178  *                             located.
00179  *
00180  * @param  fldname           UTF8 constant_pool entry of name of field
00181  *                             in class.
00182  *
00183  * @param  flddesc           UTF8 constant_pool entry of description of
00184  *                             field type.
00185  *
00186  * @returns @link #rtrue rtrue@endlink if this field is a class static
00187  *          field, otherwise @link #rfalse rfalse@endlink.
00188  *
00189  */
00190 rboolean field_name_is_class_static(jvm_class_index  clsidx,
00191                                     cp_info_dup     *fldname,
00192                                     cp_info_dup     *flddesc)
00193 {
00194     return(field_index_is_class_static(
00195                clsidx,
00196                field_find_by_cp_entry(clsidx, fldname, flddesc)));
00197 
00198 } /* END of field_name_is_class_static() */
00199 
00200 
00201 /*!
00202  * @brief Determine if a field index is to an object instance field
00203  * or not.
00204  *
00205  *
00206  * @param  clsidx            Class index of class whose field is to be
00207  *                             located.
00208  *
00209  * @param  fldidx            Field index in class of field to be located
00210  *
00211  *
00212  * @returns @link #rtrue rtrue@endlink if this field is an object
00213  *          instance field, otherwise @link #rfalse rfalse@endlink.
00214  *
00215  */
00216 rboolean field_index_is_object_instance(jvm_class_index clsidx,
00217                                         jvm_field_index fldidx)
00218 {
00219     /* Prohibit invalid parameter */
00220     if (jvm_field_index_bad == fldidx)
00221     {
00222         return(rfalse);
00223     }
00224 
00225     jvm_field_lookup_index oiflidx;
00226     for (oiflidx= 0;
00227          oiflidx < CLASS(clsidx).num_object_instance_field_lookups;
00228          oiflidx++)
00229     {
00230         /*
00231          * Report a match when field index is
00232          * found in static class fields table
00233          */
00234         if (fldidx ==
00235             (CLASS(clsidx).object_instance_field_lookup)[oiflidx])
00236         {
00237             return(rtrue);
00238         }
00239     }
00240 
00241     /* Not found */
00242     return(rfalse);
00243 
00244 } /* END of field_index_is_object_instance() */
00245 
00246 
00247 /*!
00248  * @brief Determine if a field name/descriptor is to an object instance
00249  * field or not.
00250  *
00251  *
00252  * @param  clsidx            Class index of class whose field is to be
00253  *                             located.
00254  *
00255  * @param  fldname           UTF8 constant_pool entry of name of field
00256  *                             in class.
00257  *
00258  * @param  flddesc           UTF8 constant_pool entry of description of
00259  *                             field type.
00260  *
00261  *
00262  * @returns @link #rtrue rtrue@endlink if this field is an object
00263  *          instance field, otherwise @link #rfalse rfalse@endlink.
00264  *
00265  */
00266 rboolean field_name_is_object_instance(jvm_class_index   clsidx,
00267                                        cp_info_dup     *fldname,
00268                                        cp_info_dup     *flddesc)
00269 {
00270     return(field_index_is_object_instance(
00271                clsidx,
00272                field_find_by_cp_entry(clsidx, fldname, flddesc)));
00273 
00274 } /* END of field_name_is_object_instance() */
00275 
00276 
00277 /*!
00278  * @brief Retrieve by field index a field lookup index to a static
00279  * class instance field.
00280  *
00281  *
00282  * @param  clsidx            Class index of class whose field is to be
00283  *                             located.
00284  *
00285  * @param  fldidx            Field index in class of field to be located
00286  *
00287  *
00288  * @returns class static field lookup index of located field, otherwise
00289  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink.
00290  *
00291  */
00292 jvm_field_lookup_index
00293     field_index_get_class_static_lookup(jvm_class_index  clsidx,
00294                                         jvm_field_index fldidx)
00295 {
00296     /* Prohibit invalid parameter */
00297     if (jvm_field_index_bad == fldidx)
00298     {
00299         return(jvm_field_lookup_index_bad);
00300     }
00301 
00302     jvm_field_lookup_index csflidx;
00303     for (csflidx= 0;
00304          csflidx < CLASS(clsidx).num_class_static_field_lookups;
00305          csflidx++)
00306     {
00307         /*
00308          * Report a match when field index is
00309          * found in static class fields table
00310          */
00311         if (fldidx ==
00312             (CLASS(clsidx).class_static_field_lookup)[csflidx])
00313         {
00314             return(fldidx);
00315         }
00316     }
00317 
00318     /* Not found */
00319     return(jvm_field_lookup_index_bad);
00320 
00321 } /* END of field_index_get_class_static_lookup() */
00322 
00323 
00324 /*!
00325  * @brief Retrieve by name/descriptor a field lookup index to a static
00326  * class instance field.
00327  *
00328  *
00329  * @param  clsidx            Class index of class whose field is to be
00330  *                             located.
00331  *
00332  * @param  fldname           UTF8 constant_pool entry of name of field
00333  *                             in class.
00334  *
00335  * @param  flddesc           UTF8 constant_pool entry of description of
00336  *                             field type.
00337  *
00338  * @returns class static field lookup index of located field, otherwise
00339  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink.
00340  *
00341  */
00342 jvm_field_lookup_index
00343     field_name_get_class_static_lookup(jvm_class_index  clsidx,
00344                                        cp_info_dup     *fldname,
00345                                        cp_info_dup     *flddesc)
00346 {
00347     return(field_index_get_class_static_lookup(
00348                clsidx,
00349                field_find_by_cp_entry(clsidx, fldname, flddesc)));
00350 
00351 
00352 } /* END of field_name_get_class_static_lookup() */
00353 
00354 
00355 /*!
00356  * @brief Retrieve by field index a field lookup index to an object
00357  * instance field.
00358  *
00359  *
00360  * @param  clsidx            Class index of class whose field is to be
00361  *                             located.
00362  *
00363  * @param  fldidx            Field index in class of field to be located
00364  *
00365  *
00366  * @returns object instance field lookup index of located field,
00367  *          otherwise
00368  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink.
00369  *
00370  */
00371 jvm_field_lookup_index
00372     field_index_get_object_instance_lookup(jvm_class_index  clsidx,
00373                                            jvm_field_index fldidx)
00374 {
00375     /* Prohibit invalid parameter */
00376     if (jvm_field_index_bad == fldidx)
00377     {
00378         return(rfalse);
00379     }
00380 
00381     jvm_field_lookup_index oiflidx;
00382     for (oiflidx= 0;
00383          oiflidx < CLASS(clsidx).num_object_instance_field_lookups;
00384          oiflidx++)
00385     {
00386         /*
00387          * Report a match when field index is
00388          * found in static class fields table
00389          */
00390         if (fldidx ==
00391             (CLASS(clsidx).object_instance_field_lookup)[oiflidx])
00392         {
00393             return(rtrue);
00394         }
00395     }
00396 
00397     /* Not found */
00398     return(rfalse);
00399 
00400 } /* END of field_index_get_object_instance_lookup() */
00401 
00402 
00403 /*!
00404  * @brief Retrieve by name/descriptor a field lookup index to an object
00405  * instance field.
00406  *
00407  *
00408  * @param  clsidx            Class index of class whose field is to be
00409  *                             located.
00410  *
00411  * @param  fldname           UTF8 constant_pool entry of name of field
00412  *                             in class.
00413  *
00414  * @param  flddesc           UTF8 constant_pool entry of description of
00415  *                             field type.
00416  *
00417  *
00418  * @returns object instance field lookup index of located field,
00419  *          otherwise 
00420  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink.
00421  *
00422  */
00423 jvm_field_lookup_index
00424     field_name_get_object_instance_lookup(jvm_class_index  clsidx,
00425                                           cp_info_dup     *fldname,
00426                                           cp_info_dup     *flddesc)
00427 {
00428     return(field_index_get_object_instance_lookup(
00429                clsidx,
00430                field_find_by_cp_entry(clsidx, fldname, flddesc)));
00431 
00432 
00433 } /* END of field_name_get_object_instance_lookup() */
00434 
00435 
00436 /*!
00437  * @brief Retrieve by field index the value of a static class instance
00438  * field.
00439  *
00440  *
00441  * @param  clsidx            Class index of class whose field is to be
00442  *                             located.
00443  *
00444  * @param  fldidx            Field index in class of field to be located
00445  *
00446  *
00447  * @returns pointer to class static field data, otherwise
00448  *          @link #rnull rnull@endlink.
00449  *
00450  */
00451 jvalue *field_index_get_class_static_pjvalue(jvm_class_index  clsidx,
00452                                              jvm_field_index fldidx)
00453 {
00454     /* Prohibit invalid parameter */
00455     if (jvm_field_index_bad == fldidx)
00456     {
00457         return((jvalue *) rnull);
00458     }
00459 
00460     jvm_field_lookup_index csflidx;
00461     for (csflidx= 0;
00462          csflidx < CLASS(clsidx).num_class_static_field_lookups;
00463          csflidx++)
00464     {
00465         /*
00466          * Report a match when field index is
00467          * found in static class fields table
00468          */
00469         if (fldidx ==
00470             (CLASS(clsidx).class_static_field_lookup)[csflidx])
00471         {
00472             return(&(CLASS(clsidx).class_static_field_data)[csflidx]);
00473         }
00474     }
00475 
00476     /* Not found */
00477     return((jvalue *) rnull);
00478 
00479 } /* END of field_index_get_class_static_pjvalue() */
00480 
00481 
00482 /*!
00483  * @brief Retrieve by name the value of a static class instance field.
00484  *
00485  *
00486  * @param  clsidx            Class index of class whose field is to be
00487  *                             located.
00488  *
00489  * @param  fldname           UTF8 constant_pool entry of name of field
00490  *                             in class.
00491  *
00492  * @param  flddesc           UTF8 constant_pool entry of description of
00493  *                             field type.
00494  *
00495  *
00496  * @returns pointer to class static field data, otherwise
00497  *          @link #rnull rnull@endlink.
00498  *
00499  */
00500 jvalue *field_name_get_class_static_pjvalue(jvm_class_index  clsidx,
00501                                             cp_info_dup     *fldname,
00502                                             cp_info_dup     *flddesc)
00503 {
00504     return(field_index_get_class_static_pjvalue(
00505                clsidx,
00506                field_find_by_cp_entry(clsidx, fldname, flddesc)));
00507 
00508 
00509 } /* END of field_name_get_class_static_pjvalue() */
00510 
00511 
00512 /*!
00513  * @brief Retrieve by field index the value of an object instance field.
00514  *
00515  *
00516  * @param  objhash           Object hash of object whose field is to be
00517  *                             located.
00518  *
00519  * @param  fldidx            Field index in class of field to be located
00520  *
00521  *
00522  * @returns Pointer to object instance field data, otherwise
00523  *          @link #rnull rnull@endlink.
00524  *
00525  */
00526 jvalue *field_index_get_object_instance_pjvalue(jvm_object_hash objhash,
00527                                                 jvm_field_index fldidx)
00528 {
00529     jvm_class_index clsidx = OBJECT_CLASS_LINKAGE(objhash)->clsidx;
00530 
00531     jvm_field_lookup_index oifldidx;
00532     for (oifldidx= 0;
00533          oifldidx < CLASS(clsidx).num_object_instance_field_lookups;
00534          oifldidx++)
00535     {
00536         /*
00537          * Report a match when field index is
00538          * found in object instance fields table
00539          */
00540         if (fldidx ==
00541             (CLASS(clsidx).object_instance_field_lookup)[oifldidx])
00542         {
00543             return(&OBJECT(objhash)
00544                         .object_instance_field_data[oifldidx]);
00545         }
00546     }
00547 
00548     /* Not found */
00549     return((jvalue *) rnull);
00550 
00551 } /* END of field_index_get_object_instance_pjvalue() */
00552 
00553 
00554 /*!
00555  * @brief Retrieve by name the value of an object instance field.
00556  *
00557  *
00558  * @param  objhash           Object hash of object whose field is to be
00559  *                             located.
00560  *
00561  * @param  fldname           UTF8 constant_pool entry of name of field
00562  *                             in class.
00563  *
00564  * @param  flddesc           UTF8 constant_pool entry of description of
00565  *                             field type.
00566  *
00567  *
00568  * @returns Pointer to object instance field data, otherwise
00569  *          @link #rnull rnull@endlink.
00570  *
00571  */
00572 jvalue *field_name_get_object_instance_pjvalue(jvm_object_hash  objhash,
00573                                                cp_info_dup     *fldname,
00574                                                cp_info_dup     *flddesc)
00575 {
00576     return(field_index_get_object_instance_pjvalue(
00577                objhash,
00578                field_find_by_cp_entry(
00579                    OBJECT_CLASS_LINKAGE(objhash)->clsidx,
00580                    fldname,
00581                    flddesc)));
00582 
00583 } /* END of field_name_get_object_instance_pjvalue() */
00584 
00585 
00586 /*!
00587  * @brief Store by field index the value of a static class instance
00588  * field.
00589  *
00590  *
00591  * @param  clsidx            Class index of class whose field is to be
00592  *                             stored.
00593  *
00594  * @param  fldidx            Field index in class of field to be stored.
00595  *
00596  *
00597  * @param  _jvalue           Data to be stored.
00598  *
00599  *
00600  * @returns Field index of field name if this is a valid class static
00601  *          field, else
00602  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink.
00603  *
00604  */
00605 jvm_field_index
00606     field_index_put_class_static_pjvalue(jvm_class_index  clsidx,
00607                                          jvm_field_index  fldidx,
00608                                          jvalue          *_jvalue)
00609 {
00610     /* Prohibit invalid parameter */
00611     if (jvm_field_index_bad == fldidx)
00612     {
00613         return(jvm_field_index_bad);
00614     }
00615 
00616     jvm_field_lookup_index csflidx;
00617     for (csflidx= 0;
00618          csflidx < CLASS(clsidx).num_class_static_field_lookups;
00619          csflidx++)
00620     {
00621         /*
00622          * Report a match when field index is
00623          * found in static class fields table
00624          */
00625         if (fldidx ==
00626             (CLASS(clsidx).class_static_field_lookup)[csflidx])
00627         {
00628             memcpy(&CLASS(clsidx).class_static_field_data[csflidx],
00629                    _jvalue,
00630                    sizeof(jvalue));
00631             return(fldidx);
00632         }
00633     }
00634 
00635     /* Not found */
00636     return(jvm_field_index_bad);
00637 
00638 } /* END of field_index_put_class_static_pjvalue() */
00639 
00640 
00641 /*!
00642  * @brief Store by name/descriptor the value of a static class
00643  * instance field.
00644  *
00645  *
00646  * @param  clsidx            Class index of class whose field is to be
00647  *                             stored.
00648  *
00649  * @param  fldname           UTF8 constant_pool entry of name of field
00650  *                             in class.
00651  *
00652  * @param  flddesc           UTF8 constant_pool entry of description of
00653  *                             field type.
00654  *
00655  * @param  _jvalue           Data to be stored.
00656  *
00657  *
00658  * @returns Field index of field name if this is a valid class static
00659  *          field, else
00660  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink.
00661  *
00662  */
00663 jvm_field_index
00664     field_name_put_class_static_pjvalue(jvm_class_index  clsidx,
00665                                         cp_info_dup     *fldname,
00666                                         cp_info_dup     *flddesc,
00667                                         jvalue          *_jvalue)
00668 {
00669     return(field_index_put_class_static_pjvalue(
00670                clsidx,
00671                field_find_by_cp_entry(clsidx,
00672                                       fldname,
00673                                       flddesc),
00674                _jvalue));
00675 
00676 } /* END of field_name_put_class_static_pjvalue() */
00677 
00678 
00679 /*!
00680  * @brief Store by field index the value of an object instance field.
00681  *
00682  *
00683  * @param  objhash           Object hash of object whose field is to be
00684  *                             located.
00685  *
00686  * @param  fldidx            Field index in class of field to be stored
00687  *
00688  * @param  _jvalue           Data to be stored.
00689  *
00690  *
00691  * @returns Field index of field name if this is a valid object instance
00692  *          field, else
00693  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink.
00694  *
00695  */
00696 jvm_field_index
00697     field_index_put_object_instance_pjvalue(jvm_object_hash  objhash,
00698                                             jvm_field_index  fldidx,
00699                                             jvalue          *_jvalue)
00700 {
00701     jvm_class_index clsidx = OBJECT_CLASS_LINKAGE(objhash)->clsidx;
00702 
00703     jvm_field_lookup_index oifldidx;
00704     for (oifldidx= 0;
00705          oifldidx < CLASS(clsidx).num_object_instance_field_lookups;
00706          oifldidx++)
00707     {
00708         /*
00709          * Report a match when field index is
00710          * found in object instance fields table
00711          */
00712         if (fldidx ==
00713             (CLASS(clsidx).object_instance_field_lookup)[oifldidx])
00714         {
00715            memcpy(&OBJECT(objhash).object_instance_field_data[oifldidx],
00716                    _jvalue,
00717                    sizeof(jvalue));
00718             return(fldidx);
00719         }
00720     }
00721 
00722     /* Not found */
00723     return(jvm_field_index_bad);
00724 
00725 } /* END of field_index_put_object_instance_pjvalue() */
00726 
00727 
00728 /*!
00729  * @brief Store by name/descriptor the value of an object
00730  * instance field.
00731  *
00732  *
00733  * @param  objhash           Object hash of object whose field is to be
00734  *                             located.
00735  *
00736  * @param  fldname           UTF8 constant_pool entry of name of field
00737  *                             in class.
00738  *
00739  * @param  flddesc           UTF8 constant_pool entry of description of
00740  *                             field type.
00741  *
00742  * @param  _jvalue           Data to be stored.
00743  *
00744  *
00745  * @returns Field index of field name if this is a valid object instance
00746  *          field, else
00747  *          @link #jvm_field_index_bad jvm_field_index_bad@endlink.
00748  *
00749  */
00750 jvm_field_index
00751     field_name_put_object_instance_pjvalue(jvm_object_hash  objhash,
00752                                            cp_info_dup     *fldname,
00753                                            cp_info_dup     *flddesc,
00754                                            jvalue          *_jvalue)
00755 {
00756     return(field_index_put_object_instance_pjvalue(
00757                objhash,
00758                field_find_by_cp_entry(
00759                    OBJECT_CLASS_LINKAGE(objhash)->clsidx,
00760                    fldname,
00761                    flddesc),
00762                _jvalue));
00763 
00764 } /* END of field_name_put_object_instance_pjvalue() */
00765 
00766 
00767 /* EOF */
00768 

Generated on Fri Sep 30 18:59:27 2005 by  doxygen 1.4.4