Реклама

  1 /******************************************************************************
  2 *
  3 * Copyright (C) 2007, The Gentee Group. All rights reserved. 
  4 * This file is part of the Gentee open source project - http://www.gentee.com. 
  5 * 
  6 * THIS  FILE IS PROVIDED UNDER THE TERMS OF THE GENTEE LICENSE ("AGREEMENT"). 
  7 * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE CONSTITUTES RECIPIENTS 
  8 * ACCEPTANCE OF THE AGREEMENT.
  9 *
 10 * Author: Alexey Krivonogov ( gentee )
 11 *
 12 ******************************************************************************/
 13 
 14 /*-----------------------------------------------------------------------------
 15 * Id: thread L "Thread"
 16 * 
 17 * Summary: This library allows you to create threads and work with them. 
 18            The methods described above are applied to variables of the 
 19            #b(thread) type. For using this library, it is required to specify
 20            the file thread.g (from lib\thread
 21            subfolder) with include command. #srcg[
 22 |include : $"...\gentee\lib\thread\thread.g"]    
 23 *
 24 * List: *#lng/methods#,thread_create,thread_getexitcode,thread_isactive,
 25         thread_resume,thread_suspend,thread_terminate,thread_wait, 
 26         *#lng/funcs#,exitthread,sleep
 27 * 
 28 -----------------------------------------------------------------------------*/
 29 
 30 define <export>
 31 {
 32    STILL_ACTIVE = 0x00000103
 33    INFINITE     = 0xFFFFFFFF
 34    WAIT_FAILED  = 0xFFFFFFFF
 35 }
 36 
 37 type thread 
 38 {
 39    uint handle
 40    uint pmem
 41 }
 42 
 43 import "kernel32.dll"
 44 {
 45    uint CreateThread( uint, uint, uint, uint, uint, uint )
 46         ExitThread( uint )
 47    uint GetExitCodeThread( uint, uint )
 48    uint GetTickCount()
 49    uint ResumeThread( uint )
 50         Sleep( uint )
 51    uint SuspendThread( uint )
 52    uint TerminateThread( uint, uint )
 53    uint WaitForSingleObject( uint, uint )
 54 }
 55 
 56 /*-----------------------------------------------------------------------------
 57 * Id: exitthread F
 58 * 
 59 * Summary: Exiting the current thread.
 60 *  
 61 * Params: code - Thread exit code.
 62 *
 63 -----------------------------------------------------------------------------*/
 64 
 65 func exitthread( uint code )
 66 {
 67    ExitThread( code )
 68 }
 69 
 70 /*-----------------------------------------------------------------------------
 71 * Id: thread_create F2
 72 * 
 73 * Summary: Create a thread.
 74 *  
 75 * Params: idfunc - The pointer to the function that will be called as a new /
 76                    thread. The function must have one parameter. You can get /
 77                    the pointer using the operator &. 
 78           param - Additional parameter. 
 79 *
 80 * Return: The handle of the created thread is returned. It returns 0 in case 
 81           of an error.
 82 *
 83 -----------------------------------------------------------------------------*/
 84 
 85 method uint thread.create( uint idfunc, uint param )
 86 {
 87    uint  id
 88    
 89    .pmem = callback( idfunc, 1 )
 90    
 91 //   return this.handle = createthread( .pmem, idfunc, param )
 92    return .handle = CreateThread( 0, 0, .pmem, param, 0, &id )
 93 }
 94 
 95 method thread.delete
 96 {
 97    if .pmem
 98    { 
 99       freecallback( .pmem )
100       .pmem = 0
101    }
102 }
103 
104 /*-----------------------------------------------------------------------------
105 * Id: thread_isactive F3
106 * 
107 * Summary: Checking if a thread is active.
108 *  
109 * Return: Returns 1 if the thread is active and 0 otherwise.
110 *
111 -----------------------------------------------------------------------------*/
112 
113 method uint thread.isactive()
114 {
115    uint result
116 
117    if GetExitCodeThread( this.handle, &result )
118    {
119       return result == $STILL_ACTIVE 
120    }
121    return 0
122 }
123 
124 /*-----------------------------------------------------------------------------
125 * Id: thread_getexitcode F2
126 * 
127 * Summary: Get the thread exit code.
128 *  
129 * Params: result - The pointer to a variable of the uint type the thread exit /
130                    code will be written to. If the thread is still active, /
131                    the value $STILL_ACTIVE will be written. 
132 *
133 * Return: #lng/retf#
134 *
135 -----------------------------------------------------------------------------*/
136 
137 method uint thread.getexitcode( uint result )
138 {
139    return GetExitCodeThread( this.handle, result )
140 }
141 
142 /*-----------------------------------------------------------------------------
143 * Id: thread_resume F3
144 * 
145 * Summary: Resuming a thread. Resume a thread paused with the 
146            #a(thread_suspend ) method.
147 *  
148 * Return: #lng/retf#
149 *
150 -----------------------------------------------------------------------------*/
151 
152 method uint thread.resume()
153 {
154    return ResumeThread( this.handle ) != 0xFFFFFFFF
155 }
156 
157 /*-----------------------------------------------------------------------------
158 * Id: thread_suspend F3
159 * 
160 * Summary: Stop a thread.
161 *  
162 * Return: #lng/retf#
163 *
164 -----------------------------------------------------------------------------*/
165 
166 method uint thread.suspend()
167 {
168    return SuspendThread( this.handle ) != 0xFFFFFFFF
169 }
170 
171 /*-----------------------------------------------------------------------------
172 * Id: thread_terminate F2
173 * 
174 * Summary: Terminating a thread.
175 *  
176 * Params: code - Thread termination code. 
177 *
178 * Return: #lng/retf#
179 *
180 -----------------------------------------------------------------------------*/
181 
182 method uint thread.terminate( uint code )
183 {
184    this.delete()
185    return TerminateThread( this.handle, code )
186 }
187 
188 /*-----------------------------------------------------------------------------
189 * Id: sleep F
190 * 
191 * Summary: Pause the current thread for the specified time. 
192 *  
193 * Params: msec - The time for pausing the thread in milliseconds.  
194 *
195 * Return: #lng/retf#
196 *
197 -----------------------------------------------------------------------------*/
198 
199 func sleep( uint msec )
200 {
201    Sleep( msec )
202 }
203 
204 /*-----------------------------------------------------------------------------
205 ** Id: thread_wait F3
206 * 
207 * Summary: Waiting till a thread is exited.
208 *
209 * Return: #lng/retf#
210 *
211 -----------------------------------------------------------------------------*/
212 
213 method uint thread.wait()
214 {
215    return WaitForSingleObject( this.handle, $INFINITE ) != $WAIT_FAILED
216 }
217