home *** CD-ROM | disk | FTP | other *** search
/ PC User 2004 November / PCU1104CD1.iso / software / online / files / jyte.exe / makegwparse.py < prev    next >
Encoding:
Python Source  |  2003-10-08  |  29.4 KB  |  748 lines
  1. """Utilities for makegw - Parse a header file to build an interface
  2.  
  3.  This module contains the core code for parsing a header file describing a
  4.  COM interface, and building it into an "Interface" structure.
  5.  
  6.  Each Interface has methods, and each method has arguments.
  7.  
  8.  Each argument knows how to use Py_BuildValue or Py_ParseTuple to
  9.  exchange itself with Python.
  10.  
  11.  See the @win32com.makegw@ module for information in building a COM
  12.  interface
  13. """
  14. import regex
  15. import traceback
  16. import string
  17.  
  18. error_not_found = "The requested item could not be found"
  19. error_not_supported = "The required functionality is not supported"
  20.  
  21. VERBOSE=0
  22. DEBUG=0
  23.  
  24. ## NOTE : For interfaces as params to work correctly, you must
  25. ## make sure any PythonCOM extensions which expose the interface are loaded
  26. ## before generating.
  27.  
  28.  
  29. class ArgFormatter:
  30.     """An instance for a specific type of argument.     Knows how to convert itself"""
  31.     def __init__(self, arg, builtinIndirection, declaredIndirection = 0):
  32.         #print 'init:', arg.name, builtinIndirection, declaredIndirection, arg.indirectionLevel
  33.         self.arg = arg
  34.         self.builtinIndirection = builtinIndirection
  35.         self.declaredIndirection = declaredIndirection
  36.         self.gatewayMode = 0
  37.     def _IndirectPrefix(self, indirectionFrom, indirectionTo):
  38.         """Given the indirection level I was declared at (0=Normal, 1=*, 2=**)
  39.         return a string prefix so I can pass to a function with the
  40.         required indirection (where the default is the indirection of the method's param.
  41.         
  42.         eg, assuming my arg has indirection level of 2, if this function was passed 1
  43.         it would return "&", so that a variable declared with indirection of 1
  44.         can be prefixed with this to turn it into the indirection level required of 2
  45.         """
  46.         dif = indirectionFrom - indirectionTo
  47.         if dif==0:
  48.           return ""
  49.         elif dif==-1:
  50.           return "&"
  51.         elif dif==1:
  52.           return "*"
  53.         else:
  54.           return "??"
  55.           raise error_not_supported, "Can't indirect this far - please fix me :-)"
  56.     def GetIndirectedArgName(self, indirectFrom, indirectionTo):
  57.         #print 'get:',self.arg.name, indirectFrom,self._GetDeclaredIndirection() + self.builtinIndirection, indirectionTo, self.arg.indirectionLevel
  58.  
  59.         if indirectFrom is None:
  60.             ### ACK! this does not account for [in][out] variables.
  61.             ### when this method is called, we need to know which
  62.             indirectFrom = self._GetDeclaredIndirection() + self.builtinIndirection
  63.  
  64.         return self._IndirectPrefix(indirectFrom, indirectionTo) + self.arg.name
  65.     def GetBuildValueArg(self):
  66.         "Get the argument to be passes to Py_BuildValue"
  67.         return self.arg.name
  68.     def GetParseTupleArg(self):
  69.         "Get the argument to be passed to PyArg_ParseTuple"
  70.         if self.gatewayMode:
  71.             # use whatever they were declared with
  72.             return self.GetIndirectedArgName(None, 1)
  73.         # local declarations have just their builtin indirection
  74.         return self.GetIndirectedArgName(self.builtinIndirection, 1)
  75.     def GetInterfaceCppObjectInfo(self):
  76.         """Provide information about the C++ object used.
  77.                 
  78.         Simple variables (such as integers) can declare their type (eg an integer)
  79.         and use it as the target of both PyArg_ParseTuple and the COM function itself.
  80.         
  81.         More complex types require a PyObject * declared as the target of PyArg_ParseTuple,
  82.         then some conversion routine to the C++ object which is actually passed to COM.
  83.         
  84.         This method provides the name, and optionally the type of that C++ variable.  
  85.         If the type if provided, the caller will likely generate a variable declaration.
  86.         The name must always be returned.
  87.         
  88.         Result is a tuple of (variableName, [DeclareType|None|""])
  89.         """
  90.  
  91.         # the first return element is the variable to be passed as
  92.         #     an argument to an interface method. the variable was
  93.         #     declared with only its builtin indirection level. when
  94.         #     we pass it, we'll need to pass in whatever amount of
  95.         #     indirection was applied (plus the builtin amount)
  96.         # the second return element is the variable declaration; it
  97.         #     should simply be builtin indirection
  98.         return self.GetIndirectedArgName(self.builtinIndirection, self.arg.indirectionLevel + self.builtinIndirection), \
  99.                        "%s %s" % (self.GetUnconstType(), self.arg.name)
  100.  
  101.     def GetInterfaceArgCleanup(self):
  102.         "Return cleanup code for C++ args passed to the interface method."
  103.         if DEBUG:
  104.             return "/* GetInterfaceArgCleanup output goes here: %s */\n" % self.arg.name
  105.         else:
  106.             return ""
  107.  
  108.     def GetInterfaceArgCleanupGIL(self):
  109.         """Return cleanup code for C++ args passed to the interface
  110.         method that must be executed with the GIL held"""
  111.         if DEBUG:
  112.             return "/* GetInterfaceArgCleanup (GIL held) output goes here: %s */\n" % self.arg.name
  113.         else:
  114.             return ""
  115.  
  116.     def GetUnconstType(self):
  117.         return self.arg.unc_type
  118.     
  119.     def SetGatewayMode(self):
  120.         self.gatewayMode = 1
  121.     def _GetDeclaredIndirection(self):
  122.         return self.arg.indirectionLevel
  123.         print 'declared:', self.arg.name, self.gatewayMode
  124.         if self.gatewayMode:
  125.             return self.arg.indirectionLevel
  126.         else:
  127.             return self.declaredIndirection
  128.     def DeclareParseArgTupleInputConverter(self):
  129.         "Declare the variable used as the PyArg_ParseTuple param for a gateway"
  130.         # Only declare it??
  131.         #if self.arg.indirectionLevel==0:
  132.         #    return "\t%s %s;\n" % (self.arg.type, self.arg.name)
  133.         #else:
  134.         if DEBUG:
  135.             return "/* Declare ParseArgTupleInputConverter goes here: %s */\n" % self.arg.name
  136.         else:
  137.             return ""
  138.     def GetParsePostCode(self):
  139.         "Get a string of C++ code to be executed after (ie, to finalise) the PyArg_ParseTuple conversion"
  140.         if DEBUG:
  141.             return "/* GetParsePostCode code goes here: %s */\n" % self.arg.name
  142.         else:
  143.             return ""
  144.     def GetBuildForInterfacePreCode(self):
  145.         "Get a string of C++ code to be executed before (ie, to initialise) the Py_BuildValue conversion for Interfaces"
  146.         if DEBUG:
  147.             return "/* GetBuildForInterfacePreCode goes here: %s */\n" % self.arg.name
  148.         else:
  149.             return ""
  150.     def GetBuildForGatewayPreCode(self):
  151.         "Get a string of C++ code to be executed before (ie, to initialise) the Py_BuildValue conversion for Gateways"
  152.         s = self.GetBuildForInterfacePreCode() # Usually the same
  153.         if DEBUG:
  154.             if s[:4] == "/* G":
  155.                 s = "/* GetBuildForGatewayPreCode goes here: %s */\n" % self.arg.name
  156.         return s
  157.     def GetBuildForInterfacePostCode(self):
  158.         "Get a string of C++ code to be executed after (ie, to finalise) the Py_BuildValue conversion for Interfaces"
  159.         if DEBUG:
  160.             return "/* GetBuildForInterfacePostCode goes here: %s */\n" % self.arg.name
  161.         return ""
  162.     def GetBuildForGatewayPostCode(self):
  163.         "Get a string of C++ code to be executed after (ie, to finalise) the Py_BuildValue conversion for Gateways"
  164.         s = self.GetBuildForInterfacePostCode() # Usually the same
  165.         if DEBUG:
  166.             if s[:4] == "/* G":
  167.                 s = "/* GetBuildForGatewayPostCode goes here: %s */\n" % self.arg.name
  168.         return s
  169.     def GetAutoduckString(self):
  170.         return '// @pyparm %s|%s||Description for %s' % (self._GetPythonTypeDesc(), self.arg.name, self.arg.name)
  171.     def _GetPythonTypeDesc(self):
  172.         "Returns a string with the description of the type.     Used for doco purposes"
  173.         return None
  174.     def NeedUSES_CONVERSION(self):
  175.         "Determines if this arg forces a USES_CONVERSION macro"
  176.         return 0
  177.  
  178. # Special formatter for floats since they're smaller than Python floats.
  179. class ArgFormatterFloat(ArgFormatter):
  180.     def GetFormatChar(self):
  181.         return "f"
  182.     def DeclareParseArgTupleInputConverter(self):
  183.         # Declare a double variable
  184.         return "\tdouble dbl%s;\n" % self.arg.name
  185.     def GetParseTupleArg(self):
  186.         return "&dbl" + self.arg.name
  187.     def _GetPythonTypeDesc(self):
  188.         return "float"
  189.     def GetBuildValueArg(self):
  190.         return "&dbl" + self.arg.name
  191.     def GetBuildForInterfacePreCode(self):
  192.         return "\tdbl" + self.arg.name + " = " + self.arg.name + ";\n"
  193.     def GetBuildForGatewayPreCode(self):
  194.         return "\tdbl%s = " % self.arg.name + self._IndirectPrefix( \
  195.             self._GetDeclaredIndirection(),
  196.             0) + self.arg.name + ";\n"
  197.     def GetParsePostCode(self):
  198.         s = "\t"
  199.         if self.gatewayMode:
  200.             s = s + self._IndirectPrefix( 
  201.                 self._GetDeclaredIndirection(),
  202.                 0)
  203.         s = s + self.arg.name
  204.         s = s + " = (float)dbl%s;\n" % self.arg.name
  205.         return s
  206.  
  207. # Special formatter for Shorts because they're
  208. # a different size than Python ints!
  209. class ArgFormatterShort(ArgFormatter):
  210.     def GetFormatChar(self):
  211.         return "i"
  212.     def DeclareParseArgTupleInputConverter(self):
  213.         # Declare a double variable
  214.         return "\tINT i%s;\n" % self.arg.name
  215.     def GetParseTupleArg(self):
  216.         return "&i" + self.arg.name
  217.     def _GetPythonTypeDesc(self):
  218.         return "int"
  219.     def GetBuildValueArg(self):
  220.         return "&i" + self.arg.name
  221.     def GetBuildForInterfacePreCode(self):
  222.         return "\ti" + self.arg.name + " = " + self.arg.name + ";\n"
  223.     def GetBuildForGatewayPreCode(self):
  224.         return "\ti%s = " % self.arg.name + self._IndirectPrefix( \
  225.             self._GetDeclaredIndirection(),
  226.             0) + self.arg.name + ";\n"
  227.     def GetParsePostCode(self):
  228.         s = "\t"
  229.         if self.gatewayMode:
  230.             s = s + self._IndirectPrefix( 
  231.                 self._GetDeclaredIndirection(),
  232.                 0)
  233.         s = s + self.arg.name
  234.         s = s + " = i%s;\n" % self.arg.name
  235.         return s
  236.  
  237. class ArgFormatterPythonCOM(ArgFormatter):
  238.     """An arg formatter for types exposed in the PythonCOM module"""
  239.     def GetFormatChar(self):
  240.         return "O"
  241.     #def GetInterfaceCppObjectInfo(self):
  242.     #    return ArgFormatter.GetInterfaceCppObjectInfo(self)[0], \
  243.     #        "%s %s%s" % (self.arg.unc_type, "*" * self._GetDeclaredIndirection(), self.arg.name)
  244.     def DeclareParseArgTupleInputConverter(self):
  245.         # Declare a PyObject variable
  246.         return "\tPyObject *ob%s;\n" % self.arg.name
  247.     def GetParseTupleArg(self):
  248.         return "&ob"+self.arg.name
  249.     def _GetPythonTypeDesc(self):
  250.         return "<o Py%s>" % self.arg.type
  251.     def GetBuildValueArg(self):
  252.         return "ob" + self.arg.name
  253.     def GetBuildForInterfacePostCode(self):
  254.         return "\tPy_XDECREF(ob%s);\n" % self.arg.name
  255.     def DeclareParseArgTupleInputConverter(self):
  256.         # Declare a PyObject variable
  257.         return "\tPyObject *ob%s;\n" % self.arg.name
  258.  
  259. class ArgFormatterBSTR(ArgFormatterPythonCOM):
  260.     def _GetPythonTypeDesc(self):
  261.         return "<o unicode>"
  262.     def GetParsePostCode(self):
  263.         return "\tif (bPythonIsHappy && !PyWinObject_AsBstr(ob%s, %s)) bPythonIsHappy = FALSE;\n" % (self.arg.name, self.GetIndirectedArgName(None, 2))
  264.     def GetBuildForInterfacePreCode(self):
  265.         notdirected = self.GetIndirectedArgName(None, 1)
  266.         return "\tob%s = MakeBstrToObj(%s);\n" % \
  267.                (self.arg.name, notdirected)
  268.     def GetBuildForInterfacePostCode(self):
  269.         return "\tSysFreeString(%s);\n" % (self.arg.name,) + \
  270.                ArgFormatterPythonCOM.GetBuildForInterfacePostCode(self)
  271.     def GetBuildForGatewayPostCode(self):
  272.         return "\tPy_XDECREF(ob%s);\n" % self.arg.name
  273.  
  274. class ArgFormatterOLECHAR(ArgFormatterPythonCOM):
  275.     def _GetPythonTypeDesc(self):
  276.         return "<o unicode>"
  277.     def GetUnconstType(self):
  278.         if self.arg.type[:3]=="LPC":
  279.             return self.arg.type[:2] + self.arg.type[3:]
  280.         else:
  281.             return self.arg.unc_type
  282.     def GetParsePostCode(self):
  283.         return "\tif (bPythonIsHappy && !PyWinObject_AsBstr(ob%s, %s)) bPythonIsHappy = FALSE;\n" % (self.arg.name, self.GetIndirectedArgName(None, 2))
  284.     def GetInterfaceArgCleanup(self):
  285.         return "\tSysFreeString(%s);\n" % self.GetIndirectedArgName(None, 1)
  286.     def GetBuildForInterfacePreCode(self):
  287.         # the variable was declared with just its builtin indirection
  288.         notdirected = self.GetIndirectedArgName(self.builtinIndirection, 1)
  289.         return "\tob%s = MakeOLECHARToObj(%s);\n" % \
  290.                (self.arg.name, notdirected)
  291.     def GetBuildForInterfacePostCode(self):
  292.         # memory returned into an OLECHAR should be freed
  293.         return "\tCoTaskMemFree(%s);\n" % (self.arg.name,) + \
  294.                ArgFormatterPythonCOM.GetBuildForInterfacePostCode(self)
  295.     def GetBuildForGatewayPostCode(self):
  296.         return "\tPy_XDECREF(ob%s);\n" % self.arg.name
  297.  
  298. class ArgFormatterTCHAR(ArgFormatterPythonCOM):
  299.     def _GetPythonTypeDesc(self):
  300.         return "string/<o unicode>"
  301.     def GetUnconstType(self):
  302.         if self.arg.type[:3]=="LPC":
  303.             return self.arg.type[:2] + self.arg.type[3:]
  304.         else:
  305.             return self.arg.unc_type
  306.     def GetParsePostCode(self):
  307.         return "\tif (bPythonIsHappy && !PyWinObject_AsTCHAR(ob%s, %s)) bPythonIsHappy = FALSE;\n" % (self.arg.name, self.GetIndirectedArgName(None, 2))
  308.     def GetInterfaceArgCleanup(self):
  309.         return "\tPyWinObject_FreeTCHAR(%s);\n" % self.GetIndirectedArgName(None, 1)
  310.     def GetBuildForInterfacePreCode(self):
  311.         # the variable was declared with just its builtin indirection
  312.         notdirected = self.GetIndirectedArgName(self.builtinIndirection, 1)
  313.         return "\tob%s = PyWinObject_FromTCHAR(%s);\n" % \
  314.                (self.arg.name, notdirected)
  315.     def GetBuildForInterfacePostCode(self):
  316.         return "// ??? - TCHAR post code\n"
  317.     def GetBuildForGatewayPostCode(self):
  318.         return "\tPy_XDECREF(ob%s);\n" % self.arg.name
  319.  
  320. class ArgFormatterIID(ArgFormatterPythonCOM):
  321.     def _GetPythonTypeDesc(self):
  322.         return "<o PyIID>"
  323.     def GetParsePostCode(self):
  324.         return "\tif (!PyWinObject_AsIID(ob%s, &%s)) bPythonIsHappy = FALSE;\n" % (self.arg.name, self.arg.name)
  325.     def GetBuildForInterfacePreCode(self):
  326. #        notdirected = self.GetIndirectedArgName(self.arg.indirectionLevel, 0)
  327.         notdirected = self.GetIndirectedArgName(None, 0)
  328.         return "\tob%s = PyWinObject_FromIID(%s);\n" % (self.arg.name, notdirected)
  329.     def GetInterfaceCppObjectInfo(self):
  330.         return self.arg.name, "IID %s" % (self.arg.name)
  331.  
  332. class ArgFormatterTime(ArgFormatterPythonCOM):
  333.     def __init__(self, arg, builtinIndirection, declaredIndirection = 0):
  334.         # we don't want to declare LPSYSTEMTIME / LPFILETIME objects
  335.         if arg.indirectionLevel == 0 and arg.unc_type[:2] == "LP":
  336.             arg.unc_type = arg.unc_type[2:]
  337.             # reduce the builtin and increment the declaration
  338.             arg.indirectionLevel = arg.indirectionLevel + 1
  339.             builtinIndirection = 0
  340.         ArgFormatterPythonCOM.__init__(self, arg, builtinIndirection, declaredIndirection)
  341.  
  342.     def _GetPythonTypeDesc(self):
  343.         return "<o PyTime>"
  344.     def GetParsePostCode(self):
  345.         # variable was declared with only the builtinIndirection
  346.         ### NOTE: this is an [in] ... so use only builtin
  347.         return '\tif (!PyTime_Check(ob%s)) {\n\t\tPyErr_SetString(PyExc_TypeError, "The argument must be a PyTime object");\n\t\tbPythonIsHappy = FALSE;\n\t}\n\tif (!((PyTime *)ob%s)->GetTime(%s)) bPythonIsHappy = FALSE;\n' % (self.arg.name, self.arg.name, self.GetIndirectedArgName(self.builtinIndirection, 1))
  348.     def GetBuildForInterfacePreCode(self):
  349.         ### use just the builtinIndirection again...
  350.         notdirected = self.GetIndirectedArgName(self.builtinIndirection,0)
  351.         return "\tob%s = new PyTime(%s);\n" % (self.arg.name, notdirected)
  352.     def GetBuildForInterfacePostCode(self):
  353.         ### hack to determine if we need to free stuff
  354.         ret = ''
  355.         if self.builtinIndirection + self.arg.indirectionLevel > 1:
  356.             # memory returned into an OLECHAR should be freed
  357.             ret = "\tCoTaskMemFree(%s);\n" % self.arg.name
  358.         return ret + ArgFormatterPythonCOM.GetBuildForInterfacePostCode(self)
  359.  
  360. class ArgFormatterSTATSTG(ArgFormatterPythonCOM):
  361.     def _GetPythonTypeDesc(self):
  362.         return "<o STATSTG>"
  363.     def GetParsePostCode(self):
  364.         return '\tif (!PyCom_PyObjectAsSTATSTG(ob%s, %s, 0/*flags*/)) bPythonIsHappy = FALSE;\n' % (self.arg.name, self.GetIndirectedArgName(None, 1))
  365.     def GetBuildForInterfacePreCode(self):
  366.         notdirected = self.GetIndirectedArgName(None, 1)
  367.         return "\tob%s = PyCom_PyObjectFromSTATSTG(%s);\n\t// STATSTG doco says our responsibility to free\n\tif ((%s).pwcsName) CoTaskMemFree((%s).pwcsName);\n" % (self.arg.name, self.GetIndirectedArgName(None, 1),notdirected,notdirected)
  368.  
  369. class ArgFormatterGeneric(ArgFormatterPythonCOM):
  370.     def _GetPythonTypeDesc(self):
  371.         return "<o %s>" % self.arg.type
  372.     def GetParsePostCode(self):
  373.         return '\tif (!PyObject_As%s(ob%s, &%s) bPythonIsHappy = FALSE;\n' % (self.arg.type, self.arg.name, self.GetIndirectedArgName(None, 1))
  374.     def GetInterfaceArgCleanup(self):
  375.         return '\tPyObject_Free%s(%s);\n' % (self.arg.type, self.arg.name)
  376.     def GetBuildForInterfacePreCode(self):
  377.         notdirected = self.GetIndirectedArgName(None, 1)
  378.         return "\tob%s = PyObject_From%s(%s);\n" % (self.arg.name, self.arg.type, self.GetIndirectedArgName(None, 1))
  379.  
  380. class ArgFormatterIDLIST(ArgFormatterPythonCOM):
  381.     def _GetPythonTypeDesc(self):
  382.         return "<o PyIDL>"
  383.     def GetParsePostCode(self):
  384.         return '\tif (bPythonIsHappy && !PyObject_AsPIDL(ob%s, &%s)) bPythonIsHappy = FALSE;\n' % (self.arg.name, self.GetIndirectedArgName(None, 1))
  385.     def GetInterfaceArgCleanup(self):
  386.         return '\tPyObject_FreePIDL(%s);\n' % (self.arg.name,)
  387.     def GetBuildForInterfacePreCode(self):
  388.         notdirected = self.GetIndirectedArgName(None, 1)
  389.         return "\tob%s = PyObject_FromPIDL(%s);\n" % (self.arg.name, self.GetIndirectedArgName(None, 1))
  390.  
  391. class ArgFormatterHANDLE(ArgFormatterPythonCOM):
  392.     def _GetPythonTypeDesc(self):
  393.         return "<o PyHANDLE>"
  394.     def GetParsePostCode(self):
  395.         return '\tif (!PyWinObject_AsHANDLE(ob%s, &%s, FALSE) bPythonIsHappy = FALSE;\n' % (self.arg.name, self.GetIndirectedArgName(None, 1))
  396.     def GetBuildForInterfacePreCode(self):
  397.         notdirected = self.GetIndirectedArgName(None, 1)
  398.         return "\tob%s = PyWinObject_FromHANDLE(%s);\n" % (self.arg.name, self.GetIndirectedArgName(None, 0))
  399.  
  400. class ArgFormatterLARGE_INTEGER(ArgFormatterPythonCOM):
  401.     def GetKeyName(self):
  402.         return "LARGE_INTEGER"
  403.     def _GetPythonTypeDesc(self):
  404.         return "<o %s>" % self.GetKeyName()
  405.     def GetParsePostCode(self):
  406.         return '\tif (!PyWinObject_As%s(ob%s, %s)) bPythonIsHappy = FALSE;\n' % (self.GetKeyName(), self.arg.name, self.GetIndirectedArgName(None, 1))
  407.     def GetBuildForInterfacePreCode(self):
  408.         notdirected = self.GetIndirectedArgName(None, 0)
  409.         return "\tob%s = PyWinObject_From%s(%s);\n" % (self.arg.name, self.GetKeyName(), notdirected)
  410.  
  411. class ArgFormatterULARGE_INTEGER(ArgFormatterLARGE_INTEGER):
  412.     def GetKeyName(self):
  413.         return "ULARGE_INTEGER"
  414.  
  415. class ArgFormatterInterface(ArgFormatterPythonCOM):
  416.     def GetInterfaceCppObjectInfo(self):
  417.         return self.GetIndirectedArgName(1, self.arg.indirectionLevel), \
  418.                "%s * %s" % (self.GetUnconstType(), self.arg.name)
  419.  
  420.     def GetParsePostCode(self):
  421.         # This gets called for out params in gateway mode
  422.         if self.gatewayMode:
  423.             sArg = self.GetIndirectedArgName(None, 2)
  424.         else:
  425.         # vs. in params for interface mode.
  426.             sArg = self.GetIndirectedArgName(1, 2)
  427.         return "\tif (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(ob%s, IID_%s, (void **)%s, TRUE /* bNoneOK */))\n\t\t bPythonIsHappy = FALSE;\n" % (self.arg.name, self.arg.type, sArg)
  428.     
  429.     def GetBuildForInterfacePreCode(self):
  430.         return "\tob%s = PyCom_PyObjectFromIUnknown(%s, IID_%s, FALSE);\n" % (self.arg.name, self.arg.name, self.arg.type)
  431.     
  432.     def GetBuildForGatewayPreCode(self):
  433.         sPrefix = self._IndirectPrefix(self._GetDeclaredIndirection(), 1)
  434.         return "\tob%s = PyCom_PyObjectFromIUnknown(%s%s, IID_%s, TRUE);\n" % (self.arg.name, sPrefix, self.arg.name, self.arg.type)
  435.  
  436.     def GetInterfaceArgCleanup(self):
  437.         return "\tif (%s) %s->Release();\n" % (self.arg.name, self.arg.name)
  438.  
  439. class ArgFormatterVARIANT(ArgFormatterPythonCOM):
  440.     def GetParsePostCode(self):
  441.         return "\tif ( !PyCom_VariantFromPyObject(ob%s, %s) )\n\t\tbPythonIsHappy = FALSE;\n" % (self.arg.name, self.GetIndirectedArgName(None, 1))
  442.  
  443.     def GetBuildForGatewayPreCode(self):
  444.         notdirected = self.GetIndirectedArgName(None, 1)
  445.         return "\tob%s = PyCom_PyObjectFromVariant(%s);\n" % (self.arg.name, notdirected)
  446.     def GetBuildForGatewayPostCode(self):
  447.         return "\tPy_XDECREF(ob%s);\n" % self.arg.name
  448.  
  449.                       # Key :        , Python Type Description, ParseTuple format char
  450. ConvertSimpleTypes = {"BOOL":("BOOL", "int", "i"),
  451.                       "UINT":("UINT", "int", "i"),
  452.                       "BYTE": ("BYTE", "int", "i"),
  453.                       "INT": ("INT", "int", "i"),
  454.                       "DWORD": ("DWORD", "int", "l"),
  455.                       "HRESULT":("HRESULT", "int", "l"),
  456.                       "ULONG": ("ULONG", "int", "l"),
  457.                       "LONG": ("LONG", "int", "l"),
  458.                       "int": ("int", "int", "i"),
  459.                       "long": ("long", "int", "l"),
  460.                       "HWND": ("HWND", "HWND", "l"),
  461.                       "HDC": ("HDC", "HDC", "l"),
  462.                       "LPARAM" : ("LPARAM", "long", "l"),
  463.                       "LRESULT" : ("LRESULT", "long", "l"),
  464.                       "WPARAM" : ("LPARAM", "int", "i"),
  465.                       "DISPID": ("DISPID", "long", "l"),
  466.                       "APPBREAKFLAGS": ("int", "int", "i"),
  467.                       "BREAKRESUMEACTION": ("int", "int", "i"),
  468.                       "ERRORRESUMEACTION": ("int", "int", "i"),
  469.                       "BREAKREASON": ("int", "int", "i"),
  470.                       "BREAKPOINT_STATE": ("int", "int", "i"),
  471.                       "BREAKRESUME_ACTION": ("int", "int", "i"),
  472.                       "SOURCE_TEXT_ATTR": ("int", "int", "i"),
  473.                       "TEXT_DOC_ATTR": ("int", "int", "i"),
  474.                       "QUERYOPTION": ("int", "int", "i"),
  475.                       "PARSEACTION": ("int", "int", "i"),
  476. }
  477.     
  478. class ArgFormatterSimple(ArgFormatter):
  479.     """An arg formatter for simple integer etc types"""
  480.     def GetFormatChar(self):
  481.         return ConvertSimpleTypes[self.arg.type][2]
  482.     def _GetPythonTypeDesc(self):
  483.         return ConvertSimpleTypes[self.arg.type][1]
  484.  
  485. AllConverters = {"const OLECHAR":    (ArgFormatterOLECHAR, 0, 1),
  486.                  "WCHAR":            (ArgFormatterOLECHAR, 0, 1),
  487.                  "OLECHAR":            (ArgFormatterOLECHAR, 0, 1),
  488.                  "LPCOLESTR":        (ArgFormatterOLECHAR, 1, 1),
  489.                  "LPOLESTR":        (ArgFormatterOLECHAR, 1, 1),
  490.                  "LPCWSTR":            (ArgFormatterOLECHAR, 1, 1),
  491.                  "LPWSTR":            (ArgFormatterOLECHAR, 1, 1),
  492.                  "LPCSTR":            (ArgFormatterOLECHAR, 1, 1),
  493.                  "LPTSTR":            (ArgFormatterTCHAR, 1, 1),
  494.                  "LPCTSTR":         (ArgFormatterTCHAR, 1, 1),
  495.                  "HANDLE":            (ArgFormatterHANDLE, 0),
  496.                  "BSTR":            (ArgFormatterBSTR, 1, 0),
  497.                  "const IID":        (ArgFormatterIID, 0),
  498.                  "CLSID":            (ArgFormatterIID, 0),
  499.                  "IID":                (ArgFormatterIID, 0),
  500.                  "GUID":            (ArgFormatterIID, 0),
  501.                  "const GUID":        (ArgFormatterIID, 0),
  502.                  "const IID":        (ArgFormatterIID, 0),
  503.                  "REFCLSID":        (ArgFormatterIID, 0),
  504.                  "REFIID":            (ArgFormatterIID, 0),
  505.                  "REFGUID":            (ArgFormatterIID, 0),
  506.                  "const FILETIME":    (ArgFormatterTime, 0),
  507.                  "const SYSTEMTIME":(ArgFormatterTime, 0),
  508.                  "const LPSYSTEMTIME":(ArgFormatterTime, 1, 1),
  509.                  "LPSYSTEMTIME":    (ArgFormatterTime, 1, 1),
  510.                  "FILETIME":        (ArgFormatterTime, 0),
  511.                  "SYSTEMTIME":        (ArgFormatterTime, 0),
  512.                  "STATSTG":            (ArgFormatterSTATSTG, 0),
  513.                  "LARGE_INTEGER":    (ArgFormatterLARGE_INTEGER, 0),
  514.                  "ULARGE_INTEGER":    (ArgFormatterULARGE_INTEGER, 0),
  515.                  "VARIANT":            (ArgFormatterVARIANT, 0),
  516.                  "float":            (ArgFormatterFloat, 0),
  517.                  "single":            (ArgFormatterFloat, 0),
  518.                  "short":            (ArgFormatterShort, 0),
  519.                  "WORD":            (ArgFormatterShort, 0),
  520.                  "VARIANT_BOOL":    (ArgFormatterShort, 0),
  521.                  "HWND":            (ArgFormatterShort, 0),
  522.                  "HMENU":            (ArgFormatterShort, 0),
  523.                  "HOLEMENU":            (ArgFormatterShort, 0),
  524.                  "HICON":            (ArgFormatterShort, 0),
  525.                  "UINT":            (ArgFormatterShort, 0),
  526.                  "SVSIF":            (ArgFormatterShort, 0),
  527.                  "Control":            (ArgFormatterInterface, 0, 1),
  528.                  "DataObject":        (ArgFormatterInterface, 0, 1),
  529.                  "_PropertyBag":    (ArgFormatterInterface, 0, 1),
  530.                  "AsyncProp":        (ArgFormatterInterface, 0, 1),
  531.                  "DataSource":        (ArgFormatterInterface, 0, 1),
  532.                  "DataFormat":        (ArgFormatterInterface, 0, 1),
  533.                  "void **":            (ArgFormatterInterface, 2, 2),
  534.                  "ITEMIDLIST":        (ArgFormatterIDLIST, 0, 0),
  535.                  "LPITEMIDLIST":        (ArgFormatterIDLIST, 0, 1),
  536.                  "LPCITEMIDLIST":        (ArgFormatterIDLIST, 0, 1),
  537.                  "const ITEMIDLIST":        (ArgFormatterIDLIST, 0, 1),
  538. }
  539.  
  540. # Auto-add all the simple types
  541. for key in ConvertSimpleTypes.keys():
  542.     AllConverters[key] = ArgFormatterSimple, 0
  543.  
  544. def make_arg_converter(arg):
  545.     try:
  546.         clz = AllConverters[arg.type][0]
  547.         bin = AllConverters[arg.type][1]
  548.         decl = 0
  549.         if len(AllConverters[arg.type])>2:
  550.             decl = AllConverters[arg.type][2]
  551.         return clz(arg,bin, decl)
  552.     except KeyError:
  553.         if arg.type[0]=="I":
  554.             return ArgFormatterInterface(arg, 0, 1)
  555.  
  556.         raise error_not_supported, "The type '%s' (%s) is unknown." % (arg.type, arg.name)
  557.  
  558.         
  559. #############################################################
  560. #
  561. # The instances that represent the args, methods and interface
  562. class Argument:
  563.     """A representation of an argument to a COM method
  564.     
  565.     This class contains information about a specific argument to a method.
  566.     In addition, methods exist so that an argument knows how to convert itself
  567.     to/from Python arguments.
  568.     """
  569. #                                      in,out                      type              name             [    ]
  570. #                                   --------------                --------      ------------        ------
  571.     regex = regex.compile('/\\* \\[\\([^\\]]*.*\\)] \\*/[ \t]\\(.*[\\* ]\\)\\([a-zA-Z0-9]+\\)\\(\\[ *]\\)?[),]')
  572.     def __init__(self, good_interface_names):
  573.         self.good_interface_names = good_interface_names
  574.         self.inout = self.name = self.type = None
  575.         self.const = 0
  576.         self.arrayDecl = 0
  577.     def BuildFromFile(self, file):
  578.         """Parse and build my data from a file
  579.         
  580.         Reads the next line in the file, and matches it as an argument
  581.         description.  If not a valid argument line, an error_not_found exception
  582.         is raised.
  583.         """
  584.         line = file.readline()
  585.         if self.regex.search(line)<0:
  586.             raise error_not_found
  587.         self.name = self.regex.group(3)
  588.         self.inout = string.split(self.regex.group(1),'][')
  589.         typ = string.strip(self.regex.group(2))
  590.         self.raw_type = typ
  591.         self.indirectionLevel = 0
  592.         if self.regex.group(4): # Has "[ ]" decl
  593.             self.arrayDecl = 1
  594.             try:
  595.                 pos = string.rindex(typ, "__RPC_FAR")
  596.                 self.indirectionLevel = self.indirectionLevel + 1
  597.                 typ = string.strip(typ[:pos])
  598.             except ValueError:
  599.                 pass
  600.         
  601.         while 1:
  602.             try:
  603.                 pos = string.rindex(typ, "__RPC_FAR *")
  604.                 self.indirectionLevel = self.indirectionLevel + 1
  605.                 typ = string.strip(typ[:pos])
  606.             except ValueError:
  607.                 break
  608.         self.type = typ
  609.         if self.type[:6]=="const ":
  610.             self.unc_type = self.type[6:]
  611.         else:
  612.             self.unc_type = self.type
  613.         
  614.         if VERBOSE:
  615.             print "       Arg %s of type %s%s (%s)" % (self.name, self.type, "*" * self.indirectionLevel, self.inout)
  616.  
  617.     def HasAttribute(self, typ):
  618.         """Determines if the argument has the specific attribute.
  619.         
  620.         Argument attributes are specified in the header file, such as
  621.         "[in][out][retval]" etc.  You can pass a specific string (eg "out")
  622.         to find if this attribute was specified for the argument
  623.         """
  624.         return typ in self.inout
  625.  
  626.     def GetRawDeclaration(self):
  627.         ret = "%s %s" % (self.raw_type, self.name)
  628.         if self.arrayDecl:
  629.             ret = ret + "[]"
  630.         return ret
  631.  
  632. class Method:
  633.     """A representation of a C++ method on a COM interface
  634.     
  635.     This class contains information about a specific method, as well as 
  636.     a list of all @Argument@s
  637.     """
  638. #                                         options     ret type callconv     name
  639. #                                   ----------------- -------- -------- --------
  640.     regex = regex.compile('virtual \\(/\\*.*\\*/ \\)?\\(.*\\) \\(.*\\) \\(.*\\)(\w?')
  641.     def __init__(self, good_interface_names ):
  642.         self.good_interface_names = good_interface_names
  643.         self.name = self.result = self.callconv = None
  644.         self.args = []
  645.     def BuildFromFile(self, file):
  646.         """Parse and build my data from a file
  647.         
  648.         Reads the next line in the file, and matches it as a method
  649.         description.  If not a valid method line, an error_not_found exception
  650.         is raised.
  651.         """
  652.         str = file.readline()
  653.         if self.regex.search(str, 0) == -1:
  654.             raise error_not_found
  655.         self.name = self.regex.group(4)
  656.         self.result = self.regex.group(2)
  657.         if self.result != "HRESULT":
  658.             if self.result=="DWORD": # DWORD is for old old stuff?
  659.                 print "Warning: Old style interface detected - compilation errors likely!"
  660.             else:
  661.                 print "Method %s - Only HRESULT return types are supported." % self.name
  662. #                raise error_not_supported,        if VERBOSE:
  663.             print "     Method %s %s(" % (self.result, self.name)
  664.         while 1:
  665.             arg = Argument(self.good_interface_names)
  666.             try:
  667.                 arg.BuildFromFile(file)
  668.                 self.args.append(arg)
  669.             except error_not_found:
  670.                 break
  671.  
  672. class Interface:
  673.     """A representation of a C++ COM Interface
  674.     
  675.     This class contains information about a specific interface, as well as 
  676.     a list of all @Method@s
  677.     """
  678. #                                      name                 base
  679. #                                     --------           --------
  680.     regex = regex.compile("\\(interface\\|\\) \\([^ ]*\\) : public \\(.*\\)$")
  681.     def __init__(self):
  682.         self.methods = []
  683.         self.name = self.regex.group(2)
  684.         self.base = self.regex.group(3)
  685.         if VERBOSE:
  686.             print "Interface %s : public %s" % (self.name, self.base)
  687.  
  688.     def BuildMethods(self, file):
  689.         """Build all sub-methods for this interface"""
  690.         # skip the next 2 lines.
  691.         file.readline();file.readline();
  692.         while 1:
  693.             try:
  694.                 method = Method([self.name])
  695.                 method.BuildFromFile(file)
  696.                 self.methods.append(method)
  697.             except error_not_found:
  698.                 break
  699.     
  700. def find_interface(interfaceName, file):
  701.     """Find and return an interface in a file
  702.     
  703.     Given an interface name and file, search for the specified interface.
  704.     
  705.     Upon return, the interface itself has been built, 
  706.     but not the methods.
  707.     """
  708.  
  709.     line = file.readline()
  710.     while line:
  711.         if Interface.regex.search(line, 0) >=0:
  712.             name = Interface.regex.group(2)
  713.             print name
  714.             if name==interfaceName:
  715.                 return Interface()
  716.         line = file.readline()
  717.     raise error_not_found
  718.  
  719.     
  720. def parse_interface_info(interfaceName, file):
  721.     """Find, parse and return an interface in a file
  722.     
  723.     Given an interface name and file, search for the specified interface.
  724.     
  725.     Upon return, the interface itself is fully built,
  726.     """
  727.     try:
  728.         interface = find_interface(interfaceName, file)
  729.         interface.BuildMethods(file)
  730.         return interface
  731.     except regex.error:
  732.         traceback.print_exc()
  733.         print "The interface could not be built, as the regular expression failed!"
  734. def test():
  735.     f=open("d:\\msdev\\include\\objidl.h")
  736.     try:
  737.         parse_interface_info("IPersistStream", f)
  738.     finally:
  739.         f.close()
  740.  
  741. def test_regex(r,text):
  742.     res=r.search(text,0)
  743.     if res==-1:
  744.         print "** Not found"
  745.     else:
  746.         print "%d\n%s\n%s\n%s\n%s" % (res, r.group(1), r.group(2), r.group(3), r.group(4))
  747.  
  748.