nsprpub/pr/src/nspr.def

   1 ;+#
   2 ;+# This Source Code Form is subject to the terms of the Mozilla Public
   3 ;+# License, v. 2.0. If a copy of the MPL was not distributed with this
   4 ;+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
   5 ;+#
   6 ;+# OK, this file is meant to support SUN, LINUX, AIX, OS/2 and WINDOWS
   7 ;+#   1. For all unix platforms, the string ";-"  means "remove this line"
   8 ;+#   2. For all unix platforms, the string " DATA " will be removed from any
   9 ;+#     line on which it occurs.
  10 ;+#   3. Lines containing ";+" will have ";+" removed on SUN and LINUX.
  11 ;+#      On AIX, lines containing ";+" will be removed.
  12 ;+#   4. For all unix platforms, the string ";;" will thave the ";;" removed.
  13 ;+#   5. For all unix platforms, after the above processing has taken place,
  14 ;+#    all characters after the first ";" on the line will be removed.
  15 ;+#    And for AIX, the first ";" will also be removed.
  16 ;+#  This file is passed directly to windows. Since ';' is a comment, all UNIX
  17 ;+#   directives are hidden behind ";", ";+", and ";-"
  18 ;+#
  19 ;+NSPR_4.0 {
  20 ;+      global:
  21 LIBRARY nspr4 ;-
  22 EXPORTS ;-
  23                 LL_MaxInt;
  24                 LL_MinInt;
  25                 LL_Zero;
  26                 PR_Abort;
  27                 PR_AddToCounter;
  28                 PR_Accept;
  29                 PR_AcceptRead;
  30                 PR_Access;
  31                 PR_AddWaitFileDesc;
  32                 PR_AllocFileDesc;
  33                 PR_Assert;
  34                 PR_AtomicAdd;
  35                 PR_AtomicDecrement;
  36                 PR_AtomicIncrement;
  37                 PR_AtomicSet;
  38                 PR_AttachSharedMemory;
  39                 PR_AttachThread;
  40                 PR_Available;
  41                 PR_Available64;
  42                 PR_Bind;
  43                 PR_BlockClockInterrupts;
  44                 PR_BlockInterrupt;
  45                 PR_CEnterMonitor;
  46                 PR_CExitMonitor;
  47                 PR_CNotify;
  48                 PR_CNotifyAll;
  49                 PR_CSetOnMonitorRecycle;
  50                 PR_CWait;
  51                 PR_CallOnce;
  52                 PR_Calloc;
  53                 PR_CancelJob;
  54                 PR_CancelWaitFileDesc;
  55                 PR_CancelWaitGroup;
  56                 PR_CeilingLog2;
  57                 PR_ChangeFileDescNativeHandle;
  58                 PR_Cleanup;
  59                 PR_ClearInterrupt;
  60                 PR_ClearThreadGCAble;
  61                 PR_Close;
  62                 PR_CloseDir;
  63                 PR_CloseFileMap;
  64                 PR_CloseSemaphore;
  65                 PR_CloseSharedMemory;
  66                 PR_Connect;
  67                 PR_CreateCounter;
  68                 PR_ConvertIPv4AddrToIPv6;
  69                 PR_CreateAlarm;
  70                 PR_CreateFileMap;
  71                 PR_CreateIOLayerStub;
  72                 PR_CreateOrderedLock;
  73                 PR_CreateMWaitEnumerator;
  74                 PR_CreatePipe;
  75                 PR_CreateProcess;
  76                 PR_CreateProcessDetached;
  77                 PR_CreateSocketPollFd;
  78                 PR_CreateStack;
  79                 PR_CreateThread;
  80                 PR_CreateThreadGCAble;
  81                 PR_CreateTrace;
  82                 PR_CreateThreadPool;
  83                 PR_DecrementCounter;
  84                 PR_CreateWaitGroup;
  85                 PR_Delete;
  86                 PR_DeleteSemaphore;
  87                 PR_DeleteSharedMemory;
  88                 PR_DestroyAlarm;
  89                 PR_DestroyCounter;
  90                 PR_DestroyCondVar;
  91                 PR_DestroyLock;
  92                 PR_DestroyMWaitEnumerator;
  93                 PR_DestroyOrderedLock;
  94                 PR_DestroyMonitor;
  95                 PR_DestroyPollableEvent;
  96                 PR_DestroyProcessAttr;
  97                 PR_DestroyRWLock;
  98                 PR_DestroySem;
  99                 PR_DestroySocketPollFd;
 100                 PR_DestroyTrace;
 101                 PR_DestroyStack;
 102                 PR_DestroyWaitGroup;
 103                 PR_DetachProcess;
 104                 PR_DetachSharedMemory;
 105                 PR_DetachThread;
 106                 PR_DisableClockInterrupts;
 107                 PR_EnableClockInterrupts;
 108                 PR_EnterMonitor;
 109                 PR_EnumerateHostEnt;
 110                 PR_EnumerateThreads;
 111                 PR_EnumerateWaitGroup;
 112                 PR_ErrorInstallCallback;
 113                 PR_ErrorInstallTable;
 114                 PR_ErrorLanguages;
 115                 PR_ErrorToName;
 116                 PR_ErrorToString;
 117                 PR_ExitMonitor;
 118                 PR_ExplodeTime;
 119                 PR_ExportFileMapAsString;
 120                 PR_FD_CLR;
 121                 PR_FD_ISSET;
 122                 PR_FD_NCLR;
 123                 PR_FD_NISSET;
 124                 PR_FD_NSET;
 125                 PR_FD_SET;
 126                 PR_FD_ZERO;
 127                 PR_FileDesc2NativeHandle;
 128                 PR_FindSymbol;
 129                 PR_FindSymbolAndLibrary;
 130                 PR_FloorLog2;
 131                 PR_FormatTime;
 132                 PR_FindNextCounterQname;
 133                 PR_FindNextCounterRname;
 134                 PR_FindNextTraceQname;
 135                 PR_FindNextTraceRname;
 136                 PR_FormatTimeUSEnglish;
 137                 PR_Free;
 138                 PR_FreeLibraryName;
 139                 PR_GMTParameters;
 140                 PR_GetConnectStatus;
 141                 PR_GetCurrentThread;
 142                 PR_GetDefaultIOMethods;
 143                 PR_GetDescType;
 144                 PR_GetDirectorySeparator;
 145                 PR_GetCounter;
 146                 PR_GetCounterHandleFromName;
 147                 PR_GetCounterNameFromHandle;
 148                 PR_GetDirectorySepartor;
 149                 PR_GetEnv;
 150                 PR_GetError;
 151                 PR_GetErrorText;
 152                 PR_GetErrorTextLength;
 153                 PR_GetFileInfo;
 154                 PR_GetFileInfo64;
 155                 PR_GetFileMethods;
 156                 PR_GetGCRegisters;
 157                 PR_GetHostByAddr;
 158                 PR_GetHostByName;
 159                 PR_GetIPNodeByName;
 160                 PR_GetIdentitiesLayer;
 161                 PR_GetInheritedFD;
 162                 PR_GetInheritedFileMap;
 163                 PR_GetLayersIdentity;
 164                 PR_GetLibraryName;
 165                 PR_GetLibraryPath;
 166                 PR_GetMonitorEntryCount;
 167                 PR_GetNameForIdentity;
 168                 PR_GetOSError;
 169                 PR_GetOpenFileInfo;
 170                 PR_GetOpenFileInfo64;
 171                 PR_GetPageShift;
 172                 PR_GetPageSize;
 173                 PR_GetPeerName;
 174                 PR_GetPipeMethods;
 175                 PR_GetProtoByName;
 176                 PR_GetProtoByNumber;
 177                 PR_GetRandomNoise;
 178                 PR_GetSP;
 179                 PR_GetSockName;
 180                 PR_GetSocketOption;
 181                 PR_GetSpecialFD;
 182                 PR_GetStackSpaceLeft;
 183                 PR_GetSysfdTableMax;
 184                 PR_GetSystemInfo;
 185                 PR_GetTCPMethods;
 186                 PR_GetThreadAffinityMask;
 187                 PR_GetThreadID;
 188                 PR_GetThreadPriority;
 189                 PR_GetThreadPrivate;
 190                 PR_GetThreadScope;
 191                 PR_GetThreadState;
 192                 PR_GetThreadType;
 193                 PR_GetUDPMethods;
 194                 PR_GetUniqueIdentity;
 195                 PR_ImplodeTime;
 196                 PR_ImportFile;
 197                 PR_ImportFileMapFromString;
 198                 PR_ImportTCPSocket;
 199                 PR_ImportUDPSocket;
 200                 PR_GetTraceEntries;
 201                 PR_GetTraceHandleFromName;
 202                 PR_GetTraceNameFromHandle;
 203                 PR_GetTraceOption;
 204                 PR_Init;
 205                 PR_Initialize;
 206                 PR_InitializeNetAddr;
 207                 PR_Initialized;
 208                 PR_Interrupt;
 209                 PR_IntervalNow;
 210                 PR_IntervalToMicroseconds;
 211                 PR_IntervalToMilliseconds;
 212                 PR_IncrementCounter;
 213                 PR_IntervalToSeconds;
 214                 PR_IsNetAddrType;
 215                 PR_JoinJob;
 216                 PR_JoinThread;
 217                 PR_JoinThreadPool;
 218                 PR_KillProcess;
 219                 PR_Listen;
 220                 PR_LoadLibrary;
 221                 PR_LoadLibraryWithFlags;
 222                 PR_LoadStaticLibrary;
 223                 PR_LocalTimeParameters;
 224                 PR_Lock;
 225                 PR_LockFile;
 226                 PR_LogFlush;
 227                 PR_LogPrint;
 228                 PR_MakeDir;
 229                 PR_Malloc;
 230                 PR_MemMap;
 231                 PR_MemUnmap;
 232                 PR_MicrosecondsToInterval;
 233                 PR_MillisecondsToInterval;
 234                 PR_LockOrderedLock;
 235                 PR_MkDir;
 236                 PR_NetAddrToString;
 237                 PR_NewCondVar;
 238                 PR_NewLock;
 239                 PR_NewLogModule;
 240                 PR_NewMonitor;
 241                 PR_NewNamedMonitor;
 242                 PR_NewPollableEvent;
 243                 PR_NewProcessAttr;
 244                 PR_NewRWLock;
 245                 PR_NewSem;
 246                 PR_NewTCPSocket;
 247                 PR_NewTCPSocketPair;
 248                 PR_NewThreadPrivateIndex;
 249                 PR_NewUDPSocket;
 250                 PR_NormalizeTime;
 251                 PR_Notify;
 252                 PR_NotifyAll;
 253                 PR_NotifyAllCondVar;
 254                 PR_NotifyCondVar;
 255                 PR_Now;
 256                 PR_Open;
 257                 PR_OpenAnonFileMap;
 258                 PR_OpenDir;
 259                 PR_OpenFile;
 260                 PR_OpenSemaphore;
 261                 PR_OpenSharedMemory;
 262                 PR_OpenTCPSocket;
 263                 PR_OpenUDPSocket;
 264                 PR_ParseTimeString;
 265                 PR_Poll;
 266                 PR_PopIOLayer;
 267                 PR_PostSem;
 268                 PR_PostSemaphore;
 269                 PR_ProcessAttrSetCurrentDirectory;
 270                 PR_ProcessAttrSetInheritableFD;
 271                 PR_ProcessAttrSetInheritableFileMap;
 272                 PR_ProcessAttrSetStdioRedirect;
 273                 PR_ProcessExit;
 274                 PR_PushIOLayer;
 275                 PR_QueueJob;
 276                 PR_QueueJob_Accept;
 277                 PR_QueueJob_Connect;
 278                 PR_QueueJob_Read;
 279                 PR_QueueJob_Timer;
 280                 PR_QueueJob_Write;
 281                 PR_RWLock_Rlock;
 282                 PR_RWLock_Unlock;
 283                 PR_RWLock_Wlock;
 284                 PR_Read;
 285                 PR_ReadDir;
 286                 PR_Realloc;
 287                 PR_Recv;
 288                 PR_RecvFrom;
 289                 PR_Rename;
 290                 PR_ResetAlarm;
 291                 PR_ResetProcessAttr;
 292                 PR_ResumeAll;
 293                 PR_RmDir;
 294                 PR_ScanStackPointers;
 295                 PR_RecordTraceEntries;
 296                 PR_SecondsToInterval;
 297                 PR_Seek;
 298                 PR_Seek64;
 299                 PR_Select;
 300                 PR_Send;
 301                 PR_SendFile;
 302                 PR_SendTo;
 303                 PR_SetAlarm;
 304                 PR_SetConcurrency;
 305                 PR_SetError;
 306                 PR_SetErrorText;
 307                 PR_SetFDCacheSize;
 308                 PR_SetFDInheritable;
 309                 PR_SetLibraryPath;
 310                 PR_SetLogBuffering;
 311                 PR_SetLogFile;
 312                 PR_SetNetAddr;
 313                 PR_SetPollableEvent;
 314                 PR_SetSocketOption;
 315                 PR_SetCounter;
 316                 PR_SetStdioRedirect;
 317                 PR_SetSysfdTableSize;
 318                 PR_SetThreadAffinityMask;
 319                 PR_SetThreadDumpProc;
 320                 PR_SetThreadGCAble;
 321                 PR_SetThreadPriority;
 322                 PR_SetThreadPrivate;
 323                 PR_SetThreadRecycleMode;
 324                 PR_Shutdown;
 325                 PR_ShutdownThreadPool;
 326                 PR_Sleep;
 327                 PR_Socket;
 328                 PR_StackPop;
 329                 PR_StackPush;
 330                 PR_Stat;
 331                 PR_StringToNetAddr;
 332                 PR_SuspendAll;
 333                 PR_Sync;
 334                 PR_TLockFile;
 335                 PR_ThreadScanStackPointers;
 336                 PR_SetTraceOption;
 337                 PR_TicksPerSecond;
 338                 PR_TransmitFile;
 339                 PR_USPacificTimeParameters;
 340                 PR_UnblockClockInterrupts;
 341                 PR_UnblockInterrupt;
 342                 PR_UnloadLibrary;
 343                 PR_SubtractFromCounter;
 344                 PR_Unlock;
 345                 PR_UnlockFile;
 346                 PR_VersionCheck;
 347                 PR_Wait;
 348                 PR_WaitCondVar;
 349                 PR_WaitForPollableEvent;
 350                 PR_Trace;
 351                 PR_WaitProcess;
 352                 PR_WaitRecvReady;
 353                 PR_WaitSem;
 354                 PR_WaitSemaphore;
 355                 PR_Write;
 356                 PR_Writev;
 357                 PR_Yield;
 358                 PR_UnlockOrderedLock;
 359                 PR_cnvtf;
 360                 PR_dtoa;
 361                 PR_fprintf;
 362                 PR_htonl;
 363                 PR_htonll;
 364                 PR_htons;
 365                 PR_ntohl;
 366                 PR_ntohll;
 367                 PR_ntohs;
 368                 PR_smprintf;
 369                 PR_smprintf_free;
 370                 PR_snprintf;
 371                 PR_sprintf_append;
 372                 PR_sscanf;
 373                 PR_strtod;
 374                 PR_sxprintf;
 375                 PR_vfprintf;
 376                 PR_vsmprintf;
 377                 PR_vsnprintf;
 378                 PR_vsprintf_append;
 379                 PR_vsxprintf;
 380                 PRP_DestroyNakedCondVar;
 381                 PRP_NakedBroadcast;
 382                 PRP_NakedNotify;
 383                 PRP_NakedWait;
 384                 PRP_NewNakedCondVar;
 385                 PRP_TryLock;
 386                 libVersionPoint;
 387 ;+      local: *;
 388 ;+};
 389 ;+
 390 ;+NSPRprivate {
 391 ;+      global:
 392                 GetExecutionEnvironment;
 393                 PT_FPrintStats;
 394                 SetExecutionEnvironment;
 395 ;+      local: *;
 396 ;+};
 397 ;+
 398 ;+NSPR_4.1 {
 399 ;+      global:
 400                 PR_ConnectContinue;
 401                 PR_CreateIOLayer;
 402                 PR_EmulateAcceptRead;
 403                 PR_EmulateSendFile;
 404                 PR_FindFunctionSymbol;
 405                 PR_FindFunctionSymbolAndLibrary;
 406                 PR_GetMemMapAlignment;
 407                 PR_GetNumberOfProcessors;
 408                 PR_ImportPipe;
 409                 PR_SetEnv;
 410 ;+} NSPR_4.0;
 411 ;+
 412 ;+NSPR_4.3 {
 413 ;+      global:
 414                 LL_MaxUint;
 415                 PR_CallOnceWithArg;
 416                 PR_GetLibraryFilePathname;
 417 ;+} NSPR_4.1;
 418 ;+
 419 ;+NSPR_4.4 {
 420 ;+      global:
 421                 PR_GetPathSeparator;
 422 ;+} NSPR_4.3;
 423 ;+
 424 ;+NSPR_4.5 {
 425 ;+      global:
 426                 PR_EnumerateAddrInfo;
 427                 PR_FreeAddrInfo;
 428                 PR_GetAddrInfoByName;
 429                 PR_GetCanonNameFromAddrInfo;
 430 ;+} NSPR_4.4;
 431 ;+
 432 ;+NSPR_4.6 {
 433 ;+      global:
 434                 PR_GetPhysicalMemorySize;
 435 ;+} NSPR_4.5;
 436 ;+NSPR_4.7 {
 437 ;+      global:
 438                 PR_ParseTimeStringToExplodedTime;
 439 ;+} NSPR_4.6;
 440 ;+NSPR_4.8 {
 441 ;+      global:
 442                 PR_AssertCurrentThreadOwnsLock;
 443                 PR_AssertCurrentThreadInMonitor;
 444 ;+} NSPR_4.7;
 445 ;+NSPR_4.8.9 {
 446 ;+      global:
 447                 PR_GetVersion;
 448 ;+} NSPR_4.8;
 449 ;+NSPR_4.9.2 {
 450 ;+      global:
 451                 PR_GetThreadName;
 452                 PR_SetCurrentThreadName;
 453 ;+} NSPR_4.8.9;
 454 ;+NSPR_4.10.3 {
 455 ;+      global:
 456                 PR_SyncMemMap;
 457 ;+} NSPR_4.9.2;
 458 ;+# Function PR_DuplicateEnvironment had been added in NSPR 4.10.9,
 459 ;+# but we neglected to add it to nspr.def until NSPR 4.12
 460 ;+NSPR_4.12 {
 461 ;+      global:
 462                 PR_DuplicateEnvironment;
 463                 PR_GetEnvSecure;
 464 ;+} NSPR_4.10.3;
 465 ;+NSPR_4.34 {
 466 ;+      global:
 467     PR_GetPrefLoopbackAddrInfo;
 468 ;+} NSPR_4.12;