home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 July / CMCD0704.ISO / Software / Shareware / Comunicatii / jyte / jyte.exe / makegw.py < prev    next >
Text File  |  2003-10-06  |  17KB  |  453 lines
  1. """Utility functions for writing out gateway C++ files
  2.  
  3.   This module will generate a C++/Python binding for a specific COM
  4.   interface.
  5.   
  6.   At this stage, no command line interface exists.  You must start Python, 
  7.   import this module,  change to the directory where the generated code should
  8.   be written, and run the public function.
  9.   
  10.   This module is capable of generating both 'Interfaces' (ie, Python
  11.   client side support for the interface) and 'Gateways' (ie, Python
  12.   server side support for the interface).  Many COM interfaces are useful
  13.   both as Client and Server.  Other interfaces, however, really only make
  14.   sense to implement one side or the other.  For example, it would be pointless
  15.   for Python to implement Server side for 'IRunningObjectTable', unless we were
  16.   implementing core COM for an operating system in Python (hey - now there's an idea!)
  17.   
  18.   Most COM interface code is totally boiler-plate - it consists of
  19.   converting arguments, dispatching the call to Python, and processing
  20.   any result values.
  21.   
  22.   This module automates the generation of such code.  It has the ability to
  23.   parse a .H file generated by the MIDL tool (ie, almost all COM .h files)
  24.   and build almost totally complete C++ code.
  25.   
  26.   The module understands some of the well known data types, and how to
  27.   convert them.  There are only a couple of places where hand-editing is
  28.   necessary, as detailed below:
  29.  
  30.   unsupported types -- If a type is not known, the generator will
  31.   pretty much ignore it, but write a comment to the generated code.  You
  32.   may want to add custom support for this type.  In some cases, C++ compile errors
  33.   will result.  These are intentional - generating code to remove these errors would
  34.   imply a false sense of security that the generator has done the right thing.
  35.  
  36.   other return policies -- By default, Python never sees the return SCODE from
  37.   a COM function.  The interface usually returns None if OK, else a COM exception
  38.   if "FAILED(scode)" is TRUE.  You may need to change this if:
  39.   * EXCEPINFO is passed to the COM function.  This is not detected and handled
  40.   * For some reason Python should always see the result SCODE, even if it
  41.     did fail or succeed.  For example, some functions return a BOOLEAN result
  42.     in the SCODE, meaning Python should always see it.
  43.   * FAILED(scode) for the interface still has valid data to return (by default,
  44.     the code generated does not process the return values, and raise an exception
  45.     to Python/COM
  46.   
  47. """
  48.  
  49. import regsub
  50. import string
  51. import makegwparse
  52.  
  53. def make_framework_support(header_file_name, interface_name, bMakeInterface = 1, bMakeGateway = 1):
  54.   """Generate C++ code for a Python Interface and Gateway
  55.   
  56.   header_file_name -- The full path to the .H file which defines the interface.
  57.   interface_name -- The name of the interface to search for, and to generate.
  58.   bMakeInterface = 1 -- Should interface (ie, client) support be generated.
  59.   bMakeGatewayInterface = 1 -- Should gateway (ie, server) support be generated.
  60.   
  61.   This method will write a .cpp and .h file into the current directory,
  62.   (using the name of the interface to build the file name.
  63.   
  64.   """
  65.   fin=open(header_file_name)
  66.   try:
  67.     interface = makegwparse.parse_interface_info(interface_name, fin)
  68.   finally:
  69.     fin.close()
  70.     
  71.   if bMakeInterface and bMakeGateway:
  72.       desc = "Interface and Gateway"
  73.   elif bMakeInterface and not bMakeGateway:
  74.       desc = "Interface"
  75.   else:
  76.       desc = "Gateway"
  77.   if interface.name[:5]=="IEnum": # IEnum - use my really simple template-based one
  78.     import win32com.makegw.makegwenum
  79.     ifc_cpp_writer = win32com.makegw.makegwenum._write_enumifc_cpp
  80.     gw_cpp_writer = win32com.makegw.makegwenum._write_enumgw_cpp
  81.   else: # Use my harder working ones.
  82.     ifc_cpp_writer = _write_ifc_cpp
  83.     gw_cpp_writer = _write_gw_cpp
  84.       
  85.   fout=open("Py%s.cpp" % interface.name, "w")
  86.   try:
  87.     fout.write(\
  88. '''\
  89. // This file implements the %s %s for Python.
  90. // Generated by makegw.py
  91.  
  92. #include "shell_pch.h"
  93. ''' % (interface.name, desc))
  94. #    if bMakeGateway:
  95. #      fout.write('#include "PythonCOMServer.h"\n')
  96. #    if interface.base not in ["IUnknown", "IDispatch"]:
  97. #      fout.write('#include "Py%s.h"\n' % interface.base)
  98.     fout.write('#include "Py%s.h"\n\n// @doc - This file contains autoduck documentation\n' % interface.name)
  99.     if bMakeInterface: ifc_cpp_writer(fout, interface)
  100.     if bMakeGateway: gw_cpp_writer(fout, interface)
  101.   finally:
  102.     fout.close()
  103.   fout=open("Py%s.h" % interface.name, "w")
  104.   try:
  105.     fout.write(\
  106. '''\
  107. // This file declares the %s %s for Python.
  108. // Generated by makegw.py
  109. ''' % (interface.name, desc))
  110.  
  111.     if bMakeInterface: _write_ifc_h(fout, interface)
  112.     if bMakeGateway: _write_gw_h(fout, interface)
  113.   finally:
  114.     fout.close()
  115.  
  116. ###########################################################################
  117. #
  118. # INTERNAL FUNCTIONS
  119. #
  120. #
  121.  
  122. def _write_ifc_h(f, interface):
  123.   f.write(\
  124. '''\
  125. // ---------------------------------------------------
  126. //
  127. // Interface Declaration
  128.  
  129. class Py%s : public Py%s
  130. {
  131. public:
  132.     MAKE_PYCOM_CTOR(Py%s);
  133.     static %s *GetI(PyObject *self);
  134.     static PyComTypeObject type;
  135.  
  136.     // The Python methods
  137. ''' % (interface.name, interface.base, interface.name, interface.name))
  138.   for method in interface.methods:
  139.     f.write('\tstatic PyObject *%s(PyObject *self, PyObject *args);\n' % method.name)
  140.   f.write(\
  141. '''\
  142.  
  143. protected:
  144.     Py%s(IUnknown *pdisp);
  145.     ~Py%s();
  146. };
  147. ''' % (interface.name, interface.name))
  148.  
  149. def _write_ifc_cpp(f, interface):
  150.   name = interface.name
  151.   f.write(\
  152. '''\
  153. // ---------------------------------------------------
  154. //
  155. // Interface Implementation
  156.  
  157. Py%(name)s::Py%(name)s(IUnknown *pdisp):
  158.     Py%(base)s(pdisp)
  159. {
  160.     ob_type = &type;
  161. }
  162.  
  163. Py%(name)s::~Py%(name)s()
  164. {
  165. }
  166.  
  167. /* static */ %(name)s *Py%(name)s::GetI(PyObject *self)
  168. {
  169.     return (%(name)s *)Py%(base)s::GetI(self);
  170. }
  171.  
  172. ''' % (interface.__dict__))
  173.  
  174.   ptr = regsub.gsub('[a-z]', '', interface.name)
  175.   strdict = {'interfacename':interface.name, 'ptr': ptr}
  176.   for method in interface.methods:
  177.     strdict['method'] = method.name
  178.     f.write(\
  179. '''\
  180. // @pymethod |Py%(interfacename)s|%(method)s|Description of %(method)s.
  181. PyObject *Py%(interfacename)s::%(method)s(PyObject *self, PyObject *args)
  182. {
  183.     %(interfacename)s *p%(ptr)s = GetI(self);
  184.     if ( p%(ptr)s == NULL )
  185.         return NULL;
  186. ''' % strdict)
  187.     argsParseTuple = argsCOM = formatChars = codePost = \
  188.                      codePobjects = codeCobjects = cleanup = cleanup_gil = ""
  189.     needConversion = 0
  190. #    if method.name=="Stat": import win32dbg;win32dbg.brk()
  191.     for arg in method.args:
  192.       try:
  193.         argCvt = makegwparse.make_arg_converter(arg)
  194.         if arg.HasAttribute("in"):
  195.           val = argCvt.GetFormatChar()
  196.           if val:
  197.             f.write ('\t' + argCvt.GetAutoduckString() + "\n")
  198.             formatChars = formatChars + val
  199.             argsParseTuple = argsParseTuple + ", " + argCvt.GetParseTupleArg()
  200.             codePobjects = codePobjects + argCvt.DeclareParseArgTupleInputConverter()
  201.             codePost = codePost + argCvt.GetParsePostCode()
  202.             needConversion = needConversion or argCvt.NeedUSES_CONVERSION()
  203.             cleanup = cleanup + argCvt.GetInterfaceArgCleanup()
  204.             cleanup_gil = cleanup_gil + argCvt.GetInterfaceArgCleanupGIL()
  205.         comArgName, comArgDeclString = argCvt.GetInterfaceCppObjectInfo()
  206.         if comArgDeclString: # If we should declare a variable
  207.           codeCobjects = codeCobjects + "\t%s;\n" % (comArgDeclString)
  208.         argsCOM = argsCOM + ", " + comArgName
  209.       except makegwparse.error_not_supported, why:
  210.         f.write('// *** The input argument %s of type "%s" was not processed ***\n//     Please check the conversion function is appropriate and exists!\n' % (arg.name, arg.raw_type))
  211.  
  212.         f.write('\t%s %s;\n\tPyObject *ob%s;\n' % (arg.type, arg.name, arg.name))
  213.         f.write('\t// @pyparm <o Py%s>|%s||Description for %s\n' % (arg.type, arg.name, arg.name))
  214.         codePost = codePost + '\tif (bPythonIsHappy && !PyObject_As%s( ob%s, &%s )) bPythonIsHappy = FALSE;\n' % (arg.type, arg.name, arg.name)
  215.  
  216.         formatChars = formatChars + "O"
  217.         argsParseTuple = argsParseTuple + ", &ob%s" % (arg.name)
  218.  
  219.         argsCOM = argsCOM + ", " + arg.name
  220.         cleanup = cleanup + "\tPyObject_Free%s(%s);\n" % (arg.type, arg.name)
  221.  
  222.     if needConversion: f.write("\tUSES_CONVERSION;\n")
  223.     f.write(codePobjects);
  224.     f.write(codeCobjects);
  225.     f.write('\tif ( !PyArg_ParseTuple(args, "%s:%s"%s) )\n\t\treturn NULL;\n' % (formatChars, method.name, argsParseTuple))
  226.     if codePost:
  227.       f.write('\tBOOL bPythonIsHappy = TRUE;\n')
  228.       f.write(codePost);
  229.       f.write('\tif (!bPythonIsHappy) return NULL;\n')
  230.     strdict['argsCOM'] = argsCOM[1:]
  231.     strdict['cleanup'] = cleanup
  232.     strdict['cleanup_gil'] = cleanup_gil
  233.     f.write(\
  234. '''    HRESULT hr;
  235.     PY_INTERFACE_PRECALL;
  236.     hr = p%(ptr)s->%(method)s(%(argsCOM)s );
  237. %(cleanup)s
  238.     PY_INTERFACE_POSTCALL;
  239. %(cleanup_gil)s
  240.     if ( FAILED(hr) )
  241.         return PyCom_BuildPyException(hr, p%(ptr)s, IID_%(interfacename)s );
  242. ''' % strdict)
  243.     codePre = codePost = formatChars = codeVarsPass = codeDecl = ""
  244.     for arg in method.args:
  245.       if not arg.HasAttribute("out"):
  246.         continue
  247.       try:
  248.         argCvt =  makegwparse.make_arg_converter(arg)
  249.         formatChar = argCvt.GetFormatChar()
  250.         if formatChar:
  251.           formatChars = formatChars + formatChar
  252.           codePre = codePre + argCvt.GetBuildForInterfacePreCode()
  253.           codePost = codePost + argCvt.GetBuildForInterfacePostCode()
  254.           codeVarsPass = codeVarsPass + ", " + argCvt.GetBuildValueArg()
  255.           codeDecl = codeDecl + argCvt.DeclareParseArgTupleInputConverter()
  256.       except makegwparse.error_not_supported, why:
  257.         f.write('// *** The output argument %s of type "%s" was not processed ***\n//     %s\n' % (arg.name, arg.raw_type, why))
  258.         continue
  259.     if formatChars:
  260.       f.write('%s\n%s\tPyObject *pyretval = Py_BuildValue("%s"%s);\n%s\treturn pyretval;' % (codeDecl, codePre, formatChars, codeVarsPass, codePost))
  261.     else:
  262.       f.write('\tPy_INCREF(Py_None);\n\treturn Py_None;\n')
  263.     f.write('\n}\n\n')
  264.  
  265.   f.write ('// @object Py%s|Description of the interface\n' % (name))
  266.   f.write('static struct PyMethodDef Py%s_methods[] =\n{\n' % name)
  267.   for method in interface.methods:
  268.     f.write('\t{ "%s", Py%s::%s, 1 }, // @pymeth %s|Description of %s\n' % (method.name, interface.name, method.name, method.name, method.name))
  269.  
  270.   interfacebase = interface.base
  271.   f.write('''\
  272.     { NULL }
  273. };
  274.  
  275. PyComTypeObject Py%(name)s::type("Py%(name)s",
  276.         &Py%(interfacebase)s::type,
  277.         sizeof(Py%(name)s),
  278.         Py%(name)s_methods,
  279.         GET_PYCOM_CTOR(Py%(name)s));
  280. ''' % locals())
  281.  
  282. def _write_gw_h(f, interface):
  283.   if interface.name[0] == "I":
  284.     gname = 'PyG' + interface.name[1:]
  285.   else:
  286.     gname = 'PyG' + interface.name
  287.   name = interface.name
  288.   if interface.base == "IUnknown" or interface.base == "IDispatch":
  289.     base_name = "PyGatewayBase"
  290.   else:
  291.     if interface.base[0] == "I":
  292.       base_name = 'PyG' + interface.base[1:]
  293.     else:
  294.       base_name = 'PyG' + interface.base
  295.   f.write(\
  296. '''\
  297. // ---------------------------------------------------
  298. //
  299. // Gateway Declaration
  300.  
  301. class %s : public %s, public %s
  302. {
  303. protected:
  304.     %s(PyObject *instance) : %s(instance) { ; }
  305.     PYGATEWAY_MAKE_SUPPORT2(%s, %s, IID_%s, %s)
  306.  
  307. ''' % (gname, base_name, name, gname, base_name, gname, name, name, base_name))
  308.   if interface.base != "IUnknown":
  309.     f.write("\t// %s\n\t// *** Manually add %s method decls here\n\n" % (interface.base, interface.base))
  310.   else:
  311.     f.write('\n\n')
  312.  
  313.   f.write("\t// %s\n" % name)
  314.  
  315.   for method in interface.methods:
  316.     f.write('\tSTDMETHOD(%s)(\n' % method.name)
  317.     if method.args:
  318.       for arg in method.args[:-1]:
  319.         f.write("\t\t%s,\n" % (arg.GetRawDeclaration()))
  320.       arg = method.args[-1]
  321.       f.write("\t\t%s);\n\n" % (arg.GetRawDeclaration()))
  322.     else:
  323.       f.write('\t\tvoid);\n\n')
  324.  
  325.   f.write('};\n')
  326.   f.close()
  327.  
  328. def _write_gw_cpp(f, interface):
  329.   if interface.name[0] == "I":
  330.     gname = 'PyG' + interface.name[1:]
  331.   else:
  332.     gname = 'PyG' + interface.name
  333.   name = interface.name
  334.   if interface.base == "IUnknown" or interface.base == "IDispatch":
  335.     base_name = "PyGatewayBase"
  336.   else:
  337.     if interface.base[0] == "I":
  338.       base_name = 'PyG' + interface.base[1:]
  339.     else:
  340.       base_name = 'PyG' + interface.base
  341.   f.write('''\
  342. // ---------------------------------------------------
  343. //
  344. // Gateway Implementation
  345. ''' % {'name':name, 'gname':gname, 'base_name':base_name})
  346.  
  347.   for method in interface.methods:
  348.     f.write(\
  349. '''\
  350. STDMETHODIMP %s::%s(
  351. ''' % (gname, method.name))
  352.  
  353.     if method.args:
  354.       for arg in method.args[:-1]:
  355.         inoutstr = string.join(arg.inout, '][')
  356.         f.write("\t\t/* [%s] */ %s,\n" % (inoutstr, arg.GetRawDeclaration()))
  357.         
  358.       arg = method.args[-1]
  359.       inoutstr = string.join(arg.inout, '][')
  360.       f.write("\t\t/* [%s] */ %s)\n" % (inoutstr, arg.GetRawDeclaration()))
  361.     else:
  362.       f.write('\t\tvoid)\n')
  363.  
  364.     f.write("{\n\tPY_GATEWAY_METHOD;\n")
  365.     cout = 0
  366.     codePre = codePost = codeVars = ""
  367.     argStr = ""
  368.     needConversion = 0
  369.     formatChars = ""
  370.     if method.args:
  371.       for arg in method.args:
  372.         if arg.HasAttribute("out"):
  373.           cout = cout + 1
  374.           if arg.indirectionLevel ==2 :
  375.             f.write("\tif (%s==NULL) return E_POINTER;\n" % arg.name)
  376.         if arg.HasAttribute("in"):
  377.           try:
  378.             argCvt = makegwparse.make_arg_converter(arg)
  379.             argCvt.SetGatewayMode()
  380.             formatchar = argCvt.GetFormatChar();
  381.             needConversion = needConversion or argCvt.NeedUSES_CONVERSION()
  382.  
  383.             if formatchar:
  384.               formatChars = formatChars + formatchar
  385.               codeVars = codeVars + argCvt.DeclareParseArgTupleInputConverter()
  386.               argStr = argStr + ", " + argCvt.GetBuildValueArg()
  387.             codePre = codePre + argCvt.GetBuildForGatewayPreCode()
  388.             codePost = codePost + argCvt.GetBuildForGatewayPostCode()
  389.           except makegwparse.error_not_supported, why:
  390.             f.write('// *** The input argument %s of type "%s" was not processed ***\n//   - Please ensure this conversion function exists, and is appropriate\n//   - %s\n' % (arg.name, arg.raw_type, why))
  391.             f.write('\tPyObject *ob%s = PyObject_From%s(%s);\n' % (arg.name, arg.type, arg.name))
  392.             f.write('\tif (ob%s==NULL) return PyCom_HandlePythonFailureToCOM();\n' % arg.name)
  393.             codePost = codePost + "\tPy_DECREF(ob%s);\n" % arg.name
  394.             formatChars = formatChars + "O"
  395.             argStr = argStr + ", ob%s" % (arg.name)
  396.     
  397.     if needConversion: f.write('\tUSES_CONVERSION;\n')
  398.     f.write(codeVars)
  399.     f.write(codePre)
  400.     if cout:
  401.       f.write("\tPyObject *result;\n")
  402.       resStr = "&result"
  403.     else:
  404.       resStr = "NULL"
  405.       
  406.     if formatChars:
  407.       fullArgStr = '%s, "%s"%s' % (resStr, formatChars, argStr)
  408.     else:
  409.       fullArgStr = resStr
  410.  
  411.     f.write('\tHRESULT hr=InvokeViaPolicy("%s", %s);\n' % (method.name, fullArgStr))
  412.     f.write(codePost)
  413.     if cout:
  414.       f.write("\tif (FAILED(hr)) return hr;\n")
  415.       f.write("\t// Process the Python results, and convert back to the real params\n")
  416.       # process the output arguments.
  417.       formatChars = codePobjects = codePost = argsParseTuple = ""
  418.       needConversion = 0
  419.       for arg in method.args:
  420.         if not arg.HasAttribute("out"):
  421.           continue
  422.         try:
  423.           argCvt = makegwparse.make_arg_converter(arg)
  424.           argCvt.SetGatewayMode()
  425.           val = argCvt.GetFormatChar()
  426.           if val:
  427.             formatChars = formatChars + val
  428.             argsParseTuple = argsParseTuple + ", " + argCvt.GetParseTupleArg()
  429.             codePobjects = codePobjects + argCvt.DeclareParseArgTupleInputConverter()
  430.             codePost = codePost + argCvt.GetParsePostCode()
  431.             needConversion = needConversion or argCvt.NeedUSES_CONVERSION()
  432.         except makegwparse.error_not_supported, why:
  433.           f.write('// *** The output argument %s of type "%s" was not processed ***\n//     %s\n' % (arg.name, arg.raw_type, why))
  434.  
  435.       if formatChars: # If I have any to actually process.
  436.         if len(formatChars)==1:
  437.           parseFn = "PyArg_Parse"
  438.         else:
  439.           parseFn = "PyArg_ParseTuple"
  440.         if codePobjects: f.write(codePobjects)
  441.         f.write('\tif (!%s(result, "%s" %s)) return PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/);\n' % (parseFn, formatChars, argsParseTuple))
  442.       if codePost: 
  443.         f.write('\tBOOL bPythonIsHappy = TRUE;\n')
  444.         f.write(codePost)
  445.         f.write('\tif (!bPythonIsHappy) hr = PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/);\n')
  446.       f.write('\tPy_DECREF(result);\n');
  447.     f.write('\treturn hr;\n}\n\n')
  448.   
  449. def test():
  450. #    make_framework_support("d:\\msdev\\include\\objidl.h", "ILockBytes")
  451.     make_framework_support("d:\\msdev\\include\\objidl.h", "IStorage")
  452. #    make_framework_support("d:\\msdev\\include\\objidl.h", "IEnumSTATSTG")
  453.