Changeset 452 for WizardsToolkit/trunk

Timestamp:

10/25/09 11:36:27 (4 weeks ago)

Author:

cristy

Message:

 

Location:

WizardsToolkit/trunk/wizard

Files:

• blob.c (modified) (1 diff)
• configure.c (modified) (11 diffs)
• configure.h (modified) (1 diff)
• exception.c (modified) (9 diffs)
• file.c (modified) (6 diffs)
• log.c (modified) (19 diffs)
• memory.c (modified) (9 diffs)
• mime.c (modified) (10 diffs)
• random.c (modified) (2 diffs)
• resource.c (modified) (16 diffs)
• semaphore.c (modified) (1 diff)
• studio.h (modified) (1 diff)
• wizard.c (modified) (2 diffs)

WizardsToolkit/trunk/wizard/blob.c

@@ -329 +329 @@
       blob_info->filename);
   destroy=WizardFalse;
-  AcquireSemaphoreInfo(&blob_info->semaphore);
+  LockSemaphoreInfo(blob_info->semaphore);
   blob_info->reference_count--;
   if (blob_info->reference_count == 0)
     destroy=WizardTrue;
-  RelinquishSemaphoreInfo(blob_info->semaphore);
+  UnlockSemaphoreInfo(blob_info->semaphore);
   if (destroy == WizardFalse)
     return(blob_info);

WizardsToolkit/trunk/wizard/configure.c

@@ -76 +76 @@
   ConfigureMap[] =
   {
+    { "NAME", "ImageMagick" }
   };
 
@@ -99 +100 @@
 %                                                                             %
 %                                                                             %
-+   D e s t r o y C o n f i g u r e L i s t                                   %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  DestroyConfigureList() deallocates memory associated with the configure list.
-%
-%  The format of the DestroyConfigureList method is:
-%
-%      DestroyConfigureList(void)
-%
++   C o n f i g u r e C o m p o n e n t G e n e s i s                         %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  ConfigureComponentGenesis() instantiates the configure component.
+%
+%  The format of the ConfigureComponentGenesis method is:
+%
+%      WizardBooleanType ConfigureComponentGenesis(void)
+%
+*/
+WizardExport WizardBooleanType ConfigureComponentGenesis(void)
+{
+  assert(configure_semaphore == (SemaphoreInfo *) NULL);
+  configure_semaphore=AllocateSemaphoreInfo();
+  return(WizardTrue);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
++   C o n f i g u r e C o m p o n e n t T e r m i n u s                       %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  ConfigureComponentTerminus() deallocates memory associated with the
+%  configure list.
+%
+%  The format of the ConfigureComponentTerminus method is:
+%
+%      ConfigureComponentTerminus(void)
 %
 */
@@ -133 +159 @@
 }
 
-WizardExport void DestroyConfigureList(void)
-{
-  AcquireSemaphoreInfo(&configure_semaphore);
+WizardExport void ConfigureComponentTerminus(void)
+{
+  if (configure_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
   if (configure_list != (LinkedListInfo *) NULL)
     configure_list=DestroyLinkedList(configure_list,DestroyConfigureElement);
   configure_list=(LinkedListInfo *) NULL;
   instantiate_configure=WizardFalse;
-  RelinquishSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   DestroySemaphoreInfo(&configure_semaphore);
 }
@@ -228 +256 @@
     Search for named configure.
   */
-  AcquireSemaphoreInfo(&configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
   ResetLinkedListIterator(configure_list);
   p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
@@ -243 +271 @@
     (void) InsertValueInLinkedList(configure_list,0,
       RemoveElementByValueFromLinkedList(configure_list,p));
-  RelinquishSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   return(p);
 }
@@ -327 +355 @@
     Generate configure list.
   */
-  AcquireSemaphoreInfo(&configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
   ResetLinkedListIterator(configure_list);
   p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
@@ -337 +365 @@
     p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
   }
-  RelinquishSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   qsort((void *) options,(size_t) i,sizeof(*options),ConfigureInfoCompare);
   options[i]=(ConfigureInfo *) NULL;
@@ -414 +442 @@
   if (p == (const ConfigureInfo *) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&configure_semaphore);
-  RelinquishSemaphoreInfo(configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   options=(char **) AcquireQuantumMemory((size_t)
     GetNumberOfElementsInLinkedList(configure_list)+1UL,sizeof(*options));
   if (options == (char **) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&configure_semaphore);
+  LockSemaphoreInfo(configure_semaphore);
   ResetLinkedListIterator(configure_list);
   p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
@@ -430 +458 @@
     p=(const ConfigureInfo *) GetNextValueInLinkedList(configure_list);
   }
-  RelinquishSemaphoreInfo(configure_semaphore);
+  UnlockSemaphoreInfo(configure_semaphore);
   qsort((void *) options,(size_t) i,sizeof(*options),ConfigureCompare);
   options[i]=(char *) NULL;
@@ -791 +819 @@
       (instantiate_configure == WizardFalse))
     {
-      AcquireSemaphoreInfo(&configure_semaphore);
+      LockSemaphoreInfo(configure_semaphore);
       if ((configure_list == (LinkedListInfo *) NULL) &&
           (instantiate_configure == WizardFalse))
@@ -798 +826 @@
           instantiate_configure=WizardTrue;
         }
-      RelinquishSemaphoreInfo(configure_semaphore);
+      UnlockSemaphoreInfo(configure_semaphore);
     }
   return(configure_list != (LinkedListInfo *) NULL ? WizardTrue : WizardFalse);

WizardsToolkit/trunk/wizard/configure.h

@@ -56 +56 @@
 
 extern WizardExport WizardBooleanType
+  ConfigureComponentGenesis(void),
   ListConfigureInfo(FILE *,ExceptionInfo *);
 
 extern WizardExport void
-  DestroyConfigureList(void);
+  ConfigureComponentTerminus(void);
 
 #if defined(__cplusplus) || defined(c_plusplus)

WizardsToolkit/trunk/wizard/exception.c

@@ -185 +185 @@
   if (exception->exceptions == (void *) NULL)
     return;
-  AcquireSemaphoreInfo(&exception->semaphore);
+  LockSemaphoreInfo(exception->semaphore);
   p=(ExceptionInfo *) RemoveLastElementFromLinkedList((LinkedListInfo *)
     exception->exceptions);
@@ -197 +197 @@
   exception->reason=(char *) NULL;
   exception->description=(char *) NULL;
-  RelinquishSemaphoreInfo(exception->semaphore);
+  UnlockSemaphoreInfo(exception->semaphore);
   errno=0;
 }
@@ -233 +233 @@
   if (exception->exceptions == (void *) NULL)
     return;
-  AcquireSemaphoreInfo(&exception->semaphore);
+  LockSemaphoreInfo(exception->semaphore);
   ResetLinkedListIterator((LinkedListInfo *) exception->exceptions);
   p=(const ExceptionInfo *) GetNextValueInLinkedList((LinkedListInfo *)
@@ -248 +248 @@
       exception->exceptions);
   }
-  RelinquishSemaphoreInfo(exception->semaphore);
+  UnlockSemaphoreInfo(exception->semaphore);
   ClearWizardException(exception);
 }
@@ -401 +401 @@
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == WizardSignature);
-  AcquireSemaphoreInfo(&exception->semaphore);
+  LockSemaphoreInfo(exception->semaphore);
   exception->severity=UndefinedException;
   if (exception->exceptions != (void *) NULL)
@@ -407 +407 @@
       exception->exceptions,DestroyExceptionElement);
   exception->signature=(~WizardSignature);
-  RelinquishSemaphoreInfo(exception->semaphore);
+  UnlockSemaphoreInfo(exception->semaphore);
   DestroySemaphoreInfo(&exception->semaphore);
   if (exception->relinquish != WizardFalse)
