Source

gd-libgd / netware / nwlibc.c

Diff from to

File netware/nwlibc.c

 #include <nks/synch.h>
 
 
-typedef struct
-{
-    int     _errno;
-    void    *twentybytes;
+typedef struct {
+	int     _errno;
+	void    *twentybytes;
 } libthreaddata_t;
 
-typedef struct
-{
-    int         x;
-    int         y;
-    int         z;
-    void        *tenbytes;
-    NXKey_t     perthreadkey;   /* if -1, no key obtained... */
-    NXMutex_t   *lock;
+typedef struct {
+	int         x;
+	int         y;
+	int         z;
+	void        *tenbytes;
+	NXKey_t     perthreadkey;   /* if -1, no key obtained... */
+	NXMutex_t   *lock;
 } libdata_t;
 
 int         gLibId      = -1;
     size_t      uninitializedDataLength,
     void        *NLMFileHandle,
     int         (*readRoutineP)( int conn, void *fileHandle, size_t offset,
-                                size_t nbytes, size_t *bytesRead, void *buffer ),
+                                 size_t nbytes, size_t *bytesRead, void *buffer ),
     size_t      customDataOffset,
     size_t      customDataSize,
     int         messageCount,
     const char  **messages
 )
 {
-    NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0);
+	NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0);
 
 #ifndef __GNUC__
 #pragma unused(cmdLine)
 #pragma unused(messages)
 #endif
 
-/*
-** Here we process our command line, post errors (to the error screen),
-** perform initializations and anything else we need to do before being able
-** to accept calls into us. If we succeed, we return non-zero and the NetWare
-** Loader will leave us up, otherwise we fail to load and get dumped.
-*/
-    gAllocTag = AllocateResourceTag(NLMHandle,
-                                "<library-name> memory allocations", AllocSignature);
+	/*
+	** Here we process our command line, post errors (to the error screen),
+	** perform initializations and anything else we need to do before being able
+	** to accept calls into us. If we succeed, we return non-zero and the NetWare
+	** Loader will leave us up, otherwise we fail to load and get dumped.
+	*/
+	gAllocTag = AllocateResourceTag(NLMHandle,
+	                                "<library-name> memory allocations", AllocSignature);
 
-    if (!gAllocTag)
-    {
-        OutputToScreen(errorScreen, "Unable to allocate resource tag for "
-                                            "library memory allocations.\n");
-        return -1;
-    }
+	if (!gAllocTag) {
+		OutputToScreen(errorScreen, "Unable to allocate resource tag for "
+		               "library memory allocations.\n");
+		return -1;
+	}
 
-    gLibId = register_library(DisposeLibraryData);
+	gLibId = register_library(DisposeLibraryData);
 
-    if (gLibId < -1)
-    {
-        OutputToScreen(errorScreen, "Unable to register library with kernel.\n");
-        return -1;
-    }
+	if (gLibId < -1) {
+		OutputToScreen(errorScreen, "Unable to register library with kernel.\n");
+		return -1;
+	}
 
-    gLibHandle = NLMHandle;
+	gLibHandle = NLMHandle;
 
-    gLibLock = NXMutexAlloc(0, 0, &liblock);
+	gLibLock = NXMutexAlloc(0, 0, &liblock);
 
-    if (!gLibLock)
-    {
-        OutputToScreen(errorScreen, "Unable to allocate library data lock.\n");
-        return -1;
-    }
+	if (!gLibLock) {
+		OutputToScreen(errorScreen, "Unable to allocate library data lock.\n");
+		return -1;
+	}
 
-    return 0;
+	return 0;
 }
 
 /*
 */
 void _NonAppStop( void )
 {
-    (void) unregister_library(gLibId);
-    NXMutexFree(gLibLock);
+	(void) unregister_library(gLibId);
+	NXMutexFree(gLibLock);
 }
 
 /*
 */
 int  _NonAppCheckUnload( void )
 {
-    return 0;
+	return 0;
 }
 
 int GetOrSetUpData
     libthreaddata_t **threadData
 )
 {
-    int                 err;
-    libdata_t           *app_data;
-    libthreaddata_t *thread_data;
-    NXKey_t             key;
-    NX_LOCK_INFO_ALLOC(liblock, "Application Data Lock", 0);
-
-    err         = 0;
-    thread_data = (libthreaddata_t *) NULL;
-
-/*
-** Attempt to get our data for the application calling us. This is where we
-** store whatever application-specific information we need to carry in support
-** of calling applications.
-*/
-    app_data = (libdata_t *) get_app_data(id);
-
-    if (!app_data)
-    {
-/*
-** This application hasn't called us before; set up application AND per-thread
-** data. Of course, just in case a thread from this same application is calling
-** us simultaneously, we better lock our application data-creation mutex. We
-** also need to recheck for data after we acquire the lock because WE might be
-** that other thread that was too late to create the data and the first thread
-** in will have created it.
-*/
-        NXLock(gLibLock);
-
-        if (!(app_data = (libdata_t *) get_app_data(id)))
-        {
-            app_data = (libdata_t *) malloc(sizeof(libdata_t));
-
-            if (app_data)
-            {
-                memset(app_data, 0, sizeof(libdata_t));
-
-                app_data->tenbytes = malloc(10);
-                app_data->lock     = NXMutexAlloc(0, 0, &liblock);
-
-                if (!app_data->tenbytes || !app_data->lock)
-                {
-                    if (app_data->lock)
-                        NXMutexFree(app_data->lock);
-
-                    free(app_data);
-                    app_data = (libdata_t *) NULL;
-                    err      = ENOMEM;
-                }
-
-                if (app_data)
-                {
-/*
-** Here we burn in the application data that we were trying to get by calling
-** get_app_data(). Next time we call the first function, we'll get this data
-** we're just now setting. We also go on here to establish the per-thread data
-** for the calling thread, something we'll have to do on each application
-** thread the first time it calls us.
-*/
-                    err = set_app_data(gLibId, app_data);
-
-                    if (err)
-                    {
-                        free(app_data);
-                        app_data = (libdata_t *) NULL;
-                        err      = ENOMEM;
-                    }
-                    else
-                    {
-                        /* create key for thread-specific data... */
-                        err = NXKeyCreate(DisposeThreadData, (void *) NULL, &key);
-
-                        if (err)                /* (no more keys left?) */
-                            key = -1;
-
-                        app_data->perthreadkey = key;
-                    }
-                }
-            }
-        }
-
-        NXUnlock(gLibLock);
-    }
-
-    if (app_data)
-    {
-        key = app_data->perthreadkey;
-
-        if (     key != -1                  /* couldn't create a key? no thread data */
-            && !(err = NXKeyGetValue(key, (void **) &thread_data))
-            && !thread_data)
-        {
-/*
-** Allocate the per-thread data for the calling thread. Regardless of whether
-** there was already application data or not, this may be the first call by a
-** a new thread. The fact that we allocation 20 bytes on a pointer is not very
-** important, this just helps to demonstrate that we can have arbitrarily
-** complex per-thread data.
-*/
-            thread_data = (libthreaddata_t *) malloc(sizeof(libthreaddata_t));
-
-            if (thread_data)
-            {
-                thread_data->_errno      = 0;
-                thread_data->twentybytes = malloc(20);
-
-                if (!thread_data->twentybytes)
-                {
-                    free(thread_data);
-                    thread_data = (libthreaddata_t *) NULL;
-                    err         = ENOMEM;
-                }
-
-                if ((err = NXKeySetValue(key, thread_data)))
-                {
-                    free(thread_data->twentybytes);
-                    free(thread_data);
-                    thread_data = (libthreaddata_t *) NULL;
-                }
-            }
-        }
-    }
-
-    if (appData)
-        *appData = app_data;
-
-    if (threadData)
-        *threadData = thread_data;
-
-    return err;
+	int                 err;
+	libdata_t           *app_data;
+	libthreaddata_t *thread_data;
+	NXKey_t             key;
+	NX_LOCK_INFO_ALLOC(liblock, "Application Data Lock", 0);
+
+	err         = 0;
+	thread_data = (libthreaddata_t *) NULL;
+
+	/*
+	** Attempt to get our data for the application calling us. This is where we
+	** store whatever application-specific information we need to carry in support
+	** of calling applications.
+	*/
+	app_data = (libdata_t *) get_app_data(id);
+
+	if (!app_data) {
+		/*
+		** This application hasn't called us before; set up application AND per-thread
+		** data. Of course, just in case a thread from this same application is calling
+		** us simultaneously, we better lock our application data-creation mutex. We
+		** also need to recheck for data after we acquire the lock because WE might be
+		** that other thread that was too late to create the data and the first thread
+		** in will have created it.
+		*/
+		NXLock(gLibLock);
+
+		if (!(app_data = (libdata_t *) get_app_data(id))) {
+			app_data = (libdata_t *) malloc(sizeof(libdata_t));
+
+			if (app_data) {
+				memset(app_data, 0, sizeof(libdata_t));
+
+				app_data->tenbytes = malloc(10);
+				app_data->lock     = NXMutexAlloc(0, 0, &liblock);
+
+				if (!app_data->tenbytes || !app_data->lock) {
+					if (app_data->lock)
+						NXMutexFree(app_data->lock);
+
+					free(app_data);
+					app_data = (libdata_t *) NULL;
+					err      = ENOMEM;
+				}
+
+				if (app_data) {
+					/*
+					** Here we burn in the application data that we were trying to get by calling
+					** get_app_data(). Next time we call the first function, we'll get this data
+					** we're just now setting. We also go on here to establish the per-thread data
+					** for the calling thread, something we'll have to do on each application
+					** thread the first time it calls us.
+					*/
+					err = set_app_data(gLibId, app_data);
+
+					if (err) {
+						free(app_data);
+						app_data = (libdata_t *) NULL;
+						err      = ENOMEM;
+					} else {
+						/* create key for thread-specific data... */
+						err = NXKeyCreate(DisposeThreadData, (void *) NULL, &key);
+
+						if (err)                /* (no more keys left?) */
+							key = -1;
+
+						app_data->perthreadkey = key;
+					}
+				}
+			}
+		}
+
+		NXUnlock(gLibLock);
+	}
+
+	if (app_data) {
+		key = app_data->perthreadkey;
+
+		if (     key != -1                  /* couldn't create a key? no thread data */
+		         && !(err = NXKeyGetValue(key, (void **) &thread_data))
+		         && !thread_data) {
+			/*
+			** Allocate the per-thread data for the calling thread. Regardless of whether
+			** there was already application data or not, this may be the first call by a
+			** a new thread. The fact that we allocation 20 bytes on a pointer is not very
+			** important, this just helps to demonstrate that we can have arbitrarily
+			** complex per-thread data.
+			*/
+			thread_data = (libthreaddata_t *) malloc(sizeof(libthreaddata_t));
+
+			if (thread_data) {
+				thread_data->_errno      = 0;
+				thread_data->twentybytes = malloc(20);
+
+				if (!thread_data->twentybytes) {
+					free(thread_data);
+					thread_data = (libthreaddata_t *) NULL;
+					err         = ENOMEM;
+				}
+
+				if ((err = NXKeySetValue(key, thread_data))) {
+					free(thread_data->twentybytes);
+					free(thread_data);
+					thread_data = (libthreaddata_t *) NULL;
+				}
+			}
+		}
+	}
+
+	if (appData)
+		*appData = app_data;
+
+	if (threadData)
+		*threadData = thread_data;
+
+	return err;
 }
 
 int DisposeLibraryData
     void    *data
 )
 {
-    if (data)
-    {
-        void    *tenbytes = ((libdata_t *) data)->tenbytes;
+	if (data) {
+		void    *tenbytes = ((libdata_t *) data)->tenbytes;
 
-        if (tenbytes)
-            free(tenbytes);
+		if (tenbytes)
+			free(tenbytes);
 
-        free(data);
-    }
+		free(data);
+	}
 
-    return 0;
+	return 0;
 }
 
 void DisposeThreadData
     void    *data
 )
 {
-    if (data)
-    {
-        void    *twentybytes = ((libthreaddata_t *) data)->twentybytes;
+	if (data) {
+		void    *twentybytes = ((libthreaddata_t *) data)->twentybytes;
 
-        if (twentybytes)
-            free(twentybytes);
+		if (twentybytes)
+			free(twentybytes);
 
-        free(data);
-    }
+		free(data);
+	}
 }