home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 May / Pcwk5b98.iso / Borland / Cplus45 / BC45 / OCT_AUTO.PAK / AUTOGEN.CPP next >
Encoding:
C/C++ Source or Header  |  1995-08-29  |  49.6 KB  |  1,405 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectConnections - (C) Copyright 1994 by Borland International
  3. //
  4. // This program reads type libraries (*.OLB; *.TLB) and emits C++ source files
  5. // A typelib filename on the command line forces non-interactive operation.
  6. // Normally generates .HXX and .CXX files for use by OCF automation controller
  7. // A C++ compatible .HPP file can be generated using the entire type library
  8. // by selecting the dialog box option, or by use of the command line options.
  9. //----------------------------------------------------------------------------
  10. #include <ocf/ocdefs.h>  // TComRef
  11. #include <osl/except.h>  // TXBase
  12. #include <olenls.h>      // LANGIDFROMCLSID
  13. #include <iostream.h>
  14. #include <commdlg.h>     // GetFileTitle
  15. #include "autogen.rh"
  16.  
  17. //____________________________________________________________________________
  18. //
  19. // ITypeInfo and ITypeLib encapsulations
  20. //____________________________________________________________________________
  21.  
  22. class TComRef<ITypeInfo> : public TComRefBase<ITypeInfo> {
  23.   public:
  24.     TComRef();
  25.     TComRef(ITypeInfo* iface);
  26.     TComRef(const TComRef<ITypeInfo>& i);
  27.    ~TComRef();
  28.     ITypeInfo* operator =(ITypeInfo* iface);
  29.     TComRef<ITypeInfo>& operator =(const TComRef<ITypeInfo>& i);
  30.     ITypeInfo* operator->() {return I;}
  31.     operator ITypeInfo* far*();
  32.  
  33.     void GetAttr();
  34.     void GetFuncDesc(unsigned int index);
  35.     void GetVarDesc( unsigned int index);
  36.     void GetDocumentation(MEMBERID memberid = MEMBERID_NIL);
  37.     TYPEATTR far* Attr;
  38.     FUNCDESC far* FuncDesc;
  39.     VARDESC  far* VarDesc;
  40.     BSTR Name;
  41.     BSTR Doc;
  42.   private:
  43.     void ClearData();
  44. };
  45. inline void TComRef<ITypeInfo>::ClearData()
  46. {
  47.   memset((char*)this  + sizeof(TComRefBase<ITypeInfo>), 0,
  48.         sizeof(*this) - sizeof(TComRefBase<ITypeInfo>) );
  49. };
  50. TComRef<ITypeInfo>::TComRef() : TComRefBase<ITypeInfo>()
  51. {
  52.   ClearData();
  53. }
  54. TComRef<ITypeInfo>::TComRef(ITypeInfo* i) : TComRefBase<ITypeInfo>(i)
  55. {
  56.   ClearData();
  57. }
  58. TComRef<ITypeInfo>::TComRef(const TComRef<ITypeInfo>& i)
  59.                   : TComRefBase<ITypeInfo>(i)
  60. {
  61.   ClearData();
  62. }
  63. TComRef<ITypeInfo>::~TComRef()
  64. {
  65.   if (Attr) I->ReleaseTypeAttr(Attr);
  66.   if (FuncDesc) I->ReleaseFuncDesc(FuncDesc);
  67.   if (VarDesc)  I->ReleaseVarDesc(VarDesc);
  68.   ::SysFreeString(Name);
  69.   ::SysFreeString(Doc);
  70. }
  71. inline ITypeInfo*
  72. TComRef<ITypeInfo>::operator =(ITypeInfo* iface)
  73. {
  74.   TComRef<ITypeInfo>::~TComRef();
  75.   ClearData();
  76.   return I = iface;
  77. }
  78. inline TComRef<ITypeInfo>&
  79. TComRef<ITypeInfo>::operator =(const TComRef<ITypeInfo>& i)
  80. {
  81.   TComRef<ITypeInfo>::~TComRef();
  82.   ClearData();
  83.   I = i.I;
  84.   return *this;
  85. }
  86. inline
  87. TComRef<ITypeInfo>::operator ITypeInfo* far*()
  88. { 
  89.   TComRef<ITypeInfo>::~TComRef();
  90.   ClearData();
  91.   return &I;
  92. }
  93. void TComRef<ITypeInfo>::GetDocumentation(MEMBERID memberid)
  94. {
  95.   ::SysFreeString(Name);
  96.   ::SysFreeString(Doc);
  97.   OLECALL(I->GetDocumentation(memberid, &Name, &Doc, 0, 0),"TypeInfo::GetDoc");
  98. }
  99. void TComRef<ITypeInfo>::GetAttr()
  100. {
  101.   if (Attr) I->ReleaseTypeAttr(Attr);
  102.   OLECALL(I->GetTypeAttr(&Attr),"TypeInfo::GetTypeAttr");
  103. }
  104. void TComRef<ITypeInfo>::GetFuncDesc(unsigned int index)
  105. {
  106.   if (FuncDesc) I->ReleaseFuncDesc(FuncDesc);
  107.   OLECALL(I->GetFuncDesc(index, &FuncDesc),"TypeInfo::GetFuncDesc");
  108. }
  109. void TComRef<ITypeInfo>::GetVarDesc( unsigned int index)
  110. {
  111.   if (VarDesc)  I->ReleaseVarDesc(VarDesc);
  112.   OLECALL(I->GetVarDesc(index, &VarDesc),"TypeInfo::GetVarDesc");
  113. }
  114.  
  115. class TComRef<ITypeLib> : public TComRefBase<ITypeLib> {
  116.   public:
  117.     TComRef();
  118.     TComRef(ITypeLib* iface);
  119.     TComRef(const TComRef<ITypeLib>& i);
  120.    ~TComRef();
  121.     ITypeLib* operator =(ITypeLib* iface) {if(I)I->Release(); return I = iface;}
  122.     ITypeLib* operator =(const TComRef<ITypeLib>& i){if(I)I->Release(); return I=i.I;}
  123.     ITypeLib* operator->() {return I;}
  124.     void GetAttr();
  125.     void GetDocumentation(int index = -1);
  126.     TLIBATTR far* Attr;
  127.     BSTR Name;
  128.     BSTR Doc;
  129. };
  130. TComRef<ITypeLib>::TComRef() : TComRefBase<ITypeLib>(),
  131.                                Name(0), Doc(0), Attr(0){}
  132. TComRef<ITypeLib>::TComRef(ITypeLib* i) : TComRefBase<ITypeLib>(i),
  133.                                Name(0), Doc(0), Attr(0){}
  134. TComRef<ITypeLib>::TComRef(const TComRef<ITypeLib>& i) : TComRefBase<ITypeLib>(i),
  135.                                Name(0), Doc(0), Attr(0){}
  136. TComRef<ITypeLib>::~TComRef()
  137. {
  138.   if (Attr) I->ReleaseTLibAttr(Attr);
  139.   ::SysFreeString(Name);
  140.   ::SysFreeString(Doc);
  141. }
  142. void TComRef<ITypeLib>::GetDocumentation(int index)
  143. {
  144.   ::SysFreeString(Name);
  145.   ::SysFreeString(Doc);
  146.   OLECALL(I->GetDocumentation(index, &Name, &Doc, 0, 0),"TypeLib::GetDoc");
  147. }
  148. void TComRef<ITypeLib>::GetAttr()
  149. {
  150.   if (Attr) I->ReleaseTLibAttr(Attr);
  151.   OLECALL(I->GetLibAttr(&Attr),"TypeLib::GetAttr");
  152. }
  153.  
  154. //____________________________________________________________________________
  155. //
  156. // Error handling facility using local exception object
  157. //____________________________________________________________________________
  158.  
  159. struct TLocalError {   // local exception object for this program
  160.   TLocalError(const char* title, const char* message)
  161.                   : Title(title),    Message(message) {}
  162.   const char* Title;
  163.   const char* Message;
  164. };
  165.  
  166. static void Error(const char* title, const char* message)
  167. {
  168.   throw TLocalError(title,message);
  169. }
  170.  
  171. static inline void ErrorIf(int error, const char* title, int resId)
  172. {
  173.   if (error)
  174.     Error(title, (char*)resId);
  175. }
  176. static inline void ErrorIf(int error, int resId, const char* message)
  177. {
  178.   if (error)
  179.     Error((char*)resId, message);
  180. }
  181. static inline void ErrorIf(int error, const char* title, const char* message)
  182. {
  183.   if (error)
  184.     Error(title,message);
  185. }
  186.  
  187. //____________________________________________________________________________
  188. //
  189. // ITypeInfo iterator, emits C++ code
  190. //____________________________________________________________________________
  191.  
  192. // TypeInfo/TypeLib processing flags
  193.  
  194. const int tfEnum      = 1<<TKIND_ENUM;
  195. const int tfRecord    = 1<<TKIND_RECORD;
  196. const int tfModule    = 1<<TKIND_MODULE;
  197. const int tfInterface = 1<<TKIND_INTERFACE;
  198. const int tfDispatch  = 1<<TKIND_DISPATCH;
  199. const int tfCoClass   = 1<<TKIND_COCLASS;
  200. const int tfAlias     = 1<<TKIND_ALIAS;
  201. const int tfUnion     = 1<<TKIND_UNION;
  202. const int tfAllKinds  =(1<<TKIND_MAX)-1;
  203. const int tfScanOnly  = 1<<15;
  204. const int tfLibHeader = 1<<14;
  205. const int tfDispHeader= 1<<13;
  206. const int tfDispImpl  = 1<<12;
  207. const int tfBoolType  = 1<<11;  // OR into libMode[1] if compiler bool support
  208.  
  209. char* infoKind[] = 
  210.   {"ENUM","RECORD","MODULE","INTERFACE","DISPATCH","COCLASS","ALIAS","UNION"};
  211.  
  212. char* typeFlagText[] = {
  213.   "appobject",     // 1   TYPEFLAG_FAPPOBJECT
  214.   "cancreate",     // 2   TYPEFLAG_FCANCREATE
  215.   "licensed",      // 4   TYPEFLAG_FLICENSED
  216.   "predeclid",     // 8   TYPEFLAG_FPREDECLID
  217.   "hidden",        // 16  TYPEFLAG_FHIDDEN
  218.   "control",       // 32  TYPEFLAG_FCONTROL
  219.   "dual",          // 64  TYPEFLAG_FDUAL
  220.   "nonextensible", // 128 TYPEFLAG_FNONEXTENSIBLE
  221.   "oleautomation", // 256 TYPEFLAG_FOLEAUTOMATION
  222.   "TYPEFLAG256",
  223.   "TYPEFLAG512",
  224. };
  225. const int typeFlagCount = sizeof(typeFlagText)/sizeof(char*);
  226.  
  227. char* implFlagText[] = {
  228.   "default",       // 1 IMPLTYPEFLAG_FDEFAULT
  229.   "source",        // 2 IMPLTYPEFLAG_FSOURCE
  230.   "restricted",    // 4 IMPLTYPEFLAG_FRESTRICTED
  231.   "IMPLTYPEFLAG8",
  232.   "IMPLTYPEFLAG16",
  233.   "IMPLTYPEFLAG32",
  234. };
  235. const int implFlagCount = sizeof(implFlagText)/sizeof(char*);
  236.  
  237. char* memberFlagText[] = {
  238.   "restricted",   // 1   FUNCFLAG_FRESTRICTED (VARFLAG_FREADONLY->invokeKind)
  239.   "source",       // 2   FUNCFLAG_FSOURCE       VARFLAG_FSOURCE
  240.   "bindable",     // 4   FUNCFLAG_FBINDABLE     VARFLAG_FBINDABLE
  241.   "requestedit",  // 8   FUNCFLAG_FREQUESTEDIT  VARFLAG_FREQUESTEDIT
  242.   "displaybind",  // 16  FUNCFLAG_FDISPLAYBIND  VARFLAG_FDISPLAYBIND
  243.   "defaultbind",  // 32  FUNCFLAG_FDEFAULTBIND  VARFLAG_FDEFAULTBIND
  244.   "hidden",       // 64  FUNCFLAG_FHIDDEN       VARFLAG_FHIDDEN
  245.   "FUNCFLAG128",
  246.   "FUNCFLAG256",
  247. };
  248. const int memberFlagCount = sizeof(memberFlagText)/sizeof(char*);
  249.  
  250. char* infoCpp[] =     // add delimiting space after identifier as needed
  251.   {"enum ","struct ","","class _ICLASS ","class ","//","typedef ","union "};
  252.  
  253. char* invokeKind[] = {
  254.   "",              // 0 no INVOKEKIND flags
  255.   "method",        // 1 INVOKE_FUNC
  256.   "propget",       // 2 INVOKE_PROPERTYGET
  257.   "prop r/o",      // 3 VAR_DISPATH + VARFLAG_FREADONLY
  258.   "propset",       // 4 INVOKE_PROPERTYPUT
  259.   "?"       ,      // 5
  260.   "propgetset",    // 6 
  261.   "prop r/w",      // 7 VAR_DISPATCH
  262.   "propputref",    // 8 INVOKE_PROPERTYPUTREF
  263.   "?",             // 9
  264.   "?"              // 10
  265. };
  266.  
  267. char* dataType[] = {
  268.   "void",          //  0 void
  269.   "NULL",          //  1 SQL NULL
  270.   "short",         //  2 signed short
  271.   "long",          //  3 signed long
  272.   "float",         //  4 IEEE 4-byte
  273.   "double",        //  5 IEEE 8-byte
  274.   "CY",            //  6 currency
  275.   "DATE",          //  7 datetime as double
  276.   "BSTR",          //  8 char far* global mem with int size before
  277.   "IDispatch*",    //  9 dispatch interface
  278.   "SCODE",         // 10 OLE return status
  279.   "bool",          // 11 boolean
  280.   "VARIANT far*",  // 12 pointer to VARIANT union
  281.   "IUnknown*",     // 13 unspecified COM interface
  282.   "<14>",
  283.   "<15>",
  284.   "signed char",   // 17 unsigned char, byte
  285.   "unsigned char",
  286.   "unsigned short",
  287.   "unsigned long",
  288.   "LARGE_INTEGER",
  289.   "ULARGE_INTEGER",
  290.   "signed int",
  291.   "unsigned int",
  292.   "void",
  293.   "HRESULT",
  294.   "<ptr>",
  295.   "<27>",
  296.   "<array>",
  297.   "<userdef>",
  298.   "char far*",
  299.   "wchar far*",
  300. };
  301. const int dataTypeCount = sizeof(dataType)/sizeof(char*);
  302.  
  303. char* autoType[] = {
  304.   "void",          //  0 void
  305.   "NULL",          //  1 SQL NULL
  306.   "short",         //  2 signed short
  307.   "long",          //  3 signed long
  308.   "float",         //  4 IEEE 4-byte
  309.   "double",        //  5 IEEE 8-byte
  310.   "TAutoCurrency", //  6 currency
  311.   "TAutoDate",     //  7 datetime as double
  312.   "TAutoString",   //  8 char far* global mem with int size before
  313. };
  314. const int autoTypeCount = sizeof(autoType)/sizeof(char*);
  315.  
  316.   char foldName[256+1] = {
  317.   "_\0_\0_\0f\0_\0_\0_\0_\0_\0_\0S\0_\0OE_\0_\0_\0"
  318.   "_\0_\0_\0_\0_\0_\0_\0_\0_\0TMs\0_\0oe_\0_\0Y\0"
  319.   "_\0_\0c\0L\0_\0Y\0_\0_\0_\0c\0a\0_\0_\0_\0r\0_\0"
  320.   "0\0_\0\062\0\063\0_\0u\0_\0_\0_\0\061\0o\0_\0_\0_\0_\0_\0"
  321.   "A\0A\0A\0A\0AEA\0AEC\0E\0E\0E\0E\0I\0I\0I\0I\0"
  322.   "D\0N\0O\0O\0O\0O\0OEx\0O\0U\0U\0U\0UEY\0_\0ss"
  323.   "a\0a\0a\0a\0aea\0aec\0e\0e\0e\0e\0i\0i\0i\0i\0"
  324.   "o\0n\0o\0o\0o\0o\0oe_\0o\0u\0u\0u\0uey\0_\0y\0"
  325. };
  326.  
  327. const int fnObjectByRef = 1;  // generate code passing proxy object by ref
  328. const int fnPrefixGet   = 2;  // prefix identifier name with "Get"
  329. const int fnPrefixSet   = 4;  // prefix identifier name with "Set"
  330. const int fnClassName   = 8;  // add classname:: before identifier
  331. const int fnAutoTypes   = 16; // translate types to wrappered TAuto...
  332. const int fnIterator    = 32; // emit TAutoIterator<type>&
  333.  
  334. bool IsDispObject(ITypeInfo* typeInfo, TYPEDESC far& typeDesc)
  335. {
  336.   if (typeDesc.vt != VT_USERDEFINED)
  337.     return false;
  338.   TComRef<ITypeInfo> refTypeInfo;
  339.   OLECALL(typeInfo->GetRefTypeInfo(typeDesc.hreftype,refTypeInfo),"TypeInfo::GetRefTypeInfo");
  340.   refTypeInfo.GetAttr();
  341.   return refTypeInfo.Attr->typekind==TKIND_DISPATCH;
  342. }
  343.  
  344. char* ClassName = 0;   // will become member variable
  345.  
  346. bool FormatTypeName(ITypeInfo* typeInfo, TYPEDESC far& typeDescRef,
  347.                    char far* name, ostream& out, int flags = 0)
  348. {
  349.   bool isDispObject = false;
  350.   TYPEDESC far* typeDesc = &typeDescRef;
  351.   ARRAYDESC far* arrayDesc = 0;
  352.   if (flags & fnIterator)
  353.     out << "TAutoEnumerator<";
  354.   for (int derefCount = 0; typeDesc->vt == VT_PTR; derefCount++)
  355.     typeDesc = typeDesc->lptdesc;
  356.   if (typeDesc->vt == VT_USERDEFINED) {
  357.     TComRef<ITypeInfo> refTypeInfo;
  358.     OLECALL(typeInfo->GetRefTypeInfo(typeDesc->hreftype,refTypeInfo),"TypeInfo::GetRefTypeInfo");
  359.     refTypeInfo.GetDocumentation();
  360.     out << refTypeInfo.Name;
  361.     refTypeInfo.GetAttr();
  362.     if (flags & fnObjectByRef && refTypeInfo.Attr->typekind==TKIND_DISPATCH &&
  363.         !(flags & fnIterator)){
  364.       out << '&';    // need reference for automation proxy class
  365.     } isDispObject = true;
  366.   } else if (typeDesc->vt == VT_CARRAY) {
  367.     arrayDesc = typeDesc->lpadesc;
  368.     FormatTypeName(typeInfo, arrayDesc->tdescElem, 0, out);
  369.   } else {
  370.     if ((flags & fnAutoTypes) && (typeDesc->vt & 31) < autoTypeCount)
  371.       out << autoType[typeDesc->vt & 31];
  372.     else
  373.       out << dataType[typeDesc->vt & 31];
  374.   }
  375.   if (typeDesc->vt & VT_BYREF)  // should never happen
  376.     derefCount++;
  377.   while (derefCount--)
  378.     out << " far*";
  379.   if (flags & fnIterator)
  380.     out << ">&";
  381.   if (name) {
  382.     char* buf;
  383.     int len = lstrlen(name);
  384.     int nonascii = 0;
  385.     for (unsigned char far* pc = (unsigned char far*)name; *pc; pc++)
  386.       if (*pc >= 128)
  387.         nonascii++;
  388.     if (nonascii) {
  389.       unsigned char far* pn = (unsigned char far*)name;
  390.       buf = new char[nonascii + len + 1];
  391.       name = buf;
  392.       unsigned char c;
  393.       do {
  394.         c = *pn++;
  395.         if (c < 128) {
  396.           *buf++ = c;
  397.         } else {
  398.           char* px = foldName + (c-128)*2;
  399.           *buf++ = *px++;
  400.           if (*px)
  401.             *buf++ = *px;
  402.         }
  403.       } while (c);
  404.     }
  405.     out << ' ';
  406.     if (ClassName && (flags & fnClassName))
  407.       out << ClassName << "::";
  408.     if (flags & fnPrefixGet)
  409.       out << "Get";
  410.     if (flags & fnPrefixSet)
  411.       out << "Set";
  412.     out << name;
  413.     if (nonascii)
  414.       delete name;
  415.   }
  416.   if (arrayDesc)
  417.     for (int dim = 0; dim < arrayDesc->cDims; dim++)
  418.       out << '[' << arrayDesc->rgbounds[dim].cElements << ']';
  419.   return isDispObject;
  420. }
  421.  
  422. void FormatGuidLang(GUID far& guid, LCID locale, ostream& out)
  423. {
  424.   char guidBuf[38+1] = "{NULL}"; 
  425.   int notNull = 0;
  426.   int far* pg = (int far*)&guid;
  427.   for (int i = sizeof(GUID)/sizeof(int); i--; pg++)
  428.     notNull |= *pg;
  429.   if (notNull)
  430.     wsprintf(guidBuf, "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  431.              guid.Data1, guid.Data2, guid.Data3,
  432.              guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
  433.              guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
  434.   out << ' ' << guidBuf << '\\' << hex << LANGIDFROMLCID(locale) << dec;
  435. }
  436.  
  437. void FormatVers(int major, int minor, ostream& out)
  438. {
  439.   if (major)
  440.     out << ' ' << major << '.' << minor;
  441. }
  442.  
  443. void FormatDispId(DISPID id, int invKind, uint16 flags, ostream& out)
  444. {
  445.   out << "[id(";
  446.   if ((long)id > 9999 || (long)id < -9999)
  447.     out << "0x" << hex << id << dec;
  448.   else
  449.     out << id;
  450.   out << ')';
  451.   if (invKind)
  452.     out << ", " << invokeKind[invKind];
  453.   for (int i = 0; flags; i++, flags >>= 1) {
  454.     if (flags & 1)
  455.       out << ", " << memberFlagText[i];
  456.   }
  457.   out << ']';
  458. }
  459.  
  460. // assumed that caller of this function called GetDocumenation() on typeInfo
  461.  
  462. void FormatTypeInfo(TComRef<ITypeInfo>& typeInfo, int mode, ostream& out)
  463. {
  464. //typeInfo.GetDocumentation();
  465.   typeInfo.GetAttr();
  466.   int kind = typeInfo.Attr->typekind;
  467.   if (typeInfo.Attr->typekind != TKIND_ALIAS) {
  468.     out << "\n// TKIND_" << infoKind[kind] << ": " << typeInfo.Name;
  469.     FormatVers(typeInfo.Attr->wMajorVerNum,typeInfo.Attr->wMinorVerNum,out);
  470.     FormatGuidLang(typeInfo.Attr->guid, typeInfo.Attr->lcid, out);
  471.     out << ' ' << typeInfo.Doc << '\n';
  472.     int typeFlags = typeInfo.Attr->wTypeFlags;
  473.     if (typeFlags && !(mode & (tfDispHeader | tfDispImpl))) {
  474.       char* delim = "//  [";
  475.       for (int tflag = 0; tflag < implFlagCount; tflag++, typeFlags >>= 1)
  476.         if (typeFlags & 1) {  
  477.           out << delim << typeFlagText[tflag];
  478.           delim = ", ";
  479.       }
  480.       out << "]\n";
  481.     }
  482.     out << '\n';
  483.     if (!(mode & tfDispImpl))
  484.       out << infoCpp[kind];
  485.   }
  486.   switch (kind) {
  487.     case TKIND_MODULE: {
  488.       for (int varIndex = 0; varIndex < typeInfo.Attr->cVars; varIndex++) {
  489.         typeInfo.GetVarDesc(varIndex);
  490.         typeInfo.GetDocumentation(typeInfo.VarDesc->memid);
  491.         out << "    ";
  492.         FormatTypeName(typeInfo, typeInfo.VarDesc->elemdescVar.tdesc, typeInfo.Name, out);
  493.         out << "; // ";
  494.         int invKind = typeInfo.VarDesc->wVarFlags & VARFLAG_FREADONLY ? 3 : 7;
  495.         FormatDispId(typeInfo.VarDesc->memid, invKind,
  496.                      typeInfo.VarDesc->wVarFlags & ~VARFLAG_FREADONLY, out);
  497.         out << '\n';
  498.       }
  499.       for (int funcIndex = 0; funcIndex < typeInfo.Attr->cFuncs; funcIndex++) {
  500.         typeInfo.GetFuncDesc(funcIndex);
  501.         typeInfo.GetDocumentation(typeInfo.FuncDesc->memid);
  502.         int argCount = typeInfo.FuncDesc->cParams;
  503.         int argIndex;
  504.         TBSTR argName[35];      // max. arg count + 1, minimum 35 for MSWord6
  505.         unsigned int nameCount;
  506.         OLECALL(typeInfo->GetNames(typeInfo.FuncDesc->memid, argName[0],
  507.                                    sizeof(argName)/sizeof(TBSTR), &nameCount),"TKIND_INTERFACE GetNames");
  508.         if (typeInfo.Doc)
  509.           out << "    // " << typeInfo.Doc << '\n';
  510.         out << "    ";
  511.         for (argIndex = 0; argIndex <= argCount; argIndex++) {
  512.           ELEMDESC far* elemDesc = argIndex==0 ?
  513.                           &typeInfo.FuncDesc->elemdescFunc :
  514.                           typeInfo.FuncDesc->lprgelemdescParam + (argIndex-1);
  515.           FormatTypeName(typeInfo, elemDesc->tdesc, argIndex < nameCount ?
  516.                          (char far*)argName[argIndex] : (char far*)0, out);
  517.           if (argIndex == 0)
  518.             out << '(';
  519.           else if (argIndex != argCount)
  520.             out << ", ";
  521.         }
  522.         out << "); // ";
  523.         FormatDispId(typeInfo.FuncDesc->memid, 0,
  524.                      typeInfo.FuncDesc->wFuncFlags, out);
  525.         out << '\n';
  526.       }
  527.       out << "\n";
  528.       break;
  529.     }
  530.  
  531.     case TKIND_UNION:
  532.     case TKIND_RECORD: {
  533.       out << typeInfo.Name << " {\n"; /*}*/
  534.       for (int membIndex = 0; membIndex < typeInfo.Attr->cVars; membIndex++) {
  535.         typeInfo.GetVarDesc(membIndex);
  536.         typeInfo.GetDocumentation(typeInfo.VarDesc->memid);
  537.         out << "  ";
  538.         FormatTypeName(typeInfo, typeInfo.VarDesc->elemdescVar.tdesc, typeInfo.Name, out);
  539.         out << ";\n";
  540.       }
  541.       /*{*/ out << "};\n";
  542.       break;
  543.     }
  544.     case TKIND_ALIAS: {
  545.       out << infoCpp[kind] << ' ';
  546.       FormatTypeName(typeInfo, typeInfo.Attr->tdescAlias, typeInfo.Name, out);
  547.       out << ";\n";
  548.       break;
  549.     }
  550.     case TKIND_ENUM: {
  551.       out << typeInfo.Name << " {\n"; /*}*/
  552.       for (int enumIndex = 0; enumIndex < typeInfo.Attr->cVars; enumIndex++) {
  553.         typeInfo.GetVarDesc(enumIndex);
  554.         typeInfo.GetDocumentation(typeInfo.VarDesc->memid);
  555.         out << "  " << typeInfo.Name;
  556.         if (typeInfo.VarDesc->varkind == VAR_CONST
  557.          && typeInfo.VarDesc->lpvarValue->vt == VT_I2)
  558.           out << " = " << typeInfo.VarDesc->lpvarValue->iVal;
  559.         out << ",\n";
  560.       }
  561.       /*{*/ out << "};\n";
  562.       break;
  563.     }
  564.     case TKIND_INTERFACE: {
  565.       out << typeInfo.Name;
  566.       int baseCount = typeInfo.Attr->cImplTypes;
  567.       for (int baseIndex = 0; baseIndex < baseCount; baseIndex++) {
  568.         out << (baseIndex ==0 ? " : public " : ", public ");
  569.         HREFTYPE hrefType;
  570.         OLECALL(typeInfo->GetRefTypeOfImplType(baseIndex, &hrefType),"TKIND_INTERFACE GetRefTypeofImplType");
  571.         TComRef<ITypeInfo> refTypeInfo;
  572.         OLECALL(typeInfo->GetRefTypeInfo(hrefType, refTypeInfo),"TKIND_INTERFACE GetRefTypeInfo"); 
  573.         refTypeInfo.GetDocumentation();
  574.         out << refTypeInfo.Name;
  575.       }
  576.       out << " {\n  public:\n"; /*}*/
  577.       for (int funcIndex = 0; funcIndex < typeInfo.Attr->cFuncs; funcIndex++) {
  578.         typeInfo.GetFuncDesc(funcIndex);
  579.         typeInfo.GetDocumentation(typeInfo.FuncDesc->memid);
  580.         int argCount = typeInfo.FuncDesc->cParams;
  581.         int argIndex;
  582.         TBSTR argName[35];      // max. arg count + 1, minimum 35 for MSWord6
  583.         unsigned int nameCount;
  584.         OLECALL(typeInfo->GetNames(typeInfo.FuncDesc->memid, argName[0],
  585.                                    sizeof(argName)/sizeof(TBSTR), &nameCount),"TKIND_INTERFACE GetNames");
  586.         if (typeInfo.Doc)
  587.           out << "    // " << typeInfo.Doc << '\n';
  588.         if (typeInfo.FuncDesc->wFuncFlags & FUNCFLAG_FRESTRICTED)
  589.           out << "//  ";    // not accessible from dispatch controller
  590.         else
  591.           out << "    ";
  592.         for (argIndex = 0; argIndex <= argCount; argIndex++) {
  593.           ELEMDESC far* elemDesc = argIndex==0 ?
  594.                           &typeInfo.FuncDesc->elemdescFunc :
  595.                           typeInfo.FuncDesc->lprgelemdescParam + (argIndex-1);
  596.           FormatTypeName(typeInfo, elemDesc->tdesc, argIndex < nameCount ?
  597.                          (char far*)argName[argIndex] : (char far*)0, out);
  598.           if (argIndex == 0)
  599.             out << '(';
  600.           else if (argIndex != argCount)
  601.             out << ", ";
  602.         }
  603.         out << ") = 0; // ";
  604.         FormatDispId(typeInfo.FuncDesc->memid, 0,
  605.                      typeInfo.FuncDesc->wFuncFlags, out);
  606.         out << '\n';
  607.       }
  608.       /*{*/ out << "};\n";
  609.       break;
  610.     }
  611.     case TKIND_DISPATCH: {
  612.       TYPEDESC typeDescVoid;
  613.       typeDescVoid.vt = VT_VOID;
  614.       char semi;
  615.       if (mode & tfDispImpl) {
  616.         ClassName = new char[lstrlen(typeInfo.Name)+1];
  617.         lstrcpy(ClassName, typeInfo.Name);
  618.         semi = ' ';
  619.       } else {
  620.         semi = ';';
  621.         out << typeInfo.Name;
  622.         if (mode & tfDispHeader)
  623.           out << " : public TAutoProxy";
  624.         out << " {\n  public:\n"; /*}*/
  625.         if (mode & tfDispHeader)
  626.           out << "    " << typeInfo.Name << "() : TAutoProxy(0x"
  627.               << hex << LANGIDFROMLCID(typeInfo.Attr->lcid) << dec << ") {}\n";
  628.       }
  629.       for (int varIndex = 0; varIndex < typeInfo.Attr->cVars; varIndex++) {
  630.         int formatFlags = 0;
  631.         if (mode & tfDispHeader)
  632.           formatFlags = fnObjectByRef | fnPrefixGet | fnAutoTypes;
  633.         if (mode & tfDispImpl)
  634.           formatFlags = fnObjectByRef | fnPrefixGet | fnClassName | fnAutoTypes;
  635.         typeInfo.GetVarDesc(varIndex);
  636.         TYPEDESC& typeDesc = typeInfo.VarDesc->elemdescVar.tdesc;
  637.         int invKind = typeInfo.VarDesc->wVarFlags & VARFLAG_FREADONLY ? 3 : 7;
  638.         // should we insure that (type.Info.VarDesc->varkind==VAR_DISPATCH) ?
  639.         typeInfo.GetDocumentation(typeInfo.VarDesc->memid);
  640.         if (!(mode & tfDispImpl) && typeInfo.Doc)
  641.           out << "    // " << typeInfo.Doc << '\n';
  642.         bool isDispObject = IsDispObject(typeInfo, typeDesc);
  643.         bool boolProp = !(mode & tfBoolType) && typeDesc.vt == VT_BOOL;
  644.         bool boolRef  = !(mode & tfBoolType) && typeDesc.vt == VT_PTR
  645.                                     && typeDesc.lptdesc->vt == VT_BOOL;
  646.         do {
  647.           char* argName = 0;
  648.           if (!(mode & tfDispImpl))
  649.             out << "    ";
  650.           if (formatFlags == 0 || 
  651.              !((formatFlags & fnPrefixSet) || isDispObject)){
  652.             FormatTypeName(typeInfo, typeDesc, typeInfo.Name, out, formatFlags);
  653.             if (formatFlags & fnPrefixGet)
  654.               out << "()";
  655.             out << semi << "    ";
  656.           } else {
  657.             FormatTypeName(typeInfo,typeDescVoid,typeInfo.Name,out,formatFlags);
  658.             if (mode & tfDispImpl)
  659.               argName = isDispObject ? "obj" : "val";
  660.             out << '(';
  661.             FormatTypeName(typeInfo,typeDesc,argName,out,
  662.                            formatFlags & (fnObjectByRef | fnAutoTypes));
  663.             out << ')' << semi;
  664.           }
  665.           if (mode & tfDispImpl) {
  666.             out << "\n{\n  AUTONAMES0(\"" << typeInfo.Name
  667.                 << "\")\n  AUTOARGS0()\n  AUTOCALL_PROP_"; /*}*/
  668.             if (formatFlags & fnPrefixSet)
  669.               out << "SET";
  670.             else if (isDispObject)
  671.               out << "REF";
  672.             else if (boolProp)
  673.               out << "CONV(TAutoBool)";
  674.             else if (boolRef)
  675.               out << "CONV(TAutoBoolRef)";
  676.             else
  677.               out << "GET";
  678.             if (argName) {
  679.               if (boolProp)
  680.                 out << "(TAutoBool(" << argName << "))";
  681.               else if (boolRef)
  682.                 out << "(TAutoBoolRef(" << argName << "))";
  683.               else
  684.                 out << '(' << argName << ')';
  685.             }
  686.             /*{*/ out << "\n}\n";
  687.           } else {
  688.             out << " // ";
  689.             FormatDispId(typeInfo.VarDesc->memid, invKind,
  690.                          typeInfo.VarDesc->wVarFlags & ~VARFLAG_FREADONLY, out);
  691.           }
  692.           out << '\n';
  693.           if ((formatFlags & fnPrefixGet) && invKind == 7)
  694.             formatFlags ^= (fnPrefixGet | fnPrefixSet);
  695.           else
  696.             formatFlags = 0;
  697.         } while (formatFlags & fnPrefixSet);
  698.       }
  699.       for (int funcIndex = 0; funcIndex < typeInfo.Attr->cFuncs; funcIndex++) {
  700.         int formatFlags = 0;
  701.         if (mode & tfDispHeader)
  702.           formatFlags = fnObjectByRef | fnAutoTypes;
  703.         if (mode & tfDispImpl)
  704.           formatFlags = fnObjectByRef | fnAutoTypes | fnClassName;
  705.         typeInfo.GetFuncDesc(funcIndex);
  706.         if (typeInfo.FuncDesc->wFuncFlags & FUNCFLAG_FRESTRICTED)
  707.           continue;                 // not accessible from dispatch controller
  708.         typeInfo.GetDocumentation(typeInfo.FuncDesc->memid);
  709.         int argCount = typeInfo.FuncDesc->cParams;
  710.         TBSTR argNames[35];     // max. arg count + 1, minimum 35 for MSWord6
  711.         unsigned int nameCount;
  712.         OLECALL(typeInfo->GetNames(typeInfo.FuncDesc->memid, argNames[0],
  713.                 sizeof(argNames)/sizeof(TBSTR), &nameCount),"TKIND_DISPATCH GetNames");
  714.         if (!(mode & tfDispImpl)) {
  715.           if (typeInfo.Doc)
  716.             out << "    // " << typeInfo.Doc << '\n';
  717.           out << "    ";
  718.         }
  719.         int argIndex  = -1;   // index into ELEMDESC[], -1 for return type
  720.         int nameIndex = 0;    // index into name table, no propset param name
  721.         int outParam  = 0;    // index of type/name being output
  722.         bool voidRet = false;
  723.         bool boolRet = false;
  724.         bool boolRetRef = false;
  725.         bool isObject = false;
  726.         bool isIterator = (typeInfo.FuncDesc->memid == DISPID_NEWENUM);
  727.         for ( ; argIndex<argCount; argIndex++, outParam++) {
  728.           TYPEDESC far* typeDesc = &typeInfo.FuncDesc->elemdescFunc.tdesc;
  729.           if (argIndex >= 0)  {        // processing an argument
  730.             typeDesc = &typeInfo.FuncDesc->lprgelemdescParam[argIndex].tdesc;
  731.           } else if (outParam == 0 && (mode & (tfDispHeader | tfDispImpl)) &&
  732.                      (IsDispObject(typeInfo, *typeDesc) || isIterator)) {
  733.             typeDesc = &typeDescVoid;
  734.             argIndex--;           // reprocess return as first arg
  735.             isObject = true;
  736.           } else if (typeDesc->vt == VT_VOID || typeDesc->vt == VT_EMPTY) {
  737.             voidRet = true;
  738.           } else if (!(mode & tfBoolType) && typeDesc->vt == VT_BOOL) {
  739.             boolRet = true;
  740.           } else if (!(mode & tfBoolType) && typeDesc->vt == VT_PTR
  741.                                  && typeDesc->lptdesc->vt == VT_BOOL) {
  742.             boolRetRef = true;
  743.           }
  744.           char far* name = 0;
  745.           char argName[10];
  746.           if (isObject && argIndex == -1) {
  747.             if (mode & tfDispImpl)
  748.               name = "obj";
  749.             if (isIterator)
  750.               formatFlags |= fnIterator;
  751.           } else if (argIndex==0 && typeInfo.FuncDesc->invkind>=INVOKE_PROPERTYPUT) {
  752.             if (mode & tfDispImpl)
  753.               name = "val";
  754.           } else if (nameIndex >= nameCount) {
  755.             if (mode & tfDispImpl)
  756.               wsprintf(name = argName, "arg%d", argIndex+1);
  757.           } else
  758.             name = argNames[nameIndex++];
  759.           if (outParam == 0 && (mode & (tfDispHeader | tfDispImpl))) {
  760.             if (typeInfo.FuncDesc->invkind>=INVOKE_PROPERTYPUT)
  761.               formatFlags |= fnPrefixSet;  // must differentiate from get
  762.             else if (typeInfo.FuncDesc->invkind==INVOKE_PROPERTYGET) {
  763.               if (isIterator)
  764.                 name = "Enumerate";
  765.               else
  766.                 formatFlags |= fnPrefixGet;  // get&set may have same name
  767.             }
  768.           }
  769.           FormatTypeName(typeInfo, *typeDesc, name, out, formatFlags);
  770.           formatFlags &= ~fnIterator;
  771.           if (outParam == 0) {
  772.             out << '(';
  773.             formatFlags &= ~(fnClassName | fnPrefixGet | fnPrefixSet);
  774.           }
  775.           else if (argIndex != argCount-1)
  776.             out << ", ";
  777.         }
  778.         out << ')' << semi;
  779.         if (mode & tfDispImpl) {
  780.           out << "\n{\n  AUTONAMES0("; /*}*/
  781.           if (isIterator)
  782.             out << "DISPID_NEWENUM";
  783.           else
  784.             out << '"' << typeInfo.Name << '"';
  785.           if (typeInfo.FuncDesc->invkind>=INVOKE_PROPERTYPUT)
  786.             argCount--;
  787.           out << ")\n  AUTOARGS" << argCount << '(';
  788.           argIndex = 1;                 // 1-based for following loop
  789.           for ( ; argIndex <= argCount; argIndex++) { // 1-based
  790.             if (argIndex != 1)
  791.               out << ", ";
  792.             TYPEDESC far& typeDesc =
  793.                        typeInfo.FuncDesc->lprgelemdescParam[argIndex-1].tdesc;
  794.             bool boolArg = !(mode & tfBoolType) && typeDesc.vt == VT_BOOL;
  795.             bool boolRef = !(mode & tfBoolType) && typeDesc.vt == VT_PTR
  796.                                        && typeDesc.lptdesc->vt == VT_BOOL;
  797.             if (boolArg)
  798.               out << "TAutoBool(";
  799.             else if (boolRef)
  800.               out << "TAutoBoolRef(";
  801.             if (argIndex < nameCount)
  802.               out << argNames[argIndex];
  803.             else
  804.               out << "arg" << argIndex;
  805.             if (boolArg || boolRef)
  806.               out << ")";
  807.           }
  808.           out << ")\n  AUTOCALL_";
  809.           if (typeInfo.FuncDesc->invkind==INVOKE_PROPERTYGET) {
  810.             if (isObject)
  811.               out << "PROP_REF(obj)";
  812.             else
  813.               out << "PROP_GET";
  814.           } else if (typeInfo.FuncDesc->invkind==INVOKE_PROPERTYPUT) {
  815.             out << "PROP_SET(val)";
  816.           } else {
  817.             out << "METHOD_";
  818.             if (isObject)
  819.               out << "REF(obj)";
  820.             else if (voidRet)
  821.               out << "VOID";
  822.             else if (boolRet)
  823.               out << "CONV(TAutoBool)";
  824.             else if (boolRetRef)
  825.               out << "CONV(TAutoBoolRef)";
  826.             else
  827.               out << "RET";
  828.           }
  829.           /*{*/ out << "\n}\n";  //(for editor brace check)
  830.         } else {
  831.           out << " // ";
  832.           FormatDispId(typeInfo.FuncDesc->memid,
  833.                        typeInfo.FuncDesc->invkind,
  834.                        typeInfo.FuncDesc->wFuncFlags, out);
  835.         }
  836.         out << '\n';
  837.       }
  838.       if (!(mode & tfDispImpl))
  839.         /*{*/ out << "};\n";
  840.       break;
  841.     }
  842.     case TKIND_COCLASS: {
  843.       for (unsigned int cindex=0; cindex<typeInfo.Attr->cImplTypes; cindex++) {
  844.         HREFTYPE hrefType;
  845.         OLECALL(typeInfo->GetRefTypeOfImplType(cindex, &hrefType), "GetRefTypeofImplType");
  846.         int typeFlags;
  847.         OLECALL(typeInfo->GetImplTypeFlags(cindex, &typeFlags), "GetImplTypeFlags");
  848.         TComRef<ITypeInfo> refTypeInfo;
  849.         OLECALL(typeInfo->GetRefTypeInfo(hrefType, refTypeInfo),"TKIND_COCLASS GetRefTypeInfo"); 
  850.         refTypeInfo.GetDocumentation();
  851.         out << "\n//  " << refTypeInfo.Name;
  852.         char* delim = "  [";
  853.         if (typeFlags) {
  854.           for (int iflag = 0; iflag < implFlagCount; iflag++, typeFlags >>= 1)
  855.             if (typeFlags & 1) {
  856.               out << delim << implFlagText[iflag];
  857.               delim = ", ";
  858.             }
  859.           out << ']';
  860.         }
  861.       }
  862.       out << "\n\n";
  863.       break;
  864.     }
  865.   }
  866.   delete ClassName;
  867.   ClassName = 0;
  868. }
  869.  
  870. //____________________________________________________________________________
  871. //
  872. // Local class to hold selection and iterator information for type library
  873. //____________________________________________________________________________
  874.  
  875. class TLogTypeInfo {
  876.   public:
  877.     typedef bool (*TCall)(TLogTypeInfo&);
  878.  
  879.     TLogTypeInfo(HWND hWnd);
  880.    ~TLogTypeInfo()        {delete SelectList;}
  881.     bool  Report();
  882.     HWND  GetWindow()      {return Window;}
  883.     int   GetSelectCount() {return SelectCount;}
  884.     int*  GetSelectList()  {return SelectList;}
  885.     void  SetSelectList(int count, int* list);
  886.     int   GetRequestCount() {return ReqCount;}
  887.     void  SetRequestList(int count, int* list, char** names);
  888.     void  SetCallback(TLogTypeInfo::TCall proc) {Proc = proc;}
  889.     bool  MatchRequest();  // return true to continue, false if all done
  890.     char* ExtractRequest();// return unmatched type name, 0 if list empty
  891.     void ClearLists();
  892.     int   Index;        // returned selection index, within user select types
  893.     int   TypeIndex;    // returned typeinfo index, within entire type library
  894.     char* TypeKind;     // returned typeinfo kind text
  895.     char far* TypeName; // returned typeinfo name text
  896.   private:
  897.     char** ReqNames;    // temp requested type names
  898.     int    ReqCount;    // temp requested name count
  899.     int*   SelectList;  // list of selected typeinfos in type library
  900.     int    SelectCount; // number of selected items
  901.     HWND   Window;      // window to receive data
  902.     TCall  Proc;        // callback function to display data
  903. };
  904. inline TLogTypeInfo::TLogTypeInfo(HWND hWnd)
  905.                     : Window(hWnd), SelectList(0), Proc(0)
  906. {
  907.   ClearLists();  // SelectList must be 0 to prevent delete of garbage
  908. }
  909. inline void TLogTypeInfo::ClearLists()
  910. {
  911.   if(!ReqNames)
  912.     delete SelectList;
  913.   ReqNames = 0;
  914.   SelectList = 0;
  915.   SelectCount = 0;
  916.   ReqCount = 0;
  917. }
  918. inline void TLogTypeInfo::SetSelectList(int count, int* list)
  919. {
  920.   ClearLists();
  921.   SelectCount = count;
  922.   SelectList = list;
  923. }
  924. inline void TLogTypeInfo::SetRequestList(int count, int* list, char** names)
  925. {
  926.   ClearLists();
  927.   ReqCount = count;
  928.   ReqNames = names;
  929.   SelectList = list;
  930. }
  931. inline bool TLogTypeInfo::Report()
  932. {
  933.   return Proc ? Proc(*this) : MatchRequest();
  934. }
  935. bool TLogTypeInfo::MatchRequest()
  936. {
  937.   if (!ReqCount)
  938.     return false;
  939.   for (int i = 0; i < ReqCount; i++) {
  940.     if (stricmp(TypeName, ReqNames[i]) == 0) {
  941.       SelectList[SelectCount++] = TypeIndex;
  942.       if (--ReqCount != i)
  943.         memcpy(&ReqNames[i],&ReqNames[i+1],(ReqCount-i)*sizeof(int));
  944.       return ReqCount != 0;
  945.     }
  946.   }  
  947.   return true;  // keep going
  948. }
  949. char* TLogTypeInfo::ExtractRequest()
  950. {
  951.   if (!ReqCount)
  952.     return 0;
  953.   char* name = ReqNames[0];
  954.   if (--ReqCount)
  955.     memcpy(&ReqNames[0], &ReqNames[1], ReqCount*sizeof(int));
  956.   return name;
  957. }
  958.  
  959. //____________________________________________________________________________
  960. //
  961. // ITypeLib iterator, emits file header info, calls ITypeInfo iterator
  962. //____________________________________________________________________________
  963.  
  964. void ReadTypeLib(char* libName, char* incName, int mode, ostream& out,
  965.                  TLogTypeInfo& log)
  966. {
  967.   try {       // catch OLE errors, no OLE calls are made outside of this block
  968.     char nameBuf[50];      // large enough for basename.tlb, overflow not fatal
  969.     TOleAllocator oleMem(0);
  970.     TComRef<ITypeLib> typeLib;
  971.     TComRef<ITypeInfo> coclassInfo;
  972.     OLECALL(::LoadTypeLib(libName, typeLib),"LoadTypeLib");
  973.     typeLib.GetAttr();
  974.     if (mode & tfLibHeader) {
  975.       typeLib.GetDocumentation();
  976.       if (::GetFileTitle(libName, nameBuf, sizeof(nameBuf)) <= 0)
  977.         out << "// Type Library: " << nameBuf;
  978.       out << "  " << typeLib.Doc << '\n';
  979.       out << "// " << typeLib.Name;
  980.       FormatVers(typeLib.Attr->wMajorVerNum, typeLib.Attr->wMinorVerNum, out);
  981.       FormatGuidLang(typeLib.Attr->guid, typeLib.Attr->lcid, out);
  982.       out << "\n\n";
  983.     }
  984.     int infoCount = typeLib->GetTypeInfoCount();
  985.     if (incName)
  986.       out << "#include " << incName << "\n";
  987.     if (mode & tfDispHeader) {
  988.       for (int infoIndex = 0; infoIndex < infoCount; infoIndex++) {
  989.         TYPEKIND infoType;
  990.         typeLib->GetTypeInfoType(infoIndex, &infoType);
  991.         if (infoType == TKIND_DISPATCH) {
  992.           TComRef<ITypeInfo> typeInfo;
  993.           OLECALL(typeLib->GetTypeInfo(infoIndex, typeInfo),"typeLib->GetTypeInfo");
  994.           typeInfo.GetDocumentation();
  995.           out << "\nclass " << typeInfo.Name << ';';
  996.         }
  997.         if (infoType == TKIND_COCLASS) {
  998.           OLECALL(typeLib->GetTypeInfo(infoIndex, coclassInfo),"typeLib->GetTypeInfo");
  999.         }
  1000.       }
  1001.       out << "\n";
  1002.     }
  1003.     // need to scan coclass typeinfo for [source] classes
  1004.     // and eliminate them from HXX/CXX code generation
  1005.     // eventually should emit server code tables
  1006.     //
  1007.     int  infoIndex = 0;
  1008.     int  selIndex  = 0;
  1009.     int  selCount  = log.GetSelectCount();
  1010.     int* selList   = log.GetSelectList();
  1011.     for (; infoIndex < infoCount; infoIndex++) {
  1012.       if (selList && !(mode & tfScanOnly)) {     // partial selection
  1013.         if (!selCount || infoIndex != selList[selIndex])
  1014.           continue;
  1015.         selCount--;
  1016.       }
  1017.       TYPEKIND infoType;
  1018.       typeLib->GetTypeInfoType(infoIndex, &infoType);
  1019.       if (((1<<infoType) & mode) == 0)
  1020.         continue;
  1021.       TComRef<ITypeInfo> typeInfo;
  1022.       OLECALL(typeLib->GetTypeInfo(infoIndex, typeInfo),"GetTypeInfo");
  1023.       typeInfo.GetDocumentation();
  1024.       typeInfo.GetAttr();
  1025.       log.TypeIndex = infoIndex;
  1026.       log.Index     = selIndex++;
  1027.       log.TypeName  = typeInfo.Name;
  1028.       log.TypeKind  = infoKind[infoType];
  1029.       if (!log.Report())
  1030.         break;
  1031.       if (mode & tfScanOnly)
  1032.         continue;
  1033.       FormatTypeInfo(typeInfo, mode, out);
  1034.     }
  1035.   }
  1036.   catch(TXOle& x) {  // convert OLE exception into local exception
  1037.     Error(libName, x.why().c_str());
  1038.   }
  1039. }
  1040.  
  1041. //____________________________________________________________________________
  1042. //
  1043. // Command line and UI processing, creates streams
  1044. //____________________________________________________________________________
  1045.  
  1046. #include <stdio.h>
  1047. #include <conio.h>
  1048. #include <string.h>
  1049. #include <fstream.h>
  1050. #include <strstrea.h>
  1051.  
  1052. // Command line token extraction class
  1053.  
  1054. class TCmdLine {
  1055.   public:
  1056.     enum Kind {Null, Name, Option, Value};
  1057.     TCmdLine(char far* cmdLine);
  1058.    ~TCmdLine();
  1059.     Kind  NextToken();
  1060.     int   TokenLen;
  1061.     char* Token;
  1062.     Kind  Type;
  1063.   private:
  1064.     char* Buf;
  1065.     Kind  NextType;
  1066. };
  1067.  
  1068. TCmdLine::TCmdLine(char far* cmdLine) : NextType(Name)
  1069. {
  1070.   Token = Buf = new char[lstrlen(cmdLine)+1];
  1071.   TokenLen = -1;         // cancels increment on next assignment
  1072.   lstrcpy(Buf, cmdLine);
  1073. }
  1074.  
  1075. TCmdLine::~TCmdLine()
  1076. {
  1077.   delete Buf;
  1078. }
  1079.  
  1080. TCmdLine::Kind TCmdLine::NextToken()
  1081. {
  1082.   Token += (TokenLen + 1);
  1083.   if (NextType == Name) {           // name or leading spaces
  1084.     Token += strspn(Token, " \t");  // skip leading white space
  1085.     switch (*Token++) {
  1086.       case 0:
  1087.         return Type = NextType = Null;
  1088.       case '=':
  1089.         Type = Value;
  1090.         break;
  1091.       case '-':
  1092.       case '/':
  1093.         Type = Option;
  1094.         break;
  1095.       default:
  1096.         Type = Name;
  1097.         Token--;
  1098.     }
  1099.   } else {   // must have stopped on a delimiter
  1100.     Type = NextType;
  1101.     if (Type == Null)
  1102.       return Type;
  1103.   }
  1104.   TokenLen = strcspn(Token, "=/- \t");
  1105.   char* nextToken = Token + TokenLen;
  1106.   switch (*nextToken) {
  1107.     case 0:
  1108.       NextType = Null;
  1109.       break;
  1110.     case '=':
  1111.       NextType = Value;
  1112.       break;
  1113.     case '-':
  1114.     case '/':
  1115.       NextType = Option;
  1116.       break;
  1117.     default:
  1118.       NextType = Name;
  1119.   }
  1120.   *nextToken = 0;  // null-terminate current token
  1121.   return Type;
  1122. }
  1123.  
  1124. // File name processing
  1125.  
  1126. enum  fileKind    { fkDispHdr, fkDispSrc, fkFullCpp,      fkCount };
  1127. char* optText[] = { "Header",  "Code",    "Definitions" };
  1128. char* fileExt[] = { "HXX",     "CXX",     "HPP" };
  1129. int   libMode[] = { tfEnum|tfAlias|tfDispatch|tfLibHeader|tfDispHeader,
  1130.                     tfDispatch|tfDispImpl, tfAllKinds|tfLibHeader };
  1131. char* stdFile[] = { ".HXX",    ".CXX",    0 };     // OC controller proxy code
  1132. char* cppFile[] = { 0,         0,         ".HPP" };// standard C++ defs       
  1133.  
  1134.  
  1135. int GenerateFiles(char* libName, char** outFiles, TLogTypeInfo& log)
  1136. {
  1137.   char outName[_MAX_PATH];
  1138.   char outDrive[_MAX_DRIVE];
  1139.   char outDir  [_MAX_DIR];
  1140.   char outFName[_MAX_FNAME];
  1141.   char outExt  [_MAX_EXT];
  1142.   char libDrive[_MAX_DRIVE];
  1143.   char libDir  [_MAX_DIR];
  1144.   char libFName[_MAX_FNAME];
  1145.   char libExt  [_MAX_EXT];
  1146.   char incFile [_MAX_FNAME+_MAX_EXT+2];
  1147.   char* incName;
  1148.  
  1149.   _splitpath(libName, libDrive, libDir, libFName, libExt);
  1150.   int outCount = 0;               // count of files actually output
  1151.   for (int fileIndex = 0; fileIndex < fkCount; fileIndex++) {
  1152.     if (!outFiles[fileIndex])
  1153.       continue;
  1154.     _splitpath(outFiles[fileIndex], outDrive, outDir, outFName, outExt);
  1155.     _makepath (outName,
  1156.                outDrive[0] ? outDrive : libDrive,
  1157.                outDir[0]   ? outDir   : libDir,
  1158.                outFName[0] ? outFName : libFName,
  1159.                outExt[0]   ? outExt   : fileExt[fileIndex]);
  1160.     ofstream out;
  1161.     out.open(outName);
  1162.     ErrorIf(out.bad(), outName, IDS_OUTFILEERR);
  1163.     switch(fileIndex) {
  1164.       case fkDispHdr:
  1165.         incName = "<ocf/automacr.h>";
  1166.         incFile[0] = '"';
  1167.         _splitpath(outName, 0, 0, incFile+1, outExt);
  1168.         strcat(incFile, outExt);
  1169.         strcat(incFile, "\"");
  1170.         break;
  1171.       case fkDispSrc:
  1172.         incName = incFile;
  1173.         break;
  1174.       case fkFullCpp:
  1175.         incName = 0;
  1176.         break;
  1177.     }
  1178.     if (log.GetWindow()) {
  1179.       ::SetDlgItemText(log.GetWindow(), IDC_STATUS,  (char far*)outName);
  1180.       int* selectList = log.GetSelectList();
  1181.       int  selectCount= log.GetSelectCount();
  1182.       if (!selectList) {
  1183.         ::SendDlgItemMessage(log.GetWindow(), IDC_INFOLIST, LB_SETSEL, 1, -1);
  1184.       } else if (outCount != 0) {
  1185.         for (int i = 0; i < selectCount; i++)
  1186.           ::SendDlgItemMessage(log.GetWindow(), IDC_INFOLIST, LB_SETSEL, 1,
  1187.                                (LPARAM)(unsigned)selectList[i]);
  1188.       }
  1189.     }
  1190.     ReadTypeLib(libName, incName, libMode[fileIndex], out, log);
  1191.     outCount++;
  1192.   }
  1193.   return 0;
  1194. }
  1195.  
  1196. #define WM_USERSTAT (WM_USER + 100)
  1197.  
  1198. bool CALLBACK __export
  1199. HelpProc(HWND hDlg, UINT msg, WPARAM /*wParam*/, LPARAM /*lParam*/)
  1200. {
  1201.   if (msg != WM_COMMAND)
  1202.     return (msg == WM_INITDIALOG);
  1203.   ::EndDialog(hDlg, TRUE);
  1204.   return true;
  1205. }
  1206.  
  1207. bool CALLBACK __export
  1208. SelectProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM /*lParam*/)
  1209. {
  1210.   if (msg == WM_INITDIALOG) {
  1211.     int tabs = IDC_INFOLIST_TAB;
  1212.     ::SendDlgItemMessage(hDlg, IDC_INFOLIST, LB_SETTABSTOPS, 1, (LPARAM)&tabs);
  1213.     ::SendDlgItemMessage(hDlg, IDC_AUTOCODE, BM_SETCHECK, 1, 0);
  1214.     return 1;
  1215.   } else if (msg == WM_COMMAND) {
  1216.     switch (wParam) {
  1217.       case IDOK:
  1218.       case IDCANCEL:    
  1219.         ::PostMessage(hDlg, WM_USERSTAT, wParam, 0);
  1220.         return 1;
  1221.       case IDC_SELECTALL:
  1222.       case IDC_SELECTNONE:
  1223.         ::SendDlgItemMessage(hDlg, IDC_INFOLIST, LB_SETSEL,
  1224.                              wParam==IDC_SELECTALL, -1);
  1225.         return 1;
  1226.     }
  1227.   } else if (msg == WM_CLOSE) {
  1228.     ::PostMessage(hDlg, WM_USERSTAT, IDABORT, 0);
  1229.   }
  1230.   return 0;
  1231. }
  1232.  
  1233. bool FillListBox(TLogTypeInfo& info)
  1234. {
  1235.   char buf[100];
  1236.   wsprintf(buf, "%s\t%s", (char far*)info.TypeKind, info.TypeName);
  1237.   ::SendDlgItemMessage(info.GetWindow(), IDC_INFOLIST, LB_ADDSTRING,
  1238.                        0, (LPARAM)(char far*)buf);
  1239.   MSG msg;
  1240.   while (::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
  1241.     ::IsDialogMessage(info.GetWindow(), &msg);
  1242.   return true;
  1243. }
  1244.  
  1245. bool ShowProgress(TLogTypeInfo& info)
  1246. {
  1247.   HWND hWnd = info.GetWindow();
  1248.   ::SendDlgItemMessage(hWnd, IDC_INFOLIST, LB_SETTOPINDEX, info.Index, 0);
  1249.   ::SendDlgItemMessage(hWnd, IDC_INFOLIST, LB_SETSEL,
  1250.                        0, (LPARAM)(unsigned)info.Index);
  1251.   MSG msg;
  1252.   while (::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
  1253.     ::IsDialogMessage(hWnd, &msg);
  1254.   return true;
  1255. }
  1256.  
  1257. bool SilentYield(TLogTypeInfo& /*info*/)
  1258. {
  1259.   MSG msg;
  1260.   while (::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
  1261.     ;
  1262. //  if (msg.message == WM_QUIT)
  1263. //    return false;
  1264.   return true;
  1265. }
  1266.  
  1267. const int MaxReqTypes = 20;  // maximum number of type names on command line
  1268.  
  1269. int PASCAL
  1270. WinMain(HINSTANCE hInst, HINSTANCE/*hPrev*/, char far* cmdLine, int/*show*/)
  1271. {
  1272.   TCmdLine cmd(cmdLine);
  1273.   char* outFiles[fkCount];
  1274.   int stat = 0;
  1275.  
  1276.   try {
  1277.     if (cmd.NextToken() == TCmdLine::Null) {
  1278.       //
  1279.       // If command line empty, create dialog and operate in interactive mode
  1280.       //
  1281.       char libName[_MAX_PATH];
  1282.       libName[0] = 0;
  1283.       HWND hWnd = ::CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_SELECT), 0,
  1284.                                       (DLGPROC)SelectProc, 0);
  1285.       OPENFILENAME ofn = {sizeof(OPENFILENAME), hWnd, hInst,
  1286.                           "TypeLib\0*.TLB;*.OLB\0",0,0,0,
  1287.                           libName, sizeof(libName), 0, 0,
  1288.                           0, "AUTOGEN - TypeLib to C++ Conversion",
  1289.                           OFN_HIDEREADONLY | OFN_FILEMUSTEXIST,
  1290.                           0,0,0,0,0,0 };
  1291.       while(::GetOpenFileName(&ofn)) {
  1292.         ::SetDlgItemText(hWnd, IDC_LIBFILE, (char far*)libName);
  1293.         ::ShowWindow(hWnd, SW_SHOW);
  1294.         TLogTypeInfo fillInfo(hWnd);
  1295.         fillInfo.SetCallback(FillListBox);
  1296.         strstream temp;
  1297.         ReadTypeLib(libName, 0, tfScanOnly | tfAllKinds, temp, fillInfo);
  1298.         MSG msg;
  1299.         int stat = 0;
  1300.         while ( !stat && ::GetMessage(&msg, 0, 0, 0)) {
  1301.           if (msg.message == WM_USERSTAT)
  1302.             stat = msg.wParam;
  1303.           else 
  1304.             ::IsDialogMessage(hWnd, &msg);
  1305.         }
  1306.         if (stat == IDABORT)
  1307.           break;
  1308.         if (stat == IDOK) {
  1309.           ::ShowWindow(::GetDlgItem(hWnd, IDC_SELECTALL),  SW_HIDE);
  1310.           ::ShowWindow(::GetDlgItem(hWnd, IDC_SELECTNONE), SW_HIDE);
  1311.           ::ShowWindow(::GetDlgItem(hWnd, IDC_STATUS),     SW_SHOW);
  1312.           int cppdefState = (int)::SendDlgItemMessage(hWnd, IDC_CPPDEF,
  1313.                                                      BM_GETCHECK, 0, 0);
  1314.           memcpy(outFiles, cppdefState ? cppFile : stdFile, sizeof(outFiles));
  1315.           fillInfo.SetCallback(ShowProgress);
  1316.           int* selectList = 0;
  1317.           int selectCount = (int)::SendDlgItemMessage(hWnd, IDC_INFOLIST,
  1318.                                                      LB_GETSELCOUNT, 0, 0);
  1319.           if (selectCount) {
  1320.             selectList = new int[selectCount];
  1321.             ::SendDlgItemMessage(hWnd, IDC_INFOLIST, LB_GETSELITEMS,
  1322.                                  selectCount, (LPARAM)(int far*)selectList);
  1323.           }
  1324.           fillInfo.SetSelectList(selectCount, selectList);
  1325.           stat = GenerateFiles(libName, outFiles, fillInfo);
  1326.           while (!::GetFocus() ||
  1327.                   ::GetWindowTask(::GetFocus())!=::GetCurrentTask())
  1328.             if (::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
  1329.               ::IsDialogMessage(hWnd, &msg);
  1330.           ::ShowWindow(::GetDlgItem(hWnd, IDC_SELECTALL),  SW_SHOW);
  1331.           ::ShowWindow(::GetDlgItem(hWnd, IDC_SELECTNONE), SW_SHOW);
  1332.           ::ShowWindow(::GetDlgItem(hWnd, IDC_STATUS),     SW_HIDE);
  1333.         }
  1334.         ::ShowWindow(hWnd, SW_HIDE);
  1335.         ::SendDlgItemMessage(hWnd, IDC_INFOLIST, LB_RESETCONTENT, 0, 0);
  1336.       }
  1337.       ::DestroyWindow(hWnd);
  1338.       return stat;
  1339.     }
  1340.     if (cmd.Type == TCmdLine::Name) {
  1341.       //
  1342.       //  If type library supplied on command line, operate in non-interactive
  1343.       //
  1344.       char* libName = cmd.Token;   // first argument should be a typelib name
  1345.       int optFound = 0;
  1346.       memset(outFiles, 0, sizeof(outFiles));
  1347.       char* reqTypes[MaxReqTypes];
  1348.       int   reqInfos[MaxReqTypes];
  1349.       int   reqCount = 0;
  1350.       int   optIndex = -1;
  1351.       while (cmd.NextToken() != TCmdLine::Null) {
  1352.         if (cmd.Type == TCmdLine::Option) {
  1353.           for (optIndex = 0; optIndex < fkCount; optIndex++) {
  1354.             if (strnicmp(cmd.Token, optText[optIndex], cmd.TokenLen) == 0)
  1355.               break;
  1356.           }
  1357.           ErrorIf(optIndex == fkCount, IDS_UNKNOWNOPT, cmd.Token);
  1358.           outFiles[optIndex] = "";
  1359.           optFound++;
  1360.         } else if (cmd.Type == TCmdLine::Value) {
  1361.           ErrorIf(optIndex == -1, IDS_MISSINGOPT, cmd.Token);
  1362.           outFiles[optIndex] = cmd.Token;
  1363.           optIndex = -1;
  1364.         } else {  // TCmdLine::Name  should be a class name to select
  1365.           ErrorIf(reqCount == MaxReqTypes, cmd.Token, IDS_TOOMANYTYPES);
  1366.           reqTypes[reqCount++] = cmd.Token;
  1367.         }
  1368.       }
  1369.       if (optFound == 0)  // if no file options, default to controller files
  1370.         memcpy(outFiles, stdFile, sizeof(outFiles));
  1371.       TLogTypeInfo silentInfo(0);
  1372.       if (reqCount) {
  1373.         silentInfo.SetRequestList(reqCount, reqInfos, reqTypes);
  1374.         strstream temp;
  1375.         ReadTypeLib(libName, 0, tfScanOnly | tfAllKinds, temp, silentInfo);
  1376.         char* badName = silentInfo.ExtractRequest();
  1377.         ErrorIf(badName!=0, IDS_BADTYPENAME, badName);
  1378.       }
  1379.       silentInfo.SetCallback(SilentYield);
  1380.       stat = GenerateFiles(libName, outFiles, silentInfo);
  1381.     } else {
  1382.       //
  1383.       //  If first command line arg is an option flag, show help dialog
  1384.       //
  1385.       stat = ::DialogBox(hInst, MAKEINTRESOURCE(IDD_HELP), 0,(DLGPROC)HelpProc);
  1386.     }
  1387.     return stat;
  1388.   }
  1389.   catch (TLocalError& xcpt) {
  1390.     char msgbuf[80];
  1391.     const char ** pmsg;
  1392.     if ( *(pmsg = &xcpt.Message) <= (const char*)IDS_MAX ||
  1393.          *(pmsg = &xcpt.Title)   <= (const char*)IDS_MAX) {
  1394.       ::LoadString(hInst, *(unsigned*)pmsg, msgbuf, sizeof(msgbuf));
  1395.       *pmsg = msgbuf;
  1396.     }
  1397.     ::MessageBox(0, xcpt.Message, xcpt.Title, MB_OK);
  1398.     return 1;
  1399.   }
  1400.   catch (xmsg& xcpt) {    // should not occur, but check anyway while catching
  1401.     ::MessageBox(0, xcpt.why().c_str(), "Exception", MB_OK);
  1402.     return 2;
  1403.   }
  1404. }
  1405.