shared_source/c_tclxtens_7_5/crchashextns.c

//$Header$
//-------------------------------------------------------------------------------------------------
//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
//integrated into many of David T. Ashley's projects.
//-------------------------------------------------------------------------------------------------
//This source code and any program in which it is compiled/used is provided under the MIT License,
//reproduced below.
//-------------------------------------------------------------------------------------------------
//Permission is hereby granted, free of charge, to any person obtaining a copy of
//this software and associated documentation files(the "Software"), to deal in the
//Software without restriction, including without limitation the rights to use,
//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
//Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions :
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
//-------------------------------------------------------------------------------------------------
#define MODULE_CRCHASHEXTNS

#include <string.h>

#include "tcl.h"
#include "tcldecls.h"

#include "crchashextns.h"
#include "crchashfuncs.h"

#include "strfuncs.h"
#include "tclalloc.h"


//Procedure called when the "crc32" command is encountered in a Tcl script.
//
int CRCHASHEXTNS_Crc32extnCommand(ClientData dummy, 
                                  Tcl_Interp *interp, 
                                  int objc,
                                  Tcl_Obj *objv[]) 
   {
   Tcl_Obj *rv;
      //Value that will be returned.
   Tcl_Obj *block_obj;
      //Used for file reads.
   char buffer[11];
      //Space for "0x" followed by 8 hex chars and terminator.
   struct CRCHASHFUNCS_Crc32StateStruct crc_state;
      //CRC state structure, internals nominally known and accessible to another
      //another software module.
   unsigned long crc;
      //Calculated CRC.
   unsigned long bytearraysize;
      //Size of block allocated or portion used.
   char *bytearrayptr;
      //Pointer to array of bytes.
   char *fname;
      //File name specified.
   char *blockbuf;
      //Pointer to array of bytes.
   Tcl_Channel chan;
      //Channel opened using the Tcl libraries.
   int return_code, return_code_b;
      //Return codes from Tcl library functions.
   int loop_exit_flag;
      //Looping exit flag.
   int chars_read;
      //Number of characters read (i.e. for short read).
   int block_obj_n;


   if (objc < 2 || objc > 3)
      {
      Tcl_WrongNumArgs(interp, 
                       1, 
                       objv, 
                       "?-string? filename_or_string_value");

      return TCL_ERROR;
      }
   else if (objc == 2)
      {
      //Be sure that the internal crc table has been built.  This function
      //also returns a table correctness code.  Error out severely if the
      //CRC module believes its internal data has been corrupted.
      if (!CRCHASHFUNCS_Crc32TableCheck())
         {
         //Serious internal error.  Error out.

         //Create the return object.
         rv = Tcl_NewStringObj("CRCHASHEXTNS.C:  Serious internal error:  CRC-32 lookup table corrupted.", -1);

         //Set the return value to be the error message.
         Tcl_SetObjResult(interp, rv);

         //Error return.
         return TCL_ERROR;
         }

      //We need to open a channel, run it through the CRC algorithm, and
      //return results.

      //Get the string representation of the object.
      fname = Tcl_GetString(objv[1]);

      //Attempt to open a file channel.  The error information, if any,
      //will be placed in the interpreter's state.
      chan = Tcl_OpenFileChannel(interp, fname, "r", 0);

      //There is the possibility that the channel could not be opened
      //successfully.  If there was an error, error out.
      if (!chan)
         {
         //Create the return object.
         rv = Tcl_NewStringObj("crc32: Tcl_OpenFileChannel() failure on file name: ", -1);

         //Tack on the offensive argument.
         Tcl_AppendToObj(rv, fname, -1);

         //Set the return value to be the error message.
         Tcl_SetObjResult(interp, rv);

         //Error return.
         return TCL_ERROR;
         }

      //Try to set the channel encoding to binary and record the return code.
      return_code   = Tcl_SetChannelOption(interp, chan, "-encoding", "binary");

      //Try to set the channel translation mode to binary and record the return
      //code.
      if (return_code == TCL_OK)
         return_code_b = Tcl_SetChannelOption(interp, chan, "-translation", "binary");

      //If the attempt to set the channel encoding or translation 
      //didn't go well, error out.  Must also try to chose the channel because
      //it was successfully opened.
      if ((return_code != TCL_OK) || (return_code_b != TCL_OK))
         {
         //Try to close the channel.  "interp" not supplied so as not
         //to overwrite error info.
         Tcl_Close(NULL, chan);

         //Create the return object.
         rv = Tcl_NewStringObj("crc32: Tcl_SetChannelOption() failure.", -1);

         //Set the return value to be the error message.
         Tcl_SetObjResult(interp, rv);

         //Error return.
         return TCL_ERROR;
         }

      //Allocate the object to hold the block buffer.  I've examined the
      //function, and cannot do it with with a NULL pointer.  Must instead
      //allocate SOMETHING, although it will be destroyed immediately on
      //the first read.  This will have reference count zero.
      block_obj = Tcl_NewByteArrayObj("Trash", 5);

      //Calculate the CRC.  The essential process is to keep reading
      //and adding to the CRC until end of file.
      //Open and initialize the necessary structure.
      CRCHASHFUNCS_Crc32StateStructOpen(&crc_state);

      loop_exit_flag = 0;

      do
         {
         //Grab as many chars as possible, up to 65536 of them.
         //65536 was chosen because this is large enough for great
         //performance, but small enough that it won't make a significant
         //virtual memory impact.
         chars_read = Tcl_ReadChars(chan, block_obj, 65536, 0);

         //If the characters read shows as <0, this is an error
         //condition.  Trap.
         if (chars_read < 0)
            {
             //Try to close the channel.  "interp" not supplied so as not
            //to overwrite error info.
            Tcl_Close(NULL, chan);

            //Deallocate the buffer used to accept block file reads.  Because the
            //creation process set the reference count to zero, a single
            //decrement will destroy the object.
            Tcl_DecrRefCount(block_obj);

            //Create the return object.
            rv = Tcl_NewStringObj("crc32: Tcl_ReadChars() failure.", -1);

            //Set the return value to be the error message.
            Tcl_SetObjResult(interp, rv);

            //Error return.
            return TCL_ERROR;
            }

         //Obtain a pointer to the binary block that was read.
         blockbuf = Tcl_GetByteArrayFromObj(block_obj, &block_obj_n);

         //Add to the CRC for those chars read.  Skip the zero case.
         if (block_obj_n > 0)
            {
            CRCHASHFUNCS_Crc32StateStructAddData(&crc_state,
                                                 blockbuf,
                                                 block_obj_n);
            }

         //We want to exit if EOF is true.  A short read would
         //also be an indication, but short read should imply
         //EOF, so should not test both.
         return_code = Tcl_Eof(chan);
         loop_exit_flag = (return_code != 0);
         } while(!loop_exit_flag);

      //Extract the CRC.
      crc = CRCHASHFUNCS_Crc32Extract(&crc_state);

      //Postprocess the structure.
      CRCHASHFUNCS_Crc32StateStructClose(&crc_state);

      //Close the channel.
      return_code = Tcl_Close(interp, chan);

      //If there was an error closing the channel, error out.
      if (return_code != TCL_OK)
         {
         //Create the return object.
         rv = Tcl_NewStringObj("crc32: Tcl_Close() failure.", -1);

         //Set the return value to be the error message.
         Tcl_SetObjResult(interp, rv);

         //Error return.
         return TCL_ERROR;
         }

      //Deallocate the buffer used to accept block file reads.  Because the
      //creation process set the reference count to zero, a single
      //decrement will destroy the object.
      Tcl_DecrRefCount(block_obj);

      //Return the CRC to the caller.  No detectable errors
      //are possible at this point.

      //Convert the long integer to a hexadecimal representation.
      Strfuncs_UlToHexString(crc, buffer+2, 1);

      //Stuff the leading characters of the hexadecimal representation.
      buffer[0]  = '0';
      buffer[1]  = 'x';

      //Stuff the string terminator.
      buffer[10] =  0;

      //Create the return object.
      rv = Tcl_NewStringObj(buffer, -1);

      //Set the return value to be the hexadecimal representation of the
      //CRC.
      Tcl_SetObjResult(interp, rv);

      //Everything went well, return the OK code.
      return TCL_OK;
      }
   else /* if (objc == 3) */
      {
      //The second parameter positively must be "-string" or a substring
      //of that.  At present, there are no competing option flags, so 
      //a simple substring lookup will handle it.
      //Yank the string pointer.
      bytearrayptr = Tcl_GetString(objv[1]);

      //If not a substring, error out.
      if ((strlen(bytearrayptr)<2) || !Strfuncs_IsSubstring(bytearrayptr, "-string"))
         {
         //Create the return object.
         rv = Tcl_NewStringObj("crc32: Unrecognized switch: ", -1);

         //Tack on the offensive argument.
         Tcl_AppendToObj(rv, bytearrayptr, -1);

         //Set the return value to be the error message.
         Tcl_SetObjResult(interp, rv);

         //Error return.
         return TCL_ERROR;
         }

      //Convert the last parameter to its byte representation and get a
      //pointer to this representation and the length.  This was the 
      //library call that Ajuba recommended.
      bytearrayptr = Tcl_GetByteArrayFromObj(objv[2], &bytearraysize);

      //Be sure that the internal crc table has been built.  This function
      //also returns a table correctness code.  Error out severely if the
      //CRC module believes its internal data has been corrupted.
      if (!CRCHASHFUNCS_Crc32TableCheck())
         {
         //Serious internal error.  Error out.

         //Create the return object.
         rv = Tcl_NewStringObj("CRCHASHEXTNS.C:  Serious internal error:  CRC-32 lookup table corrupted.", -1);

         //Set the return value to be the error message.
         Tcl_SetObjResult(interp, rv);

         //Error return.
         return TCL_ERROR;
         }

      //Open and initialize the necessary structure.
      CRCHASHFUNCS_Crc32StateStructOpen(&crc_state);

      //Process the string.
      CRCHASHFUNCS_Crc32StateStructAddData(&crc_state,
                                          bytearrayptr,
                                          bytearraysize);
      //Extract the CRC.
      crc = CRCHASHFUNCS_Crc32Extract(&crc_state);

      //Postprocess the structure.
      CRCHASHFUNCS_Crc32StateStructClose(&crc_state);

      //Convert the long integer to a hexadecimal representation.
      Strfuncs_UlToHexString(crc, buffer+2, 1);

      //Stuff the leading characters of the hexadecimal representation.
      buffer[0]  = '0';
      buffer[1]  = 'x';

      //Stuff the string terminator.
      buffer[10] =  0;

      //Create the return object.
      rv = Tcl_NewStringObj(buffer, -1);

      //Set the return value to be the hexadecimal representation of the
      //CRC.
      Tcl_SetObjResult(interp, rv);

      //Everything went well, return the OK code.
      return TCL_OK;
      }
   }