@@ -442 +442 @@
   exception->severity=UndefinedException;
   exception->exceptions=(void *) NewLinkedList(0);
+  exception->semaphore=AllocateSemaphoreInfo();
   exception->signature=WizardSignature;
 }
@@ -662 +663 @@
   if (relative->exceptions == (void *) NULL)
     return;
-  AcquireSemaphoreInfo(&exception->semaphore);
+  LockSemaphoreInfo(exception->semaphore);
   ResetLinkedListIterator((LinkedListInfo *) relative->exceptions);
   p=(const ExceptionInfo *) GetNextValueInLinkedList((LinkedListInfo *)
@@ -672 +673 @@
       relative->exceptions);
   }
-  RelinquishSemaphoreInfo(exception->semaphore);
+  UnlockSemaphoreInfo(exception->semaphore);
 }
 

WizardsToolkit/trunk/wizard/file.c

@@ -147 +147 @@
   assert(file_info->signature == WizardSignature);
   (void) LogWizardEvent(TraceEvent,GetWizardModule(),"%s",file_info->path);
-  AcquireSemaphoreInfo(&file_info->semaphore);
+  LockSemaphoreInfo(file_info->semaphore);
   path=AcquireString(file_info->path);
   AppendFileExtension("lck",path);
@@ -176 +176 @@
               {
                 path=DestroyString(path);
-                RelinquishSemaphoreInfo(file_info->semaphore);
+                UnlockSemaphoreInfo(file_info->semaphore);
                 return(WizardTrue);
               }
@@ -220 +220 @@
   }
   path=DestroyString(path);
-  RelinquishSemaphoreInfo(file_info->semaphore);
+  UnlockSemaphoreInfo(file_info->semaphore);
   return(WizardFalse);
 }
@@ -278 +278 @@
   file_info->path=AcquireString((char *) NULL);
   file_info->file=(-1);
-  file_info->semaphore=(SemaphoreInfo *) NULL;
+  file_info->semaphore=AllocateSemaphoreInfo();
   file_info->timestamp=time((time_t *) NULL);
   file_info->signature=WizardSignature;
@@ -433 +433 @@
   assert(file_info->signature == WizardSignature);
   (void) LogWizardEvent(TraceEvent,GetWizardModule(),"%s",file_info->path);
-  AcquireSemaphoreInfo(&file_info->semaphore);
+  LockSemaphoreInfo(file_info->semaphore);
   if (file_info->file >= 0)
     if (close(file_info->file) == -1)
@@ -443 +443 @@
     file_info->path=DestroyString(file_info->path);
   file_info->signature=(~WizardSignature);
-  RelinquishSemaphoreInfo(file_info->semaphore);
+  UnlockSemaphoreInfo(file_info->semaphore);
   DestroySemaphoreInfo(&file_info->semaphore);
   file_info=(FileInfo *) RelinquishWizardMemory(file_info);

WizardsToolkit/trunk/wizard/log.c

@@ -226 +226 @@
   log_info=(LogInfo *) GetLogInfo("*",exception);
   exception=DestroyExceptionInfo(exception);
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   if (log_info->file != (FILE *) NULL)
     {
@@ -234 +234 @@
       log_info->file=(FILE *) NULL;
     }
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
 }
 
@@ -280 +280 @@
     Search for named log.
   */
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   ResetLinkedListIterator(log_list);
   p=(const LogInfo *) GetNextValueInLinkedList(log_list);
@@ -295 +295 @@
     (void) InsertValueInLinkedList(log_list,0,
       RemoveElementByValueFromLinkedList(log_list,p));
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   return(p);
 }
@@ -376 +376 @@
     Generate log list.
   */
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   ResetLinkedListIterator(log_list);
   p=(const LogInfo *) GetNextValueInLinkedList(log_list);
@@ -386 +386 @@
     p=(const LogInfo *) GetNextValueInLinkedList(log_list);
   }
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   qsort((void *) preferences,(size_t) i,sizeof(*preferences),LogInfoCompare);
   preferences[i]=(LogInfo *) NULL;
@@ -469 +469 @@
     Generate log list.
   */
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   ResetLinkedListIterator(log_list);
   p=(const LogInfo *) GetNextValueInLinkedList(log_list);
@@ -479 +479 @@
     p=(const LogInfo *) GetNextValueInLinkedList(log_list);
   }
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   qsort((void *) preferences,(size_t) i,sizeof(*preferences),LogCompare);
   preferences[i]=(char *) NULL;
@@ -536 +536 @@
     {
       AcquireSemaphoreInfo(&log_semaphore);
+      LockSemaphoreInfo(log_semaphore);
       if ((log_list == (LinkedListInfo *) NULL) &&
           (instantiate_log == WizardFalse))
@@ -542 +543 @@
           instantiate_log=WizardTrue;
         }
-      RelinquishSemaphoreInfo(log_semaphore);
+      UnlockSemaphoreInfo(log_semaphore);
     }
   return(log_list != (LinkedListInfo *) NULL ? WizardTrue : WizardFalse);
@@ -687 +688 @@
 WizardExport WizardBooleanType LogComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&log_semaphore);
-  RelinquishSemaphoreInfo(log_semaphore);
+  assert(log_semaphore == (SemaphoreInfo *) NULL);
+  log_semaphore=AllocateSemaphoreInfo();
   return(WizardTrue);
 }
@@ -741 +742 @@
 WizardExport void LogComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&log_semaphore);
+  if (log_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   if (log_list != (LinkedListInfo *) NULL)
     log_list=DestroyLinkedList(log_list,DestroyLogElement);
   instantiate_log=WizardFalse;
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   DestroySemaphoreInfo(&log_semaphore);
 }
@@ -1130 +1133 @@
   log_info=(LogInfo *) GetLogInfo("*",exception);
   exception=DestroyExceptionInfo(exception);
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   if ((log_info->event_mask & type) == 0)
     {
-      RelinquishSemaphoreInfo(log_semaphore);
+      UnlockSemaphoreInfo(log_semaphore);
       return(WizardTrue);
     }
@@ -1148 +1151 @@
     {
       (void) ContinueTimer(log_info->timer);
-      RelinquishSemaphoreInfo(log_semaphore);
+      UnlockSemaphoreInfo(log_semaphore);
       return(WizardFalse);
     }
@@ -1191 +1194 @@
             {
               (void) ContinueTimer(log_info->timer);
-              RelinquishSemaphoreInfo(log_semaphore);
+              UnlockSemaphoreInfo(log_semaphore);
               return(WizardFalse);
             }
@@ -1199 +1202 @@
           if (log_info->file == (FILE *) NULL)
             {
-              RelinquishSemaphoreInfo(log_semaphore);
+              UnlockSemaphoreInfo(log_semaphore);
               return(WizardFalse);
             }
@@ -1225 +1228 @@
   text=(char  *) RelinquishWizardMemory(text);
   (void) ContinueTimer(log_info->timer);
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   return(WizardTrue);
 }
@@ -1689 +1692 @@
   exception=DestroyExceptionInfo(exception);
   option=ParseWizardOption(WizardLogEventOptions,WizardTrue,events);
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   log_info=(LogInfo *) GetValueFromLinkedList(log_list,0);
   log_info->event_mask=(LogEventType) option;
   if (option == -1)
     log_info->event_mask=UndefinedEvents;
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
   return(log_info->event_mask);
 }
@@ -1731 +1734 @@
   log_info=(LogInfo *) GetLogInfo("*",exception);
   exception=DestroyExceptionInfo(exception);
-  AcquireSemaphoreInfo(&log_semaphore);
+  LockSemaphoreInfo(log_semaphore);
   if (log_info->format != (char *) NULL)
     log_info->format=DestroyString(log_info->format);
   log_info->format=ConstantString(format);
-  RelinquishSemaphoreInfo(log_semaphore);
+  UnlockSemaphoreInfo(log_semaphore);
 }
 

WizardsToolkit/trunk/wizard/memory.c

@@ -391 +391 @@
   if (free_segments == (DataSegmentInfo *) NULL)
     {
-      AcquireSemaphoreInfo(&memory_semaphore);
+      LockSemaphoreInfo(memory_semaphore);
       if (free_segments == (DataSegmentInfo *) NULL)
         {
@@ -411 +411 @@
           free_segments=(&memory_info.segment_pool[0]);
         }
-      RelinquishSemaphoreInfo(memory_semaphore);
-    }
-  AcquireSemaphoreInfo(&memory_semaphore);
+      UnlockSemaphoreInfo(memory_semaphore);
+    }
+  LockSemaphoreInfo(memory_semaphore);
   memory=AcquireBlock(size == 0 ? 1UL : size);
   if (memory == (void *) NULL)
@@ -420 +420 @@
         memory=AcquireBlock(size == 0 ? 1UL : size);
     }
-  RelinquishSemaphoreInfo(memory_semaphore);
+  UnlockSemaphoreInfo(memory_semaphore);
 #endif
   return(memory);
@@ -546 +546 @@
     i;
 
-  AcquireSemaphoreInfo(&memory_semaphore);
-  RelinquishSemaphoreInfo(memory_semaphore);
+  LockSemaphoreInfo(memory_semaphore);
+  UnlockSemaphoreInfo(memory_semaphore);
   for (i=0; i < (long) memory_info.number_segments; i++)
     if (memory_info.segments[i]->mapped == WizardFalse)
@@ -742 +742 @@
   assert((SizeOfBlock(memory) % (4*sizeof(size_t))) == 0);
   assert((*BlockHeader(NextBlock(memory)) & PreviousBlockBit) != 0);
-  AcquireSemaphoreInfo(&memory_semaphore);
+  LockSemaphoreInfo(memory_semaphore);
   if ((*BlockHeader(memory) & PreviousBlockBit) == 0)
     {
@@ -773 +773 @@
   *BlockHeader(NextBlock(memory))&=(~PreviousBlockBit);
   InsertFreeBlock(memory,AllocationPolicy(SizeOfBlock(memory)));
-  RelinquishSemaphoreInfo(memory_semaphore);
+  UnlockSemaphoreInfo(memory_semaphore);
 #endif
   return((void *) NULL);
@@ -870 +870 @@
     memory=RelinquishWizardMemory(memory);
 #else
-  AcquireSemaphoreInfo(&memory_semaphore);
+  LockSemaphoreInfo(memory_semaphore);
   block=ResizeBlock(memory,size == 0 ? 1UL : size);
   if (block == (void *) NULL)
@@ -876 +876 @@
       if (ExpandHeap(size == 0 ? 1UL : size) == WizardFalse)
         {
-          RelinquishSemaphoreInfo(memory_semaphore);
+          UnlockSemaphoreInfo(memory_semaphore);
           memory=RelinquishWizardMemory(memory);
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
@@ -883 +883 @@
       assert(block != (void *) NULL);
     }
-  RelinquishSemaphoreInfo(memory_semaphore);
+  UnlockSemaphoreInfo(memory_semaphore);
   memory=RelinquishWizardMemory(memory);
 #endif

WizardsToolkit/trunk/wizard/mime.c

@@ -201 +201 @@
   mime_info=(const MimeInfo *) NULL;
   lsb_first=1;
-  AcquireSemaphoreInfo(&mime_semaphore);
+  LockSemaphoreInfo(mime_semaphore);
   ResetLinkedListIterator(mime_list);
   p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
@@ -325 +325 @@
     (void) InsertValueInLinkedList(mime_list,0,
       RemoveElementByValueFromLinkedList(mime_list,p));
-  RelinquishSemaphoreInfo(mime_semaphore);
+  UnlockSemaphoreInfo(mime_semaphore);
   return(mime_info);
 }
@@ -409 +409 @@
     Generate mime list.
   */
-  AcquireSemaphoreInfo(&mime_semaphore);
+  LockSemaphoreInfo(mime_semaphore);
   ResetLinkedListIterator(mime_list);
   p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
@@ -419 +419 @@
     p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
   }
-  RelinquishSemaphoreInfo(mime_semaphore);
+  UnlockSemaphoreInfo(mime_semaphore);
   qsort((void *) aliases,(size_t) i,sizeof(*aliases),MimeInfoCompare);
   aliases[i]=(MimeInfo *) NULL;
@@ -501 +501 @@
   if (aliases == (char **) NULL)
     return((char **) NULL);
-  AcquireSemaphoreInfo(&mime_semaphore);
+  LockSemaphoreInfo(mime_semaphore);
   ResetLinkedListIterator(mime_list);
   p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
@@ -511 +511 @@
     p=(const MimeInfo *) GetNextValueInLinkedList(mime_list);
   }
-  RelinquishSemaphoreInfo(mime_semaphore);
+  UnlockSemaphoreInfo(mime_semaphore);
   qsort((void *) aliases,(size_t) i,sizeof(*aliases),MimeCompare);
   aliases[i]=(char *) NULL;
@@ -606 +606 @@
     {
       AcquireSemaphoreInfo(&mime_semaphore);
+      LockSemaphoreInfo(mime_semaphore);
       if ((mime_list == (LinkedListInfo *) NULL) &&
           (instantiate_mime == WizardFalse))
@@ -612 +613 @@
           instantiate_mime=WizardTrue;
         }
-      RelinquishSemaphoreInfo(mime_semaphore);
+      UnlockSemaphoreInfo(mime_semaphore);
     }
   return(mime_list != (LinkedListInfo *) NULL ? WizardTrue : WizardFalse);
@@ -998 +999 @@
 WizardExport WizardBooleanType MimeComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&mime_semaphore);
-  RelinquishSemaphoreInfo(mime_semaphore);
+  assert(mime_semaphore == (SemaphoreInfo *) NULL);
+  mime_semaphore=AllocateSemaphoreInfo();
   return(WizardTrue);
 }
@@ -1044 +1045 @@
 WizardExport void MimeComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&mime_semaphore);
+  if (mime_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&mime_semaphore);
+  LockSemaphoreInfo(mime_semaphore);
   if (mime_list != (LinkedListInfo *) NULL)
     mime_list=DestroyLinkedList(mime_list,DestroyMimeElement);
   instantiate_mime=WizardFalse;
-  RelinquishSemaphoreInfo(mime_semaphore);
+  UnlockSemaphoreInfo(mime_semaphore);
   DestroySemaphoreInfo(&mime_semaphore);
 }

WizardsToolkit/trunk/wizard/random.c

@@ -878 +878 @@
 WizardExport WizardBooleanType RandomComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&random_semaphore);
-  RelinquishSemaphoreInfo(random_semaphore);
+  assert(random_semaphore == (SemaphoreInfo *) NULL);
+  random_semaphore=AllocateSemaphoreInfo();
   return(WizardTrue);
 }
@@ -903 +903 @@
 WizardExport void RandomComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&random_semaphore);
-  RelinquishSemaphoreInfo(random_semaphore);
+  if (random_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&random_semaphore);
   DestroySemaphoreInfo(&random_semaphore);
 }

WizardsToolkit/trunk/wizard/resource.c

@@ -320 +320 @@
       return(-1);
     }
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   if (temporary_resources == (SplayTreeInfo *) NULL)
     temporary_resources=NewSplayTree(CompareSplayTreeString,
       RelinquishWizardMemory,DestroyTemporaryResources);
+  UnlockSemaphoreInfo(resource_semaphore);
   resource=ConstantString(filename);
   (void) AddValueToSplayTree(temporary_resources,resource,resource);
