generateCodeFiles    package:RGtkBindingGenerator    R Documentation

~~_f_u_n_c_t_i_o_n _t_o _d_o ... ~~

_D_e_s_c_r_i_p_t_i_o_n:

     This is the top-level entry point for the read-generate process
     which creates S- and C-language bindings for Gtk-based libraries
     from symbolic IDL-like descriptions of classes, routines,
     enumerations, etc. This reads the description (or .defs) files and
     generates S and C code to interfae to the code described within
     them.

_U_s_a_g_e:

     generateCodeFiles(..., classNames = NULL, dir = c(C="/tmp", S="tmp"),
                        verbose = FALSE, constructorFile = "constructors.R",
                        package = "RGtk", allDefs = NULL)

_A_r_g_u_m_e_n_t_s:

     ...: a collection of .defs files  (with or without their .defs
          extension) from which we read the description of the classes,
          routines, enumerations, etc.

classNames: 

     dir: usually, a named-character vector giving the names of the
          directories in which to create the C and S code. The names of
          the elements must be "C" and "S", respectively. If one
          requires finer control over the names of and where the files
          are located (e.g. to place the different C files in different
          directories), you can supply a function that is given the
          base name of the file to create and returns the fully
          qualified file name.  

 verbose: a logical value controlling whether information is written to
          the console about how the processing and generating of the
          code is being done. 'TRUE' means provide information to the
          ``user'', i.e. the caller   of this function.

constructorFile: the name of the file in which to place the constructor
          functions.

 package: the name of the package in which this generated code will be
          located. This is used in the code that makes calls to '.C'
          and '.Call' (actually '.GtkCall') functions in the generated
          code. 

 allDefs: any previously existing definitions (e.g. the base Gtk defs) 
          which are used to locate classes, enumerations, etc.
          referenced in these Gtk library definitions. This is mainly
          used when we are processing defs files outside of the core 
          Gtk library but need some of the definitions from the latter.

_D_e_t_a_i_l_s:

     This uses Python code to read the .defs files and uses the <URL:
     http://www.omegahat.org/RSPython> package to do this from R and
     return the results (as recursive named lists of character strings)
     to R where we then generate the code.

_V_a_l_u_e:

     A list giving the definitions read from the different .defs files
     and 

 allDefs: the class, function, enumeration, flag and box definitions
          from the .defs files

 klasses: a list with an element for each of the .defs files. Each
          element is character vector giving the names of the classes
          within

_A_u_t_h_o_r(_s):

     Duncan Temple Lang <duncan@research.bell-labs.com>

_R_e_f_e_r_e_n_c_e_s:

     <URL: http://www.omegahat.org/RGtk> <URL:
     http://www.omegahat.org/GtkAutoBindingGen>   <URL:
     http://www.gtk.org>

_S_e_e _A_l_s_o:

     'genCode' 'getDefs' 'genLoadClassesCode'

_E_x_a_m_p_l_e_s:

