sal/osl/os2/thread.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: thread.c,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 #include "system.h"
  33
  34 #include <osl/diagnose.h>
  35 #include <osl/thread.h>
  36 #include <osl/time.h>
  37 #include <rtl/alloc.h>
  38 #include <rtl/tencinfo.h>
  39
  40 /*
  41     Thread-data structure hidden behind oslThread:
  42 */
  43 typedef struct _osl_TThreadImpl
  44 {
  45
  46     TID                  m_ThreadId;        /* identifier for this thread */
  47     sal_Int32            m_Flags;
  48     HEV                  m_hEvent;
  49     sal_uInt32           m_Timeout;
  50     oslWorkerFunction    m_WorkerFunction;
  51     void*                m_pData;
  52     sal_Bool             m_StartSuspended;
  53     HAB                  m_hab;
  54     HMQ                  m_hmq;
  55
  56 } osl_TThreadImpl;
  57
  58 #define THREADIMPL_FLAGS_TERMINATE    0x0001
  59 #define THREADIMPL_FLAGS_SLEEP        0x0002
  60
  61
  62 // static mutex to control access to private members of oslMutexImpl
  63 static HMTX MutexLock = NULL;
  64
  65 /*****************************************************************************/
  66
  67 HAB osl_getPMinternal_HAB(oslThread hThread)
  68 {
  69     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)hThread;
  70
  71     if(pThreadImpl == NULL) /* valid ptr? */
  72     {
  73         return NULL;
  74     }
  75     else
  76     {
  77         return pThreadImpl->m_hab;
  78     }
  79 }
  80
  81 HMQ osl_getPMinternal_HMQ(oslThread hThread)
  82 {
  83     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)hThread;
  84
  85     if(pThreadImpl == NULL) /* valid ptr? */
  86     {
  87         return NULL;
  88     }
  89     else
  90     {
  91         return pThreadImpl->m_hmq;
  92     }
  93 }
  94
  95
  96 /*****************************************************************************/
  97 /* oslWorkerWrapperFunction */
  98 /*****************************************************************************/
  99 static void oslWorkerWrapperFunction(void* pData)
 100 {
 101     BOOL rc;
 102     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)pData;
 103
 104 #if OSL_DEBUG_LEVEL>0
 105 printf("oslWorkerWrapperFunction pThreadImpl %x, pThreadImpl->m_ThreadId %d\n", pThreadImpl, pThreadImpl->m_ThreadId);
 106 #endif
 107     /* Inizialize PM for this thread */
 108     pThreadImpl->m_hab = WinInitialize( 0 );
 109 #if OSL_DEBUG_LEVEL>0
 110 printf("pThreadImpl->m_ThreadId %d, pThreadImpl->m_hab %x\n", pThreadImpl->m_ThreadId,pThreadImpl->m_hab);
 111 #endif
 112     pThreadImpl->m_hmq = WinCreateMsgQueue( pThreadImpl->m_hab, 0 );
 113 #if OSL_DEBUG_LEVEL>0
 114 printf("pThreadImpl->m_ThreadId %d, pThreadImpl->m_hmq %x\n", pThreadImpl->m_ThreadId,pThreadImpl->m_hmq);
 115 #endif
 116
 117     /* call worker-function with data */
 118     pThreadImpl->m_WorkerFunction( pThreadImpl->m_pData );
 119
 120     /* Free all PM-resources for this thread */
 121 #if OSL_DEBUG_LEVEL>0
 122 printf("pThreadImpl->m_ThreadId %d, about to destroy queue\n", pThreadImpl->m_ThreadId);
 123 #endif
 124     rc = WinDestroyMsgQueue( pThreadImpl->m_hmq );
 125 #if OSL_DEBUG_LEVEL>0
 126 printf("pThreadImpl->m_ThreadId %d, WinDestroyMsgQueue rc=%d (should be 1)\n", pThreadImpl->m_ThreadId, rc);
 127 printf("pThreadImpl->m_ThreadId %d, about to terminate hab\n", pThreadImpl->m_ThreadId);
 128 #endif
 129     rc = WinTerminate( pThreadImpl->m_hab );
 130 #if OSL_DEBUG_LEVEL>0
 131 printf("pThreadImpl->m_ThreadId %d, WinTerminate rc=%d (should be 1)\n", pThreadImpl->m_ThreadId, rc);
 132 #endif
 133 }
 134
 135
 136 /*****************************************************************************/
 137 /* oslCreateThread */
 138 /*****************************************************************************/
 139 static oslThread oslCreateThread(oslWorkerFunction pWorker,
 140                                  void* pThreadData,
 141                                  sal_Bool nFlags)
 142 {
 143     osl_TThreadImpl* pThreadImpl;
 144
 145     /* alloc mem. for our internal data structure */
 146     pThreadImpl = (osl_TThreadImpl*)malloc(sizeof(osl_TThreadImpl));
 147
 148     OSL_ASSERT(pThreadImpl);
 149
 150     pThreadImpl->m_WorkerFunction= pWorker;
 151     pThreadImpl->m_pData= pThreadData;
 152
 153     pThreadImpl->m_Flags   = 0;
 154     pThreadImpl->m_hEvent  = 0;
 155     pThreadImpl->m_Timeout = 0;
 156     pThreadImpl->m_StartSuspended = nFlags;
 157     pThreadImpl->m_hab = 0;
 158     pThreadImpl->m_hmq = 0;
 159
 160     if ( nFlags == sal_True )
 161     {
 162         DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 163     }
 164
 165     pThreadImpl->m_ThreadId = (TID) _beginthread( oslWorkerWrapperFunction,    /* worker-function */
 166                                                   NULL,                        /* unused parameter */
 167                                                   1024*1024,                   /* max. Stacksize */
 168                                                   pThreadImpl );
 169     if ( nFlags == sal_True )
 170     {
 171         if( pThreadImpl->m_ThreadId != -1 )
 172             DosSuspendThread( pThreadImpl->m_ThreadId );
 173         DosReleaseMutexSem( MutexLock);
 174     }
 175 #if OSL_DEBUG_LEVEL>0
 176 printf("oslCreateThread pThreadImpl %x, pThreadImpl->m_ThreadId %d\n", pThreadImpl, pThreadImpl->m_ThreadId);
 177 #endif
 178     if(pThreadImpl->m_ThreadId == -1)
 179     {
 180         /* create failed */
 181         if (pThreadImpl->m_hEvent != 0)
 182             DosCloseEventSem(pThreadImpl->m_hEvent);
 183
 184         free(pThreadImpl);
 185         return 0;
 186     }
 187
 188     pThreadImpl->m_hEvent= 0;
 189
 190     return pThreadImpl;
 191
 192 }
 193
 194 /*****************************************************************************/
 195 /* osl_createThread */
 196 /*****************************************************************************/
 197 oslThread SAL_CALL osl_createThread(oslWorkerFunction pWorker,
 198                                  void* pThreadData)
 199 {
 200     return oslCreateThread(pWorker,pThreadData,sal_False);
 201 }
 202
 203 /*****************************************************************************/
 204 /* osl_createSuspendedThread */
 205 /*****************************************************************************/
 206 oslThread SAL_CALL osl_createSuspendedThread(oslWorkerFunction pWorker,
 207                                           void* pThreadData)
 208 {
 209     return oslCreateThread(pWorker,pThreadData,sal_True);
 210 }
 211
 212 /*****************************************************************************/
 213 /* osl_getThreadIdentifier */
 214 /*****************************************************************************/
 215 oslThreadIdentifier SAL_CALL osl_getThreadIdentifier(oslThread Thread)
 216 {
 217     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 218
 219     if (pThreadImpl != NULL)
 220         return ((oslThreadIdentifier)pThreadImpl->m_ThreadId);
 221     else
 222         {
 223         PTIB pptib = NULL;
 224         PPIB pppib = NULL;
 225
 226         DosGetInfoBlocks( &pptib, &pppib );
 227         return ((oslThreadIdentifier) pptib->tib_ptib2->tib2_ultid );
 228         }
 229 }
 230
 231 /*****************************************************************************/
 232 /* osl_destroyThread */
 233 /*****************************************************************************/
 234 void SAL_CALL osl_destroyThread(oslThread Thread)
 235 {
 236     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 237
 238     if(Thread == 0) /* valid ptr? */
 239     {
 240         /* thread already destroyed or not created */
 241         return;
 242     }
 243
 244     if(pThreadImpl->m_ThreadId != -1)    /* valid handle ? */
 245     {
 246         /* cancel thread  */
 247         DosKillThread( pThreadImpl->m_ThreadId );
 248     }
 249 }
 250
 251 /*****************************************************************************/
 252 /* osl_freeThreadHandle */
 253 /*****************************************************************************/
 254 void SAL_CALL osl_freeThreadHandle(oslThread Thread)
 255 {
 256     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 257
 258     if(Thread == 0)        /* valid ptr? */
 259     {
 260         /* thread already destroyed or not created */
 261         return;
 262     }
 263
 264     if (pThreadImpl->m_hEvent != 0)
 265         DosCloseEventSem(pThreadImpl->m_hEvent);
 266
 267     /* free memory */
 268     free(Thread);
 269 }
 270
 271 /*****************************************************************************/
 272 /* osl_resumeThread */
 273 /*****************************************************************************/
 274 void SAL_CALL osl_resumeThread(oslThread Thread)
 275 {
 276     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 277
 278     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 279
 280     DosResumeThread( pThreadImpl->m_ThreadId );
 281 }
 282
 283 /*****************************************************************************/
 284 /* osl_suspendThread */
 285 /*****************************************************************************/
 286 void SAL_CALL osl_suspendThread(oslThread Thread)
 287 {
 288     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 289
 290     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 291
 292     DosSuspendThread( pThreadImpl->m_ThreadId );
 293 }
 294
 295 /*****************************************************************************/
 296 /* osl_setThreadPriority */
 297 /*****************************************************************************/
 298 void SAL_CALL osl_setThreadPriority(oslThread Thread,
 299                            oslThreadPriority Priority)
 300 {
 301     ULONG nOs2PriorityClass;
 302     ULONG nOs2PriorityDelta;
 303     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 304
 305     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 306
 307     switch(Priority) {
 308
 309     case osl_Thread_PriorityHighest:
 310
 311         nOs2PriorityClass = PRTYC_REGULAR;
 312         nOs2PriorityDelta = PRTYD_MAXIMUM;
 313         break;
 314
 315     case osl_Thread_PriorityAboveNormal:
 316
 317         nOs2PriorityClass = PRTYC_REGULAR;
 318         nOs2PriorityDelta = 16;
 319         break;
 320
 321     case osl_Thread_PriorityNormal:
 322
 323         nOs2PriorityClass = PRTYC_REGULAR;
 324         nOs2PriorityDelta = 0;
 325         break;
 326
 327     case osl_Thread_PriorityBelowNormal:
 328
 329         nOs2PriorityClass = PRTYC_REGULAR;
 330         nOs2PriorityDelta = -16;
 331         break;
 332
 333     case osl_Thread_PriorityLowest:
 334
 335         nOs2PriorityClass = PRTYC_REGULAR;
 336         nOs2PriorityDelta = PRTYD_MINIMUM;
 337         break;
 338
 339     case osl_Thread_PriorityUnknown:
 340         OSL_ASSERT(FALSE);        /* only fools try this...*/
 341
 342         /* let release-version behave friendly */
 343         return;
 344
 345     default:
 346         OSL_ASSERT(FALSE);        /* enum expanded, but forgotten here...*/
 347
 348         /* let release-version behave friendly */
 349         return;
 350     }
 351
 352     DosSetPriority( PRTYS_THREAD,
 353                     nOs2PriorityClass, nOs2PriorityDelta,
 354                     pThreadImpl->m_ThreadId );
 355
 356 }
 357
 358 /*****************************************************************************/
 359 /* osl_getThreadPriority  */
 360 /*****************************************************************************/
 361
 362 #define BYTE1FROMULONG(ul) ((UCHAR) (ul))
 363 #define BYTE2FROMULONG(ul) ((UCHAR) ((ULONG) ul >> 8))
 364
 365 oslThreadPriority  SAL_CALL osl_getThreadPriority(const oslThread Thread)
 366 {
 367     ULONG nOs2PriorityClass;
 368     ULONG nOs2PriorityDelta;
 369
 370     oslThreadPriority Priority;
 371
 372     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 373
 374     /* invalid arguments ?*/
 375     if(pThreadImpl==0 || pThreadImpl->m_ThreadId==-1)
 376     {
 377         return osl_Thread_PriorityUnknown;
 378     }
 379
 380     /* get current priorities */
 381     {
 382     PTIB pptib = NULL;
 383     PPIB pppib = NULL;
 384
 385     DosGetInfoBlocks( &pptib, &pppib );
 386     nOs2PriorityClass = BYTE1FROMULONG( pptib->tib_ptib2->tib2_ulpri );
 387     nOs2PriorityDelta = BYTE2FROMULONG( pptib->tib_ptib2->tib2_ulpri );
 388     }
 389
 390     /* map OS2 priority to enum */
 391     switch(nOs2PriorityClass)
 392     {
 393     case PRTYC_TIMECRITICAL:
 394         Priority= osl_Thread_PriorityHighest;
 395         break;
 396
 397     case PRTYC_REGULAR:
 398
 399         if( nOs2PriorityDelta == 0 )
 400         {
 401             Priority= osl_Thread_PriorityNormal;
 402             break;
 403         }
 404
 405         if( nOs2PriorityDelta < -16 )
 406         {
 407             Priority= osl_Thread_PriorityLowest;
 408             break;
 409         }
 410
 411         if( nOs2PriorityDelta < 0 )
 412         {
 413             Priority= osl_Thread_PriorityBelowNormal;
 414             break;
 415         }
 416
 417         if( nOs2PriorityDelta > 0 )
 418         {
 419             Priority= osl_Thread_PriorityAboveNormal;
 420             break;
 421         }
 422
 423         Priority= osl_Thread_PriorityHighest;
 424         break;
 425
 426     case PRTYC_IDLETIME:
 427         Priority= osl_Thread_PriorityLowest;
 428         break;
 429
 430     default:
 431         OSL_ASSERT(FALSE);        /* OS/2 API changed, incorporate new prio-level! */
 432
 433         /* release-version behaves friendly */
 434         Priority= osl_Thread_PriorityUnknown;
 435     }
 436
 437     return Priority;
 438 }
 439
 440 /*****************************************************************************/
 441 /* osl_isThreadRunning */
 442 /*****************************************************************************/
 443 sal_Bool SAL_CALL osl_isThreadRunning(const oslThread Thread)
 444 {
 445     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 446     APIRET rc;
 447
 448     /* invalid arguments ?*/
 449     if(pThreadImpl==0 || pThreadImpl->m_ThreadId==-1)
 450     {
 451         return sal_False;
 452     }
 453
 454     if( osl_getThreadIdentifier( 0 ) == osl_getThreadIdentifier( Thread ) )
 455         return sal_True;
 456
 457     rc = DosWaitThread( &pThreadImpl->m_ThreadId, DCWW_NOWAIT );
 458
 459     return( rc != ERROR_INVALID_THREADID );
 460 }
 461
 462 /*****************************************************************************/
 463 /* osl_joinWithThread */
 464 /*****************************************************************************/
 465 void SAL_CALL osl_joinWithThread(oslThread Thread)
 466 {
 467     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 468
 469     /* invalid arguments?*/
 470     if(pThreadImpl==0 || pThreadImpl->m_ThreadId==-1)
 471     {
 472         /* assume thread is not running */
 473         return;
 474     }
 475
 476     DosWaitThread( &pThreadImpl->m_ThreadId, DCWW_WAIT );
 477 }
 478
 479 /*****************************************************************************/
 480 /* osl_waitThread */
 481 /*****************************************************************************/
 482 void SAL_CALL osl_waitThread(const TimeValue* pDelay)
 483 {
 484     int millisecs;
 485
 486     OSL_ASSERT(pDelay);
 487
 488     millisecs = pDelay->Seconds * 1000 + pDelay->Nanosec / 1000000;
 489
 490     DosSleep(millisecs);
 491 }
 492
 493 /*****************************************************************************/
 494 /* osl_terminateThread */
 495 /*****************************************************************************/
 496 void SAL_CALL osl_terminateThread(oslThread Thread)
 497 {
 498     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 499
 500     /* invalid arguments?*/
 501     if (pThreadImpl==0 || pThreadImpl->m_ThreadId==-1)
 502     {
 503         /* assume thread is not running */
 504         return;
 505     }
 506
 507     DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 508     pThreadImpl->m_Flags |= THREADIMPL_FLAGS_TERMINATE;
 509     DosReleaseMutexSem( MutexLock);
 510 }
 511
 512
 513 /*****************************************************************************/
 514 /* osl_scheduleThread */
 515 /*****************************************************************************/
 516 sal_Bool SAL_CALL osl_scheduleThread(oslThread Thread)
 517 {
 518     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 519
 520     osl_yieldThread();
 521
 522     /* invalid arguments?*/
 523     if (pThreadImpl==0 || pThreadImpl->m_ThreadId==-1)
 524     {
 525         /* assume thread is not running */
 526         return sal_False;
 527     }
 528
 529     if (pThreadImpl->m_Flags & THREADIMPL_FLAGS_SLEEP)
 530     {
 531         OSL_ASSERT (pThreadImpl->m_hEvent != 0);
 532
 533         DosWaitEventSem(pThreadImpl->m_hEvent, pThreadImpl->m_Timeout);
 534
 535         DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 536
 537         pThreadImpl->m_Timeout = 0;
 538
 539         pThreadImpl->m_Flags &= ~THREADIMPL_FLAGS_SLEEP;
 540
 541         DosReleaseMutexSem( MutexLock);
 542     }
 543
 544     return ((pThreadImpl->m_Flags & THREADIMPL_FLAGS_TERMINATE) == 0);
 545 }
 546
 547 /*****************************************************************************/
 548 /* osl_yieldThread */
 549 /*****************************************************************************/
 550 void SAL_CALL osl_yieldThread()
 551 {
 552     DosSleep(0);
 553 }
 554
 555 typedef struct _TLS
 556 {
 557     PULONG                                                      pulPtr;
 558     oslThreadKeyCallbackFunction        pfnCallback;
 559     struct _TLS                                         *pNext, *pPrev;
 560 } TLS, *PTLS;
 561
 562 static  PTLS            g_pThreadKeyList = NULL;
 563
 564 static void AddKeyToList( PTLS pTls )
 565 {
 566     if ( pTls )
 567     {
 568         DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 569
 570         pTls->pNext = g_pThreadKeyList;
 571         pTls->pPrev = 0;
 572
 573         if ( g_pThreadKeyList )
 574             g_pThreadKeyList->pPrev = pTls;
 575
 576         g_pThreadKeyList = pTls;
 577
 578         DosReleaseMutexSem( MutexLock);
 579     }
 580 }
 581
 582 static void RemoveKeyFromList( PTLS pTls )
 583 {
 584     if ( pTls )
 585     {
 586         DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 587         if ( pTls->pPrev )
 588             pTls->pPrev->pNext = pTls->pNext;
 589         else
 590         {
 591             OSL_ASSERT( pTls == g_pThreadKeyList );
 592             g_pThreadKeyList = pTls->pNext;
 593         }
 594
 595         if ( pTls->pNext )
 596             pTls->pNext->pPrev = pTls->pPrev;
 597         DosReleaseMutexSem( MutexLock);
 598     }
 599 }
 600
 601 void SAL_CALL _osl_callThreadKeyCallbackOnThreadDetach(void)
 602 {
 603     PTLS        pTls;
 604
 605     DosRequestMutexSem( MutexLock, SEM_INDEFINITE_WAIT );
 606     pTls = g_pThreadKeyList;
 607     while ( pTls )
 608     {
 609         if ( pTls->pfnCallback )
 610         {
 611             void        *pValue = (void*)*pTls->pulPtr;
 612
 613             if ( pValue )
 614                 pTls->pfnCallback( pValue );
 615         }
 616
 617         pTls = pTls->pNext;
 618     }
 619     DosReleaseMutexSem( MutexLock);
 620 }
 621
 622 /*****************************************************************************/
 623 /* osl_createThreadKey */
 624 /*****************************************************************************/
 625 oslThreadKey SAL_CALL osl_createThreadKey(oslThreadKeyCallbackFunction pCallback)
 626 {
 627     PTLS        pTls = (PTLS)rtl_allocateMemory( sizeof(TLS) );
 628
 629     if ( pTls )
 630     {
 631         pTls->pfnCallback = pCallback;
 632         if (DosAllocThreadLocalMemory(1, &pTls->pulPtr) != NO_ERROR)
 633         {
 634             rtl_freeMemory( pTls );
 635             pTls = 0;
 636         }
 637         else
 638         {
 639             *pTls->pulPtr = 0;
 640             AddKeyToList( pTls );
 641         }
 642     }
 643
 644     return ((oslThreadKey)pTls);
 645 }
 646
 647 /*****************************************************************************/
 648 /* osl_destroyThreadKey */
 649 /*****************************************************************************/
 650 void SAL_CALL osl_destroyThreadKey(oslThreadKey Key)
 651 {
 652     if (Key != 0)
 653     {
 654         PTLS    pTls = (PTLS)Key;
 655
 656         RemoveKeyFromList( pTls );
 657         DosFreeThreadLocalMemory(pTls->pulPtr);
 658         rtl_freeMemory( pTls );
 659     }
 660 }
 661
 662 /*****************************************************************************/
 663 /* osl_getThreadKeyData */
 664 /*****************************************************************************/
 665 void * SAL_CALL osl_getThreadKeyData(oslThreadKey Key)
 666 {
 667     if (Key != 0)
 668     {
 669         PTLS    pTls = (PTLS)Key;
 670
 671         return ((void *) *pTls->pulPtr);
 672     }
 673
 674     return (NULL);
 675 }
 676
 677 /*****************************************************************************/
 678 /* osl_setThreadKeyData */
 679 /*****************************************************************************/
 680 sal_Bool SAL_CALL osl_setThreadKeyData(oslThreadKey Key, void *pData)
 681 {
 682     if (Key != 0)
 683     {
 684         PTLS    pTls = (PTLS)Key;
 685         void*   pOldData = NULL;
 686         BOOL    fSuccess = TRUE; //YD cannot fail
 687
 688         if ( pTls->pfnCallback )
 689             pOldData = (void*)*pTls->pulPtr;
 690
 691         *pTls->pulPtr = (ULONG)pData;
 692
 693         if ( fSuccess && pTls->pfnCallback && pOldData )
 694             pTls->pfnCallback( pOldData );
 695
 696         return (sal_Bool)(fSuccess != FALSE);
 697     }
 698
 699     return (sal_False);
 700 }
 701
 702
 703
 704 /*****************************************************************************/
 705 /* osl_getThreadTextEncoding */
 706 /*****************************************************************************/
 707
 708 ULONG   g_dwTLSTextEncodingIndex = (ULONG)-1;
 709
 710 sal_uInt32 SAL_CALL _GetACP( void)
 711 {
 712     APIRET      rc;
 713     ULONG       aulCpList[8]  = {0};
 714     ULONG       ulListSize;
 715
 716     rc = DosQueryCp( sizeof( aulCpList), aulCpList, &ulListSize);
 717     if (rc)
 718         return 437;     // in case of error, return codepage EN_US
 719     // current codepage is first of list, others are the prepared codepages.
 720     return aulCpList[0];
 721 }
 722
 723 rtl_TextEncoding SAL_CALL osl_getThreadTextEncoding(void)
 724 {
 725     rtl_TextEncoding    _encoding;
 726
 727     if ( (ULONG)-1 == g_dwTLSTextEncodingIndex ) {
 728         rtl_TextEncoding defaultEncoding;
 729         const char *     pszEncoding;
 730
 731         /* create thread specific data key */
 732         g_dwTLSTextEncodingIndex = osl_createThreadKey( NULL);
 733
 734         /* determine default text encoding */
 735         pszEncoding = getenv ("SOLAR_USER_RTL_TEXTENCODING");
 736         if (pszEncoding)
 737             defaultEncoding = atoi(pszEncoding);
 738         else
 739             defaultEncoding = rtl_getTextEncodingFromWindowsCodePage( _GetACP());
 740
 741         //OSL_ASSERT(defaultEncoding != RTL_TEXTENCODING_DONTKNOW);
 742         //g_thread.m_textencoding.m_default = defaultEncoding;
 743         osl_setThreadKeyData( g_dwTLSTextEncodingIndex, (void*)defaultEncoding);
 744     }
 745
 746     _encoding = (rtl_TextEncoding)osl_getThreadKeyData( g_dwTLSTextEncodingIndex );
 747     if (0 == _encoding) {
 748         const char *     pszEncoding;
 749         /* determine default text encoding */
 750         pszEncoding = getenv ("SOLAR_USER_RTL_TEXTENCODING");
 751         if (pszEncoding)
 752             _encoding = atoi(pszEncoding);
 753         else
 754             _encoding = rtl_getTextEncodingFromWindowsCodePage( _GetACP());
 755         /* save for future reference */
 756         osl_setThreadKeyData( g_dwTLSTextEncodingIndex, (void*)_encoding);
 757     }
 758
 759     return _encoding;
 760 }
 761
 762 /*****************************************************************************/
 763 /* osl_getThreadTextEncoding */
 764 /*****************************************************************************/
 765 rtl_TextEncoding SAL_CALL osl_setThreadTextEncoding( rtl_TextEncoding Encoding )
 766 {
 767     rtl_TextEncoding oldEncoding = osl_getThreadTextEncoding();
 768
 769     osl_setThreadKeyData( g_dwTLSTextEncodingIndex, (void*)Encoding);
 770
 771     return oldEncoding;
 772 }
 773
 774
 775