xpcom/stub/nsXPComStub.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is Mozilla.
  15  *
  16  * The Initial Developer of the Original Code is IBM Corporation.
  17  * Portions created by IBM Corporation are Copyright (C) 2004
  18  * IBM Corporation. All Rights Reserved.
  19  *
  20  * Contributor(s):
  21  *   Darin Fisher <darin@meer.net>
  22  *   Benjamin Smedberg <benjamin@smedbergs.us>
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include "nsXPCOM.h"
  39 #include "nsXPCOMPrivate.h"
  40 #include "nsXPCOMStrings.h"
  41 #include "xptcall.h"
  42
  43 #include <string.h>
  44
  45 /**
  46  * Private Method to register an exit routine.  This method
  47  * used to allow you to setup a callback that will be called from
  48  * the NS_ShutdownXPCOM function after all services and
  49  * components have gone away. It was fatally flawed in that the component
  50  * DLL could be released before the exit function was called; it is now a
  51  * stub implementation that does nothing.
  52  */
  53 XPCOM_API(nsresult)
  54 NS_RegisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine, PRUint32 priority);
  55
  56 XPCOM_API(nsresult)
  57 NS_UnregisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine);
  58
  59 static const XPCOMFunctions kFrozenFunctions = {
  60     XPCOM_GLUE_VERSION,
  61     sizeof(XPCOMFunctions),
  62     &NS_InitXPCOM2_P,
  63     &NS_ShutdownXPCOM_P,
  64     &NS_GetServiceManager_P,
  65     &NS_GetComponentManager_P,
  66     &NS_GetComponentRegistrar_P,
  67     &NS_GetMemoryManager_P,
  68     &NS_NewLocalFile_P,
  69     &NS_NewNativeLocalFile_P,
  70     &NS_RegisterXPCOMExitRoutine,
  71     &NS_UnregisterXPCOMExitRoutine,
  72
  73     // these functions were added post 1.4
  74     &NS_GetDebug_P,
  75     &NS_GetTraceRefcnt_P,
  76
  77     // these functions were added post 1.6
  78     &NS_StringContainerInit_P,
  79     &NS_StringContainerFinish_P,
  80     &NS_StringGetData_P,
  81     &NS_StringSetData_P,
  82     &NS_StringSetDataRange_P,
  83     &NS_StringCopy_P,
  84     &NS_CStringContainerInit_P,
  85     &NS_CStringContainerFinish_P,
  86     &NS_CStringGetData_P,
  87     &NS_CStringSetData_P,
  88     &NS_CStringSetDataRange_P,
  89     &NS_CStringCopy_P,
  90     &NS_CStringToUTF16_P,
  91     &NS_UTF16ToCString_P,
  92     &NS_StringCloneData_P,
  93     &NS_CStringCloneData_P,
  94
  95     // these functions were added post 1.7 (post Firefox 1.0)
  96     &NS_Alloc_P,
  97     &NS_Realloc_P,
  98     &NS_Free_P,
  99     &NS_StringContainerInit2_P,
 100     &NS_CStringContainerInit2_P,
 101     &NS_StringGetMutableData_P,
 102     &NS_CStringGetMutableData_P,
 103     &NS_InitXPCOM3_P,
 104
 105     // these functions were added post 1.8
 106     &NS_DebugBreak_P,
 107     &NS_LogInit_P,
 108     &NS_LogTerm_P,
 109     &NS_LogAddRef_P,
 110     &NS_LogRelease_P,
 111     &NS_LogCtor_P,
 112     &NS_LogDtor_P,
 113     &NS_LogCOMPtrAddRef_P,
 114     &NS_LogCOMPtrRelease_P,
 115     &NS_GetXPTCallStub_P,
 116     &NS_DestroyXPTCallStub_P,
 117     &NS_InvokeByIndex_P,
 118     &NS_CycleCollectorSuspect_P,
 119     &NS_CycleCollectorForget_P,
 120     &NS_StringSetIsVoid_P,
 121     &NS_StringGetIsVoid_P,
 122     &NS_CStringSetIsVoid_P,
 123     &NS_CStringGetIsVoid_P
 124 };
 125
 126 EXPORT_XPCOM_API(nsresult)
 127 NS_GetFrozenFunctions(XPCOMFunctions *functions, const char* /* libraryPath */)
 128 {
 129     if (!functions)
 130         return NS_ERROR_OUT_OF_MEMORY;
 131
 132     if (functions->version != XPCOM_GLUE_VERSION)
 133         return NS_ERROR_FAILURE;
 134
 135     PRUint32 size = functions->size;
 136     if (size > sizeof(XPCOMFunctions))
 137         size = sizeof(XPCOMFunctions);
 138
 139     size -= offsetof(XPCOMFunctions, init);
 140
 141     memcpy(&functions->init, &kFrozenFunctions.init, size);
 142
 143     return NS_OK;
 144 }
 145
 146 /*
 147  * Stubs for nsXPCOM.h
 148  */
 149
 150 #undef NS_InitXPCOM2
 151 EXPORT_XPCOM_API(nsresult)
 152 NS_InitXPCOM2(nsIServiceManager **result,
 153               nsIFile *binDirectory,
 154               nsIDirectoryServiceProvider *dirProvider)
 155 {
 156   return NS_InitXPCOM2_P(result, binDirectory, dirProvider);
 157 }
 158
 159 #undef NS_InitXPCOM3
 160 EXPORT_XPCOM_API(nsresult)
 161 NS_InitXPCOM3(nsIServiceManager **result,
 162               nsIFile *binDirectory,
 163               nsIDirectoryServiceProvider *dirProvider,
 164               nsStaticModuleInfo const *staticComponents,
 165               PRUint32 componentCount)
 166 {
 167   return NS_InitXPCOM3_P(result, binDirectory, dirProvider,
 168                          staticComponents, componentCount);
 169 }
 170
 171 #undef NS_ShutdownXPCOM
 172 EXPORT_XPCOM_API(nsresult)
 173 NS_ShutdownXPCOM(nsIServiceManager *svcMgr)
 174 {
 175   return NS_ShutdownXPCOM_P(svcMgr);
 176 }
 177
 178 #undef NS_GetServiceManager
 179 EXPORT_XPCOM_API(nsresult)
 180 NS_GetServiceManager(nsIServiceManager* *result)
 181 {
 182   return NS_GetServiceManager_P(result);
 183 }
 184
 185 #undef NS_GetComponentManager
 186 EXPORT_XPCOM_API(nsresult)
 187 NS_GetComponentManager(nsIComponentManager* *result)
 188 {
 189   return NS_GetComponentManager_P(result);
 190 }
 191
 192 #undef NS_GetComponentRegistrar
 193 EXPORT_XPCOM_API(nsresult)
 194 NS_GetComponentRegistrar(nsIComponentRegistrar* *result)
 195 {
 196   return NS_GetComponentRegistrar_P(result);
 197 }
 198
 199 #undef NS_GetMemoryManager
 200 EXPORT_XPCOM_API(nsresult)
 201 NS_GetMemoryManager(nsIMemory* *result)
 202 {
 203   return NS_GetMemoryManager_P(result);
 204 }
 205
 206 #undef NS_NewLocalFile
 207 EXPORT_XPCOM_API(nsresult)
 208 NS_NewLocalFile(const nsAString &path,
 209                 PRBool followLinks,
 210                 nsILocalFile **result)
 211 {
 212   return NS_NewLocalFile_P(path, followLinks, result);
 213 }
 214
 215 #undef NS_NewNativeLocalFile
 216 EXPORT_XPCOM_API(nsresult)
 217 NS_NewNativeLocalFile(const nsACString &path,
 218                       PRBool followLinks,
 219                       nsILocalFile **result)
 220 {
 221   return NS_NewNativeLocalFile_P(path, followLinks, result);
 222 }
 223
 224 #undef NS_GetDebug
 225 EXPORT_XPCOM_API(nsresult)
 226 NS_GetDebug(nsIDebug **result)
 227 {
 228   return NS_GetDebug_P(result);
 229 }
 230
 231 #undef NS_GetTraceRefcnt
 232 EXPORT_XPCOM_API(nsresult)
 233 NS_GetTraceRefcnt(nsITraceRefcnt **result)
 234 {
 235   return NS_GetTraceRefcnt_P(result);
 236 }
 237
 238 #undef NS_Alloc
 239 EXPORT_XPCOM_API(void*)
 240 NS_Alloc(PRSize size)
 241 {
 242   return NS_Alloc_P(size);
 243 }
 244
 245 #undef NS_Realloc
 246 EXPORT_XPCOM_API(void*)
 247 NS_Realloc(void* ptr, PRSize size)
 248 {
 249   return NS_Realloc_P(ptr, size);
 250 }
 251
 252 #undef NS_Free
 253 EXPORT_XPCOM_API(void)
 254 NS_Free(void* ptr)
 255 {
 256   NS_Free_P(ptr);
 257 }
 258
 259 #undef NS_DebugBreak
 260 EXPORT_XPCOM_API(void)
 261 NS_DebugBreak(PRUint32 aSeverity, const char *aStr, const char *aExpr,
 262               const char *aFile, PRInt32 aLine)
 263 {
 264   NS_DebugBreak_P(aSeverity, aStr, aExpr, aFile, aLine);
 265 }
 266
 267 #undef NS_LogInit
 268 EXPORT_XPCOM_API(void)
 269 NS_LogInit()
 270 {
 271   NS_LogInit_P();
 272 }
 273
 274 #undef NS_LogTerm
 275 EXPORT_XPCOM_API(void)
 276 NS_LogTerm()
 277 {
 278   NS_LogTerm_P();
 279 }
 280
 281 #undef NS_LogAddRef
 282 EXPORT_XPCOM_API(void)
 283 NS_LogAddRef(void* aPtr, nsrefcnt aNewRefCnt,
 284              const char *aTypeName, PRUint32 aInstanceSize)
 285 {
 286   NS_LogAddRef_P(aPtr, aNewRefCnt, aTypeName, aInstanceSize);
 287 }
 288
 289 #undef NS_LogRelease
 290 EXPORT_XPCOM_API(void)
 291 NS_LogRelease(void* aPtr, nsrefcnt aNewRefCnt, const char *aTypeName)
 292 {
 293   NS_LogRelease_P(aPtr, aNewRefCnt, aTypeName);
 294 }
 295
 296 #undef NS_LogCtor
 297 EXPORT_XPCOM_API(void)
 298 NS_LogCtor(void *aPtr, const char *aTypeName, PRUint32 aInstanceSize)
 299 {
 300   NS_LogCtor_P(aPtr, aTypeName, aInstanceSize);
 301 }
 302
 303 #undef NS_LogDtor
 304 EXPORT_XPCOM_API(void)
 305 NS_LogDtor(void *aPtr, const char *aTypeName, PRUint32 aInstanceSize)
 306 {
 307   NS_LogDtor_P(aPtr, aTypeName, aInstanceSize);
 308 }
 309
 310 #undef NS_LogCOMPtrAddRef
 311 EXPORT_XPCOM_API(void)
 312 NS_LogCOMPtrAddRef(void *aCOMPtr, nsISupports* aObject)
 313 {
 314   NS_LogCOMPtrAddRef_P(aCOMPtr, aObject);
 315 }
 316
 317 #undef NS_LogCOMPtrRelease
 318 EXPORT_XPCOM_API(void)
 319 NS_LogCOMPtrRelease(void *aCOMPtr, nsISupports* aObject)
 320 {
 321   NS_LogCOMPtrRelease_P(aCOMPtr, aObject);
 322 }
 323
 324 #undef NS_GetXPTCallStub
 325 EXPORT_XPCOM_API(nsresult)
 326 NS_GetXPTCallStub(REFNSIID aIID, nsIXPTCProxy* aOuter,
 327                   nsISomeInterface* *aStub)
 328 {
 329   return NS_GetXPTCallStub_P(aIID, aOuter, aStub);
 330 }
 331
 332 #undef NS_DestroyXPTCallStub
 333 EXPORT_XPCOM_API(void)
 334 NS_DestroyXPTCallStub(nsISomeInterface* aStub)
 335 {
 336   NS_DestroyXPTCallStub_P(aStub);
 337 }
 338
 339 #undef NS_InvokeByIndex
 340 EXPORT_XPCOM_API(nsresult)
 341 NS_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
 342                  PRUint32 paramCount, nsXPTCVariant* params)
 343 {
 344   return NS_InvokeByIndex_P(that, methodIndex, paramCount, params);
 345 }
 346
 347 /*
 348  * Stubs for nsXPCOMPrivate.h
 349  */
 350
 351 EXPORT_XPCOM_API(nsresult)
 352 NS_RegisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine, PRUint32 priority)
 353 {
 354   return NS_OK;
 355 }
 356
 357 EXPORT_XPCOM_API(nsresult)
 358 NS_UnregisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine)
 359 {
 360   return NS_OK;
 361 }
 362
 363 /*
 364  * Stubs for nsStringAPI.h
 365  */
 366
 367 #undef NS_StringContainerInit
 368 EXPORT_XPCOM_API(nsresult)
 369 NS_StringContainerInit(nsStringContainer &aStr)
 370 {
 371   return NS_StringContainerInit_P(aStr);
 372 }
 373
 374 #undef NS_StringContainerInit2
 375 EXPORT_XPCOM_API(nsresult)
 376 NS_StringContainerInit2(nsStringContainer &aStr,
 377                         const PRUnichar   *aData,
 378                         PRUint32           aDataLength,
 379                         PRUint32           aFlags)
 380 {
 381   return NS_StringContainerInit2_P(aStr, aData, aDataLength, aFlags);
 382 }
 383
 384 #undef NS_StringContainerFinish
 385 EXPORT_XPCOM_API(void)
 386 NS_StringContainerFinish(nsStringContainer &aStr)
 387 {
 388   NS_StringContainerFinish_P(aStr);
 389 }
 390
 391 #undef NS_StringGetData
 392 EXPORT_XPCOM_API(PRUint32)
 393 NS_StringGetData(const nsAString &aStr, const PRUnichar **aBuf, PRBool *aTerm)
 394 {
 395   return NS_StringGetData_P(aStr, aBuf, aTerm);
 396 }
 397
 398 #undef NS_StringGetMutableData
 399 EXPORT_XPCOM_API(PRUint32)
 400 NS_StringGetMutableData(nsAString &aStr, PRUint32 aLen, PRUnichar **aBuf)
 401 {
 402   return NS_StringGetMutableData_P(aStr, aLen, aBuf);
 403 }
 404
 405 #undef NS_StringCloneData
 406 EXPORT_XPCOM_API(PRUnichar *)
 407 NS_StringCloneData(const nsAString &aStr)
 408 {
 409   return NS_StringCloneData_P(aStr);
 410 }
 411
 412 #undef NS_StringSetData
 413 EXPORT_XPCOM_API(nsresult)
 414 NS_StringSetData(nsAString &aStr, const PRUnichar *aBuf, PRUint32 aCount)
 415 {
 416   return NS_StringSetData_P(aStr, aBuf, aCount);
 417 }
 418
 419 #undef NS_StringSetDataRange
 420 EXPORT_XPCOM_API(nsresult)
 421 NS_StringSetDataRange(nsAString &aStr, PRUint32 aCutStart, PRUint32 aCutLength,
 422                       const PRUnichar *aBuf, PRUint32 aCount)
 423 {
 424   return NS_StringSetDataRange_P(aStr, aCutStart, aCutLength, aBuf, aCount);
 425 }
 426
 427 #undef NS_StringCopy
 428 EXPORT_XPCOM_API(nsresult)
 429 NS_StringCopy(nsAString &aDest, const nsAString &aSrc)
 430 {
 431   return NS_StringCopy_P(aDest, aSrc);
 432 }
 433
 434 #undef NS_StringSetIsVoid
 435 EXPORT_XPCOM_API(void)
 436 NS_StringSetIsVoid(nsAString &aStr, const PRBool aIsVoid)
 437 {
 438   NS_StringSetIsVoid_P(aStr, aIsVoid);
 439 }
 440
 441 #undef NS_StringGetIsVoid
 442 EXPORT_XPCOM_API(PRBool)
 443 NS_StringGetIsVoid(const nsAString &aStr)
 444 {
 445   return NS_StringGetIsVoid_P(aStr);
 446 }
 447
 448 #undef NS_CStringContainerInit
 449 EXPORT_XPCOM_API(nsresult)
 450 NS_CStringContainerInit(nsCStringContainer &aStr)
 451 {
 452   return NS_CStringContainerInit_P(aStr);
 453 }
 454
 455 #undef NS_CStringContainerInit2
 456 EXPORT_XPCOM_API(nsresult)
 457 NS_CStringContainerInit2(nsCStringContainer &aStr,
 458                          const char         *aData,
 459                          PRUint32            aDataLength,
 460                          PRUint32            aFlags)
 461 {
 462   return NS_CStringContainerInit2_P(aStr, aData, aDataLength, aFlags);
 463 }
 464
 465 #undef NS_CStringContainerFinish
 466 EXPORT_XPCOM_API(void)
 467 NS_CStringContainerFinish(nsCStringContainer &aStr)
 468 {
 469   NS_CStringContainerFinish_P(aStr);
 470 }
 471
 472 #undef NS_CStringGetData
 473 EXPORT_XPCOM_API(PRUint32)
 474 NS_CStringGetData(const nsACString &aStr, const char **aBuf, PRBool *aTerm)
 475 {
 476   return NS_CStringGetData_P(aStr, aBuf, aTerm);
 477 }
 478
 479 #undef NS_CStringGetMutableData
 480 EXPORT_XPCOM_API(PRUint32)
 481 NS_CStringGetMutableData(nsACString &aStr, PRUint32 aLen, char **aBuf)
 482 {
 483   return NS_CStringGetMutableData_P(aStr, aLen, aBuf);
 484 }
 485
 486 #undef NS_CStringCloneData
 487 EXPORT_XPCOM_API(char *)
 488 NS_CStringCloneData(const nsACString &aStr)
 489 {
 490   return NS_CStringCloneData_P(aStr);
 491 }
 492
 493 #undef NS_CStringSetData
 494 EXPORT_XPCOM_API(nsresult)
 495 NS_CStringSetData(nsACString &aStr, const char *aBuf, PRUint32 aCount)
 496 {
 497   return NS_CStringSetData_P(aStr, aBuf, aCount);
 498 }
 499
 500 #undef NS_CStringSetDataRange
 501 EXPORT_XPCOM_API(nsresult)
 502 NS_CStringSetDataRange(nsACString &aStr, PRUint32 aCutStart, PRUint32 aCutLength,
 503                        const char *aBuf, PRUint32 aCount)
 504 {
 505   return NS_CStringSetDataRange_P(aStr, aCutStart, aCutLength, aBuf, aCount);
 506 }
 507
 508 #undef NS_CStringCopy
 509 EXPORT_XPCOM_API(nsresult)
 510 NS_CStringCopy(nsACString &aDest, const nsACString &aSrc)
 511 {
 512   return NS_CStringCopy_P(aDest, aSrc);
 513 }
 514
 515 #undef NS_CStringSetIsVoid
 516 EXPORT_XPCOM_API(void)
 517 NS_CStringSetIsVoid(nsACString &aStr, const PRBool aIsVoid)
 518 {
 519   NS_CStringSetIsVoid_P(aStr, aIsVoid);
 520 }
 521
 522 #undef NS_CStringGetIsVoid
 523 EXPORT_XPCOM_API(PRBool)
 524 NS_CStringGetIsVoid(const nsACString &aStr)
 525 {
 526   return NS_CStringGetIsVoid_P(aStr);
 527 }
 528
 529 #undef NS_CStringToUTF16
 530 EXPORT_XPCOM_API(nsresult)
 531 NS_CStringToUTF16(const nsACString &aSrc, nsCStringEncoding aSrcEncoding, nsAString &aDest)
 532 {
 533   return NS_CStringToUTF16_P(aSrc, aSrcEncoding, aDest);
 534 }
 535
 536 #undef NS_UTF16ToCString
 537 EXPORT_XPCOM_API(nsresult)
 538 NS_UTF16ToCString(const nsAString &aSrc, nsCStringEncoding aDestEncoding, nsACString &aDest)
 539 {
 540   return NS_UTF16ToCString_P(aSrc, aDestEncoding, aDest);
 541 }
 542
 543 #undef NS_CycleCollectorSuspect
 544 EXPORT_XPCOM_API(PRBool)
 545 NS_CycleCollectorSuspect(nsISupports* obj)
 546 {
 547   return NS_CycleCollectorSuspect_P(obj);
 548 }
 549
 550 #undef NS_CycleCollectorForget
 551 EXPORT_XPCOM_API(PRBool)
 552 NS_CycleCollectorForget(nsISupports* obj)
 553 {
 554   return NS_CycleCollectorForget_P(obj);
 555 }