@@ -371 +375 @@
   status=WizardFalse;
   (void) FormatWizardSize(size,resource_request);
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -378 +384 @@
       resource_info.area=(WizardOffsetType) size;
       limit=resource_info.area_limit;
-      status=(resource_info.area_limit == WizardResourceInfinity) || (size < limit) ?
-        WizardTrue : WizardFalse;
+      status=(resource_info.area_limit == WizardResourceInfinity) ||
+        (size < limit) ? WizardTrue : WizardFalse;
       (void) FormatWizardSize((WizardSizeType) resource_info.area,
         resource_current);
@@ -437 +443 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   (void) LogWizardEvent(ResourceEvent,GetWizardModule(),"%s: %s/%s/%s",
     WizardOptionToMnemonic(WizardResourceOptions,(long) type),resource_request,
@@ -513 +519 @@
 
   resource=0;
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -544 +552 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   return(resource);
 }
@@ -576 +584 @@
 
   resource=0;
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -607 +617 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   return(resource);
 }
@@ -647 +657 @@
   if (file == (const FILE *) NULL)
     file=stdout;
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   (void) FormatWizardSize(resource_info.area_limit,area_limit);
   (void) FormatWizardSize(resource_info.disk_limit,disk_limit);
@@ -657 +669 @@
     resource_info.file_limit,area_limit,memory_limit,map_limit,disk_limit);
   (void) fflush(file);
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   return(WizardTrue);
 }
@@ -695 +707 @@
 
   (void) FormatWizardSize(size,resource_request);
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -742 +756 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   (void) LogWizardEvent(ResourceEvent,GetWizardModule(),"%s: %s/%s/%s",
     WizardOptionToMnemonic(WizardResourceOptions,(long) type),resource_request,
@@ -841 +855 @@
     Set Wizard resource limits.
   */
-  AcquireSemaphoreInfo(&resource_semaphore);
-  RelinquishSemaphoreInfo(resource_semaphore);
+  assert(resource_semaphore == (SemaphoreInfo *) NULL);
+  resource_semaphore=AllocateSemaphoreInfo();
   pagesize=(-1);
 #if defined(WIZARDSTOOLKIT_HAVE_SYSCONF) && defined(_SC_PAGESIZE)
@@ -923 +937 @@
 WizardExport void ResourceComponentTerminus(void)
 {
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   if (temporary_resources != (SplayTreeInfo *) NULL)
     temporary_resources=DestroySplayTree(temporary_resources);
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   DestroySemaphoreInfo(&resource_semaphore);
 }
@@ -958 +974 @@
   const WizardSizeType limit)
 {
-  AcquireSemaphoreInfo(&resource_semaphore);
+  if (resource_semaphore == (SemaphoreInfo *) NULL)
+    AcquireSemaphoreInfo(&resource_semaphore);
+  LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -989 +1007 @@
       break;
   }
-  RelinquishSemaphoreInfo(resource_semaphore);
+  UnlockSemaphoreInfo(resource_semaphore);
   return(WizardTrue);
 }

WizardsToolkit/trunk/wizard/semaphore.c

@@ -119 +119 @@
     *semaphore_info=AllocateSemaphoreInfo();
   UnlockWizardMutex();
-  (void) LockSemaphoreInfo(*semaphore_info);
 }
 

WizardsToolkit/trunk/wizard/studio.h

@@ -402 +402 @@
 #endif
 
+#if !defined(PATH_MAX)
+#define PATH_MAX  4096
+#endif
+
 /*
   I/O defines.

WizardsToolkit/trunk/wizard/wizard.c

@@ -41 +41 @@
 #include "wizard/studio.h"
 #include "wizard/client.h"
+#include "wizard/configure.h"
 #include "wizard/hash.h"
 #include "wizard/log.h"
@@ -294 +295 @@
     Initialize wizard resources.
   */
+  (void) ConfigureComponentGenesis();
   (void) ResourceComponentGenesis();
   (void) MimeComponentGenesis();