//Performs initial registration to the hash table.
//
void CRCHASHEXTNS_Crc32extnInit(Tcl_Interp *interp)
   {
   //Register a command named "crc32".
   Tcl_CreateObjCommand(interp, 
                        "crc32",
                        (Tcl_ObjCmdProc *)CRCHASHEXTNS_Crc32extnCommand,
                        NULL,
                        NULL);
   }


//Returns version control string for file.
//
const char *CRCHASHEXTNS_cvcinfo(void)
{   
    return ("$Header$");
}


//Returns version control string for associated .H file.
//
const char *CRCHASHEXTNS_hvcinfo(void)
{   
    return (CRCHASHEXTNS_H_VERSION);
}

//End of crchashextns.c.
1	dashley	68	//$Header$
2	dashley	25	//-------------------------------------------------------------------------------------------------
3	dashley	68	//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
4			//integrated into many of David T. Ashley's projects.
5	dashley	25	//-------------------------------------------------------------------------------------------------
6	dashley	68	//This source code and any program in which it is compiled/used is provided under the MIT License,
7			//reproduced below.
8			//-------------------------------------------------------------------------------------------------
9			//Permission is hereby granted, free of charge, to any person obtaining a copy of
10			//this software and associated documentation files(the "Software"), to deal in the
11			//Software without restriction, including without limitation the rights to use,
12			//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
13			//Software, and to permit persons to whom the Software is furnished to do so,
14			//subject to the following conditions :
15	dashley	25	//
16	dashley	68	//The above copyright notice and this permission notice shall be included in all
17			//copies or substantial portions of the Software.
18	dashley	25	//
19	dashley	68	//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20			//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21			//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
22			//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23			//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24			//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25			//SOFTWARE.
26	dashley	25	//-------------------------------------------------------------------------------------------------
27			#define MODULE_CRCHASHEXTNS
28
29			#include <string.h>
30
31			#include "tcl.h"
32			#include "tcldecls.h"
33
34			#include "crchashextns.h"
35			#include "crchashfuncs.h"
36
37			#include "strfuncs.h"
38			#include "tclalloc.h"
39
40
41			//Procedure called when the "crc32" command is encountered in a Tcl script.
42			//
43			int CRCHASHEXTNS_Crc32extnCommand(ClientData dummy,
44			Tcl_Interp *interp,
45			int objc,
46			Tcl_Obj *objv[])
47			{
48			Tcl_Obj *rv;
49			//Value that will be returned.
50			Tcl_Obj *block_obj;
51			//Used for file reads.
52			char buffer[11];
53			//Space for "0x" followed by 8 hex chars and terminator.
54			struct CRCHASHFUNCS_Crc32StateStruct crc_state;
55			//CRC state structure, internals nominally known and accessible to another
56			//another software module.
57			unsigned long crc;
58			//Calculated CRC.
59			unsigned long bytearraysize;
60			//Size of block allocated or portion used.
61			char *bytearrayptr;
62			//Pointer to array of bytes.
63			char *fname;
64			//File name specified.
65			char *blockbuf;
66			//Pointer to array of bytes.
67			Tcl_Channel chan;
68			//Channel opened using the Tcl libraries.
69			int return_code, return_code_b;
70			//Return codes from Tcl library functions.
71			int loop_exit_flag;
72			//Looping exit flag.
73			int chars_read;
74			//Number of characters read (i.e. for short read).
75			int block_obj_n;
76
77
78			if (objc < 2 \|\| objc > 3)
79			{
80			Tcl_WrongNumArgs(interp,
81			1,
82			objv,
83			"?-string? filename_or_string_value");
84
85			return TCL_ERROR;
86			}
87			else if (objc == 2)
88			{
89			//Be sure that the internal crc table has been built. This function
90			//also returns a table correctness code. Error out severely if the
91			//CRC module believes its internal data has been corrupted.
92			if (!CRCHASHFUNCS_Crc32TableCheck())
93			{
94			//Serious internal error. Error out.
95
96			//Create the return object.
97			rv = Tcl_NewStringObj("CRCHASHEXTNS.C: Serious internal error: CRC-32 lookup table corrupted.", -1);
98
99			//Set the return value to be the error message.
100			Tcl_SetObjResult(interp, rv);
101
102			//Error return.
103			return TCL_ERROR;
104			}
105
106			//We need to open a channel, run it through the CRC algorithm, and
107			//return results.
108
109			//Get the string representation of the object.
110			fname = Tcl_GetString(objv[1]);
111
112			//Attempt to open a file channel. The error information, if any,
113			//will be placed in the interpreter's state.
114			chan = Tcl_OpenFileChannel(interp, fname, "r", 0);
115
116			//There is the possibility that the channel could not be opened
117			//successfully. If there was an error, error out.
118			if (!chan)
119			{
120			//Create the return object.
121			rv = Tcl_NewStringObj("crc32: Tcl_OpenFileChannel() failure on file name: ", -1);
122
123			//Tack on the offensive argument.
124			Tcl_AppendToObj(rv, fname, -1);
125
126			//Set the return value to be the error message.
127			Tcl_SetObjResult(interp, rv);
128
129			//Error return.
130			return TCL_ERROR;
131			}
132
133			//Try to set the channel encoding to binary and record the return code.
134			return_code = Tcl_SetChannelOption(interp, chan, "-encoding", "binary");
135
136			//Try to set the channel translation mode to binary and record the return
137			//code.
138			if (return_code == TCL_OK)
139			return_code_b = Tcl_SetChannelOption(interp, chan, "-translation", "binary");
140
141			//If the attempt to set the channel encoding or translation
142			//didn't go well, error out. Must also try to chose the channel because
143			//it was successfully opened.
144			if ((return_code != TCL_OK) \|\| (return_code_b != TCL_OK))
145			{
146			//Try to close the channel. "interp" not supplied so as not
147			//to overwrite error info.
148			Tcl_Close(NULL, chan);
149
150			//Create the return object.
151			rv = Tcl_NewStringObj("crc32: Tcl_SetChannelOption() failure.", -1);
152
153			//Set the return value to be the error message.
154			Tcl_SetObjResult(interp, rv);
155
156			//Error return.
157			return TCL_ERROR;
158			}
159
160			//Allocate the object to hold the block buffer. I've examined the
161			//function, and cannot do it with with a NULL pointer. Must instead
162			//allocate SOMETHING, although it will be destroyed immediately on
163			//the first read. This will have reference count zero.
164			block_obj = Tcl_NewByteArrayObj("Trash", 5);
165
166			//Calculate the CRC. The essential process is to keep reading
167			//and adding to the CRC until end of file.
168			//Open and initialize the necessary structure.
169			CRCHASHFUNCS_Crc32StateStructOpen(&crc_state);
170
171			loop_exit_flag = 0;
172
173			do
174			{
175			//Grab as many chars as possible, up to 65536 of them.
176			//65536 was chosen because this is large enough for great
177			//performance, but small enough that it won't make a significant
178			//virtual memory impact.
179			chars_read = Tcl_ReadChars(chan, block_obj, 65536, 0);
180
181			//If the characters read shows as <0, this is an error
182			//condition. Trap.
183			if (chars_read < 0)
184			{
185			//Try to close the channel. "interp" not supplied so as not
186			//to overwrite error info.
187			Tcl_Close(NULL, chan);
188
189			//Deallocate the buffer used to accept block file reads. Because the
190			//creation process set the reference count to zero, a single
191			//decrement will destroy the object.
192			Tcl_DecrRefCount(block_obj);
193
194			//Create the return object.
195			rv = Tcl_NewStringObj("crc32: Tcl_ReadChars() failure.", -1);
196
197			//Set the return value to be the error message.
198			Tcl_SetObjResult(interp, rv);
199
200			//Error return.
201			return TCL_ERROR;
202			}
203
204			//Obtain a pointer to the binary block that was read.
205			blockbuf = Tcl_GetByteArrayFromObj(block_obj, &block_obj_n);
206
207			//Add to the CRC for those chars read. Skip the zero case.
208			if (block_obj_n > 0)
209			{
210			CRCHASHFUNCS_Crc32StateStructAddData(&crc_state,
211			blockbuf,
212			block_obj_n);
213			}
214
215			//We want to exit if EOF is true. A short read would
216			//also be an indication, but short read should imply
217			//EOF, so should not test both.
218			return_code = Tcl_Eof(chan);
219			loop_exit_flag = (return_code != 0);
220			} while(!loop_exit_flag);
221
222			//Extract the CRC.
223			crc = CRCHASHFUNCS_Crc32Extract(&crc_state);
224
225			//Postprocess the structure.
226			CRCHASHFUNCS_Crc32StateStructClose(&crc_state);
227
228			//Close the channel.
229			return_code = Tcl_Close(interp, chan);
230
231			//If there was an error closing the channel, error out.
232			if (return_code != TCL_OK)
233			{
234			//Create the return object.
235			rv = Tcl_NewStringObj("crc32: Tcl_Close() failure.", -1);
236
237			//Set the return value to be the error message.
238			Tcl_SetObjResult(interp, rv);
239
240			//Error return.
241			return TCL_ERROR;
242			}
243
244			//Deallocate the buffer used to accept block file reads. Because the
245			//creation process set the reference count to zero, a single
246			//decrement will destroy the object.
247			Tcl_DecrRefCount(block_obj);
248
249			//Return the CRC to the caller. No detectable errors
250			//are possible at this point.
251
252			//Convert the long integer to a hexadecimal representation.
253			Strfuncs_UlToHexString(crc, buffer+2, 1);
254
255			//Stuff the leading characters of the hexadecimal representation.
256			buffer[0] = '0';
257			buffer[1] = 'x';
258
259			//Stuff the string terminator.
260			buffer[10] = 0;
261
262			//Create the return object.
263			rv = Tcl_NewStringObj(buffer, -1);
264
265			//Set the return value to be the hexadecimal representation of the
266			//CRC.
267			Tcl_SetObjResult(interp, rv);
268
269			//Everything went well, return the OK code.
270			return TCL_OK;
271			}
272			else /* if (objc == 3) */
273			{
274			//The second parameter positively must be "-string" or a substring
275			//of that. At present, there are no competing option flags, so
276			//a simple substring lookup will handle it.
277			//Yank the string pointer.
278			bytearrayptr = Tcl_GetString(objv[1]);
279
280			//If not a substring, error out.
281			if ((strlen(bytearrayptr)<2) \|\| !Strfuncs_IsSubstring(bytearrayptr, "-string"))
282			{
283			//Create the return object.
284			rv = Tcl_NewStringObj("crc32: Unrecognized switch: ", -1);
285
286			//Tack on the offensive argument.
287			Tcl_AppendToObj(rv, bytearrayptr, -1);
288
289			//Set the return value to be the error message.
290			Tcl_SetObjResult(interp, rv);
291
292			//Error return.
293			return TCL_ERROR;
294			}
295
296			//Convert the last parameter to its byte representation and get a
297			//pointer to this representation and the length. This was the
298			//library call that Ajuba recommended.
299			bytearrayptr = Tcl_GetByteArrayFromObj(objv[2], &bytearraysize);
300
301			//Be sure that the internal crc table has been built. This function
302			//also returns a table correctness code. Error out severely if the
303			//CRC module believes its internal data has been corrupted.
304			if (!CRCHASHFUNCS_Crc32TableCheck())
305			{
306			//Serious internal error. Error out.
307
308			//Create the return object.
309			rv = Tcl_NewStringObj("CRCHASHEXTNS.C: Serious internal error: CRC-32 lookup table corrupted.", -1);
310
311			//Set the return value to be the error message.
312			Tcl_SetObjResult(interp, rv);
313
314			//Error return.
315			return TCL_ERROR;
316			}
317
318			//Open and initialize the necessary structure.
319			CRCHASHFUNCS_Crc32StateStructOpen(&crc_state);
320
321			//Process the string.
322			CRCHASHFUNCS_Crc32StateStructAddData(&crc_state,
323			bytearrayptr,
324			bytearraysize);
325			//Extract the CRC.
326			crc = CRCHASHFUNCS_Crc32Extract(&crc_state);
327
328			//Postprocess the structure.
329			CRCHASHFUNCS_Crc32StateStructClose(&crc_state);
330
331			//Convert the long integer to a hexadecimal representation.
332			Strfuncs_UlToHexString(crc, buffer+2, 1);
333
334			//Stuff the leading characters of the hexadecimal representation.
335			buffer[0] = '0';
336			buffer[1] = 'x';
337
338			//Stuff the string terminator.
339			buffer[10] = 0;
340
341			//Create the return object.
342			rv = Tcl_NewStringObj(buffer, -1);
343
344			//Set the return value to be the hexadecimal representation of the
345			//CRC.
346			Tcl_SetObjResult(interp, rv);
347
348			//Everything went well, return the OK code.
349			return TCL_OK;
350			}
351			}
352
353
354			//Performs initial registration to the hash table.
355			//
356			void CRCHASHEXTNS_Crc32extnInit(Tcl_Interp *interp)
357			{
358			//Register a command named "crc32".
359			Tcl_CreateObjCommand(interp,
360			"crc32",
361			(Tcl_ObjCmdProc *)CRCHASHEXTNS_Crc32extnCommand,
362			NULL,
363			NULL);
364			}
365
366
367			//Returns version control string for file.
368			//
369			const char *CRCHASHEXTNS_cvcinfo(void)
370			{
371	dashley	68	return ("$Header$");
372	dashley	25	}
373
374
375			//Returns version control string for associated .H file.
376			//
377			const char *CRCHASHEXTNS_hvcinfo(void)
378			{
379			return (CRCHASHEXTNS_H_VERSION);
380			}
381
382	dashley	68	//End of crchashextns.c.