Context Navigation

source: trunk/src/helpers/tmsgfile.c@ 13

Visit:

Last change on this file since 13 was 13, checked in by umoeller, 25 years ago
Updates for V0.9.6.
Property svn:eol-style set to `CRLF` Property svn:keywords set to `Author Date Id Revision`
File size: 29.6 KB

Line
1
2	/*
3	*@@sourcefile tmsgfile.c:
4	* contains a "text message file" helper function,
5	* which works similar to DosGetMessage. See
6	* tmfGetMessage for details.
7	*
8	* tmfGetMessage operates on plain-text ".TMF" files.
9	* The file is "compiled" into the file's extended
10	* attributes for faster access after the first access.
11	* When the file's contents change, the EAs are recompiled
12	* automatically.
13	*
14	* This has the following advantages over DosGetMessage:
15	*
16	* 1) No external utility is necessary to change message
17	* files. Simply edit the text, and on the next call,
18	* the file is recompiled at run-time.
19	*
20	* 2) To identify messages, any string can be used, not
21	* only numerical IDs.
22	*
23	* This file is entirely new with V0.9.0.
24	*
25	* Usage: All OS/2 programs.
26	*
27	* Function prefixes:
28	* -- tmf* text message file functions
29	*
30	* This code uses only C standard library functions
31	* which are also part of the subsystem libraries.
32	* It does _not_ use the fopen etc. functions, but
33	* DosOpen etc. instead.
34	* You can therefore use this code with your software
35	* which uses the subsystem libraries only.
36	*
37	* This code was kindly provided by Christian Langanke.
38	* Modifications April 1999 by Ulrich Mller. Any
39	* substantial changes (other than comments and
40	* formatting) are marked with (*UM).
41	*
42	* Note: Version numbering in this file relates to XWorkplace version
43	* numbering.
44	*
45	*@@header "helpers\tmsgfile.h"
46	*@@added V0.9.0 [umoeller]
47	*/
48
49	/*
50	* Copyright (C) 1999 Christian Langanke.
51	* Copyright (C) 1999-2000 Ulrich Mller.
52	* This file is part of the XWorkplace source package.
53	* XWorkplace is free software; you can redistribute it and/or modify
54	* it under the terms of the GNU General Public License as published
55	* by the Free Software Foundation, in version 2 as it comes in the
56	* "COPYING" file of the XWorkplace main distribution.
57	* This program is distributed in the hope that it will be useful,
58	* but WITHOUT ANY WARRANTY; without even the implied warranty of
59	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
60	* GNU General Public License for more details.
61	*/
62
63	#define OS2EMX_PLAIN_CHAR
64	// this is needed for "os2emx.h"; if this is defined,
65	// emx will define PSZ as _signed_ char, otherwise
66	// as unsigned char
67
68	#define INCL_DOS
69	#define INCL_ERRORS
70	#include <os2.h>
71
72	#include <stdio.h>
73	#include <stdlib.h>
74	#include <string.h>
75	#include <stdarg.h>
76
77	#include "setup.h" // code generation and debugging options
78
79	#include "helpers\eah.h"
80	#include "helpers\tmsgfile.h"
81
82	/*
83	*@@category: Helpers\Control program helpers\Text message files (TMF)
84	*/
85
86	/* ******************************************************************
87	* *
88	* Declarations *
89	* *
90	********************************************************************/
91
92	// extended attribute used for timestamp; written to .TMF file
93	#define EA_TIMESTAMP "TMF.FILEINFO"
94	// extended attribute used for compiled text file; written to .TMF file
95	#define EA_MSGTABLE "TMF.MSGTABLE"
96
97	#define NEWLINE "\n"
98
99	// start-of-msgid marker
100	#define MSG_NAME_START "\r\n<--"
101	// end-of-msgid marker
102	#define MSG_NAME_END "-->:" // fixed: the space had to be removed, because
103	// if a newline was the first character after ":",
104	// we got complete garbage (crashes) (99-10-23) [umoeller]
105	// comment marker
106	#define MSG_COMMENT_LINE "\r\n;"
107
108	// internal prototypes
109	APIRET CompileMsgTable(PSZ pszMessageFile, PBYTE * ppbTableData);
110	APIRET GetTimeStamp(PFILESTATUS3 pfs3, PSZ pszBuffer, ULONG ulBufferlen);
111
112	/* ******************************************************************
113	* *
114	* Text Message File Code *
115	* *
116	********************************************************************/
117
118	/*
119	*@@ tmfGetMessage:
120	* just like DosGetMessage, except that this does not
121	* take a simple message number for the message in the
122	* given message file, but a PSZ message identifier
123	* (pszMessageName).
124	*
125	* This function automatically compiles the given .TMF
126	* file into the file's extended attributes, if we find
127	* that this is necessary, by calling CompileMsgTable.
128	*
129	* Note that for compatibily, this function performs the
130	* same brain-dead string processing as DosGetMessage, that
131	* is, the return string is _not_ null-terminated, and
132	* trailing newline characters are _not_ cut off.
133	*
134	* If you don't like this, call tmfGetMessageExt, which
135	* calls this function in turn.
136	*
137	* <B>Returns:</B>
138	* -- ERROR_INVALID_PARAMETER
139	* -- ERROR_BUFFER_OVERFLOW
140	* -- ERROR_MR_MID_NOT_FOUND
141	* -- ERROR_MR_INV_MSGF_FORMAT
142	* -- ERROR_BUFFER_OVERFLOW
143	*
144	* plus the error codes of DosOpen, DosRead, DosClose.
145	*/
146
147	APIRET tmfGetMessage(PCHAR* pTable, // in: pointer table for string insertion
148	ULONG cTable, // in: number of pointers in *pTable
149	PBYTE pbBuffer, // out: returned string
150	ULONG cbBuffer, // out: sizeof(*pbBuffer)
151	PSZ pszMessageName, // in: message identifier
152	PSZ pszFile, // in: message file (.TMF extension proposed)
153	PULONG pcbMsg) // out: bytes written to *pbBuffer
154	{
155	// fixed UM 99-10-22: now initializing all vars to 0,
156	// because ulBytesRead might be returned from this func
157	APIRET rc = NO_ERROR;
158	CHAR szMessageFile[_MAX_PATH];
159	PBYTE pbTableData = NULL;
160	PSZ pszEntry = 0;
161	PSZ pszEndOfEntry = 0;
162	ULONG ulMessagePos = 0;
163	ULONG ulMessageLen = 0;
164
165	HFILE hfile = NULLHANDLE;
166	ULONG ulFilePtr = 0;
167	ULONG ulAction = 0;
168	ULONG ulBytesToRead = 0;
169	ULONG ulBytesRead = 0;
170
171	do
172	{
173	// check parms
174	if ((!pbBuffer) \|\|
175	(!cbBuffer) \|\|
176	(!pszMessageName) \|\|
177	(!*pszMessageName) \|\|
178	(!*pszFile))
179	{
180	rc = ERROR_INVALID_PARAMETER;
181	break;
182	}
183
184	if (cbBuffer < 2)
185	{
186	rc = ERROR_BUFFER_OVERFLOW;
187	break;
188	}
189
190	// search file
191	if ((strchr(pszFile, ':')) \|\|
192	(strchr(pszFile, '\\')) \|\|
193	(strchr(pszFile, '/')))
194	// drive and/or path given: no search in path
195	strcpy(szMessageFile, pszFile);
196	else
197	{
198	// only filename, search in current dir and DPATH
199	rc = DosSearchPath(SEARCH_IGNORENETERRS
200	\| SEARCH_ENVIRONMENT
201	\| SEARCH_CUR_DIRECTORY,
202	"DPATH",
203	pszFile,
204	szMessageFile,
205	sizeof(szMessageFile));
206	if (rc != NO_ERROR)
207	break;
208	}
209
210	// _Pmpf(("tmfGetMessage: Found %s", szMessageFile));
211
212	// compile table if neccessary
213	rc = CompileMsgTable(szMessageFile, &pbTableData);
214	if (rc != NO_ERROR)
215	break;
216
217	// _Pmpf(("tmfGetMessage: Now searching compiled file"));
218
219	// search the name
220	pszEntry = strstr(pbTableData, pszMessageName);
221	if (!pszEntry)
222	{
223	rc = ERROR_MR_MID_NOT_FOUND;
224	break;
225	}
226	else
227	pszEntry += strlen(pszMessageName) + 1;
228
229	// isolate entry
230	pszEndOfEntry = strchr(pszEntry, '\n');
231	if (pszEndOfEntry)
232	*pszEndOfEntry = 0;
233
234	// get numbers
235	ulMessagePos = atol(pszEntry);
236	if (ulMessagePos == 0)
237	if (!pszEntry)
238	{
239	rc = ERROR_MR_INV_MSGF_FORMAT;
240	break;
241	}
242
243	pszEntry = strchr(pszEntry, ' ');
244	if (!pszEntry)
245	{
246	rc = ERROR_MR_INV_MSGF_FORMAT;
247	break;
248	}
249	ulMessageLen = atol(pszEntry);
250
251	// determine maximum read len
252	ulBytesToRead = _min(ulMessageLen, cbBuffer);
253
254	// open file and read message
255	rc = DosOpen(pszFile,
256	&hfile,
257	&ulAction,
258	0, 0,
259	OPEN_ACTION_FAIL_IF_NEW
260	\| OPEN_ACTION_OPEN_IF_EXISTS,
261	OPEN_FLAGS_FAIL_ON_ERROR
262	\| OPEN_SHARE_DENYWRITE
263	\| OPEN_ACCESS_READONLY,
264	NULL);
265	if (rc != NO_ERROR)
266	break;
267
268	rc = DosSetFilePtr(hfile, ulMessagePos, FILE_BEGIN, &ulFilePtr);
269	if ((rc != NO_ERROR) \|\| (ulFilePtr != ulMessagePos))
270	break;
271
272	rc = DosRead(hfile,
273	pbBuffer,
274	ulBytesToRead,
275	&ulBytesRead);
276	if (rc != NO_ERROR)
277	break;
278
279	// report "buffer too small" here
280	if (ulBytesToRead < ulMessageLen)
281	rc = ERROR_BUFFER_OVERFLOW;
282
283	}
284	while (FALSE);
285
286	// replace string placeholders ("%1" etc.) (*UM)
287	if (rc == NO_ERROR) // added (99-10-24) [umoeller]
288	if (cTable)
289	{
290	// create a temporary buffer for replacements
291	PSZ pszTemp = (PSZ)malloc(cbBuffer); // ### memory leak here!
292
293	if (!pszTemp)
294	rc = ERROR_NOT_ENOUGH_MEMORY;
295	else
296	{
297	// two pointers for copying
298	PSZ pSource = pbBuffer,
299	pTarget = pszTemp;
300
301	CHAR szMsgNum[5] = "0";
302	ULONG ulTableIndex = 0;
303
304	ULONG ulCount = 0, ulTargetWritten = 0;
305
306	// 1) copy the stuff we've read to the
307	// new temporary buffer
308	for (ulCount = 0;
309	ulCount < ulBytesRead;
310	ulCount++)
311	pTarget++ = pSource++;
312
313	// 2) now go thru the source string
314	// (which we've read above) and
315	// look for "%" characters; we do
316	// this while copying the stuff
317	// back to pbBuffer
318
319	pSource = pszTemp;
320	pTarget = pbBuffer;
321
322	for (ulCount = 0;
323	ulCount < ulBytesRead;
324	ulCount++)
325	{
326	if (*pSource == '%')
327	{
328	// copy the index (should be > 0)
329	szMsgNum[0] = *(pSource + 1);
330	// szMsgNum[1] is still 0
331
332	// Pmpf((" Found %s", szMsgNum));
333
334	ulTableIndex = atoi(szMsgNum);
335	// _Pmpf((" --> %d", ulTableIndex));
336	if ((ulTableIndex != 0)
337	&& (ulTableIndex <= cTable)
338	)
339	{
340	// valid index:
341	// insert stuff from table
342	PSZ ppTableThis = (PSZ)(pTable + (ulTableIndex - 1));
343
344	// (pTable) if 1, (pTable+1) if 2, ...
345	PSZ pTableSource = *ppTableThis;
346
347	// copy string from table
348	// and increase the target pointer
349	while ((pTarget++ = pTableSource++))
350	ulTargetWritten++;
351
352	// increase source pointer to point
353	// behind the "%x"
354	pSource += 2;
355	// decrease target again, because
356	// we've copied a null-byte
357	pTarget--;
358
359	ulCount++;
360	// next for
361	continue;
362	}
363	// else invalid index: just copy
364	}
365
366	// regular character: copy
367	pTarget++ = pSource++;
368	ulTargetWritten++;
369	} // end for (ulCount = 0) ...
370
371	ulBytesRead = ulTargetWritten;
372	}
373	} // end if (cTable)
374
375	// report bytes written (*UM)
376	if (pcbMsg)
377	*pcbMsg = ulBytesRead;
378
379	// cleanup
380	if (hfile)
381	DosClose(hfile);
382	if (pbTableData)
383	free(pbTableData);
384
385	return (rc);
386	}
387
388	/*
389	*@@ tmfGetMessageExt:
390	* just like tmfGetMessage, but this func is smart
391	* enough to return a zero-terminated string and
392	* strip trailing newlines.
393	*
394	* See tmfGetMessage for details.
395	*/
396
397	APIRET tmfGetMessageExt(PCHAR* pTable, // in: pointer table for string insertion
398	ULONG cTable, // in: number of pointers in *pTable
399	PBYTE pbBuffer, // out: returned string
400	ULONG cbBuffer, // out: sizeof(*pbBuffer)
401	PSZ pszMessageName, // in: message identifier
402	PSZ pszFile, // in: message file (.TMF extension proposed)
403	PULONG pcbMsg) // out: bytes written to *pbBuffer
404	{
405	APIRET arc = NO_ERROR;
406	ULONG cbReturned = 0;
407	arc = tmfGetMessage(pTable, cTable, pbBuffer, cbBuffer, pszMessageName, pszFile,
408	&cbReturned);
409
410	if (arc == NO_ERROR)
411	{
412	PSZ p = pbBuffer;
413
414	// terminate string
415	if (cbReturned < cbBuffer)
416	*(pbBuffer+cbReturned) = 0;
417	else
418	*(pbBuffer+cbBuffer-1) = 0;
419
420	// remove leading spaces (99-10-24) [umoeller]
421	while (*p == ' ')
422	p++;
423	if (p != pbBuffer)
424	{
425	// we have leading spaces:
426	strcpy(pbBuffer, p);
427	// decrease byte count
428	cbReturned -= (p - pbBuffer);
429	}
430
431	// remove trailing newlines
432	while (TRUE)
433	{
434	p = pbBuffer + strlen(pbBuffer) - 1;
435	if ( (*p == '\n')
436	\|\| (*p == '\r')
437	)
438	{
439	*p = '\0';
440	} else
441	break; // while (TRUE)
442	}
443	}
444
445	if (pcbMsg)
446	*pcbMsg = cbReturned;
447
448	return (arc);
449	}
450
451	/*
452	*@@ CompileMsgTable:
453	* this gets called from tmfGetMessage.
454	* Here we check for whether the given
455	* message file has been compiled to the
456	* EAs yet or if the compilation is
457	* outdated.
458	*
459	* If we need recompilation, we do this here.
460	* Memory for the compiled message table is
461	* allocated here using malloc(), and the
462	* buffer is stored in ppbTableData. You
463	* must free() this buffer after using this
464	* function.
465	*
466	* <B>Returns:</B>
467	* -- ERROR_INVALID_PARAMETER
468	* -- ERROR_BUFFER_OVERFLOW
469	* -- ERROR_NOT_ENOUGH_MEMORY
470	* -- ERROR_READ_FAULT
471	* -- ERROR_INVALID_DATA
472	*
473	*@@changed V0.9.1 (99-12-12) [umoeller]: fixed heap overwrites which caused irregular crashes
474	*@@changed V0.9.1 (99-12-12) [umoeller]: fixed realloc failure
475	*@@changed V0.9.1 (99-12-12) [umoeller]: file last-write date is now reset when EAs are written
476	*@@changed V0.9.1 (2000-02-01) [umoeller]: now skipping leading spaces in msg
477	*/
478
479	APIRET CompileMsgTable(PSZ pszMessageFile, // in: file to compile
480	PBYTE *ppbTableDataReturn) // out: compiled message table
481	{
482	APIRET rc = NO_ERROR;
483	// CHAR szMessageFile[_MAX_PATH];
484
485	FILESTATUS3 fs3MessageFile;
486
487	// fixed UM 99-10-22: initializing all vars to 0
488	ULONG ulStampLength = 0;
489	PBYTE pbFileData = NULL;
490	ULONG ulFileDataLength = 0;
491
492	CHAR szFileStampOld[18] = ""; // yyyymmddhhmmssms.
493
494	CHAR szFileStampCurrent[18] = "";
495
496	PBYTE pbTableData = NULL;
497	ULONG cbTableDataAllocated = 0;
498	ULONG cbTableDataUsed = 0;
499
500	HFILE hfileMessageFile = NULLHANDLE;
501	ULONG ulAction = 0;
502	ULONG ulBytesRead = 0;
503
504	COUNTRYCODE cc = {0, 0};
505
506	ULONG cbOpenTag = strlen(MSG_NAME_START);
507	ULONG cbClosingTag = strlen(MSG_NAME_END);
508
509	do
510	{
511	PSZ pCurrentNameStart = 0;
512	PSZ pCurrentNameEnd = 0;
513	ULONG ulCurrentMessagePos = 0;
514	ULONG ulCurrentMessageLen = 0;
515	// BOOL fError = FALSE;
516
517	// check parms
518	if ((!pszMessageFile) \|\|
519	(!ppbTableDataReturn))
520	{
521	rc = ERROR_INVALID_PARAMETER;
522	break;
523	}
524
525	// get length and timestamp of file
526	rc = DosQueryPathInfo(pszMessageFile,
527	FIL_STANDARD,
528	&fs3MessageFile,
529	sizeof(fs3MessageFile));
530	if (rc != NO_ERROR)
531	break;
532	ulFileDataLength = fs3MessageFile.cbFile;
533
534	// determine current timestamp
535	GetTimeStamp(&fs3MessageFile, szFileStampCurrent, sizeof(szFileStampCurrent));
536
537	_Pmpf((" Timestamp for %s: '%s'", pszMessageFile, szFileStampCurrent));
538
539	// determine saved timestamp
540	ulStampLength = sizeof(szFileStampOld);
541	rc = eahReadStringEA(pszMessageFile,
542	EA_TIMESTAMP,
543	szFileStampOld,
544	&ulStampLength);
545
546	_Pmpf((" Saved timestamp for %s: '%s'", pszMessageFile, szFileStampOld));
547
548	// compare timestamps
549	if ((rc == NO_ERROR)
550	&& (ulStampLength == (strlen(szFileStampCurrent) + 1))
551	&& (!strcmp(szFileStampCurrent, szFileStampOld))
552	)
553	{
554
555	// read table out of EAs
556	do
557	{
558	// get ea length of table
559	rc = eahReadStringEA(pszMessageFile,
560	EA_MSGTABLE,
561	NULL, &cbTableDataAllocated);
562	if (rc != ERROR_BUFFER_OVERFLOW)
563	break;
564
565	// get memory
566	if ((pbTableData = (PBYTE)malloc(cbTableDataAllocated)) == NULL)
567	{
568	rc = ERROR_NOT_ENOUGH_MEMORY;
569	break;
570	}
571
572	// read table
573	rc = eahReadStringEA(pszMessageFile,
574	EA_MSGTABLE,
575	pbTableData, &cbTableDataAllocated);
576
577	}
578	while (FALSE);
579
580	// if no error occurred, we are finished
581	if (rc == NO_ERROR)
582	{
583	_Pmpf((" --> using precompiled table"));
584	break;
585	}
586	} // end if
587
588	_Pmpf((" --> recompiling table"));
589
590	// recompilation needed:
591	// get memory for file data
592	if ((pbFileData = (PBYTE)malloc(ulFileDataLength + 1)) == NULL)
593	{
594	rc = ERROR_NOT_ENOUGH_MEMORY;
595	break;
596	}
597	*(pbFileData + ulFileDataLength) = 0;
598
599	// get memory for table data
600	cbTableDataAllocated = ulFileDataLength / 2;
601	if ((pbTableData = (PBYTE)malloc(cbTableDataAllocated)) == NULL)
602	{
603	rc = ERROR_NOT_ENOUGH_MEMORY;
604	break;
605	}
606
607	*pbTableData = 0;
608	// fixed V0.9.1 (99-12-12);
609	// this was
610	// *(pbTableData + cbTableDataAllocated) = 0;
611	// since we're using "strcat" below to write into
612	// the table data, this wasn't such a good idea
613
614	// open file and read it
615	rc = DosOpen(pszMessageFile,
616	&hfileMessageFile,
617	&ulAction,
618	0, 0,
619	OPEN_ACTION_FAIL_IF_NEW
620	\| OPEN_ACTION_OPEN_IF_EXISTS,
621	OPEN_FLAGS_FAIL_ON_ERROR
622	\| OPEN_SHARE_DENYWRITE
623	\| OPEN_ACCESS_READWRITE, // needed for EA attachement
624	NULL);
625	if (rc != NO_ERROR)
626	break;
627
628	rc = DosRead(hfileMessageFile,
629	pbFileData,
630	ulFileDataLength,
631	&ulBytesRead);
632	if (rc != NO_ERROR)
633	break;
634	if (ulBytesRead != ulFileDataLength)
635	{
636	rc = ERROR_READ_FAULT;
637	break;
638	}
639
640	// search first message name
641	// this will automatically skip comments
642	// at the beginning
643	pCurrentNameStart = strstr(pbFileData, MSG_NAME_START);
644
645	if (!pCurrentNameStart)
646	{
647	rc = ERROR_INVALID_DATA;
648	break;
649	}
650	else
651	pCurrentNameStart += cbOpenTag;
652	// this points to message ID string after "<--" now
653
654	// is first name complete ?
655	pCurrentNameEnd = strstr(pCurrentNameStart, MSG_NAME_END);
656	if (!pCurrentNameEnd)
657	{
658	rc = ERROR_INVALID_DATA;
659	break;
660	}
661
662	// scan through all names
663	while ( (pCurrentNameStart)
664	&& (*pCurrentNameStart)
665	)
666	{
667	PSZ pNextNameStart = 0,
668	pNextCommentStart = 0,
669	pEndOfMsg = 0;
670	CHAR szEntry[500] = "";
671
672	// search end of name, if not exist, skip end of file
673	pCurrentNameEnd = strstr(pCurrentNameStart, MSG_NAME_END);
674	// this points to the closing "-->" now
675	if (!pCurrentNameEnd)
676	break;
677
678	// search next name (ID), if none, use end of string
679	pNextNameStart = strstr(pCurrentNameEnd, MSG_NAME_START);
680	// points to next "<--" now
681	if (!pNextNameStart)
682	// not found:
683	// use terminating null byte
684	pNextNameStart = pCurrentNameStart + strlen(pCurrentNameStart);
685	else
686	// found:
687	// point to next message ID string
688	pNextNameStart += cbOpenTag;
689
690	pEndOfMsg = pNextNameStart - cbOpenTag;
691
692	// search next comment (99-11-28) [umoeller]
693	pNextCommentStart = strstr(pCurrentNameEnd, MSG_COMMENT_LINE);
694	if (pNextCommentStart)
695	// another comment found:
696	if (pNextCommentStart < pNextNameStart)
697	// if it's even before the next key, use that
698	// for the end of the current string; otherwise
699	// the comment would appear in the message too
700	pEndOfMsg = pNextCommentStart;
701
702	// now we have:
703	// -- pCurrentNameStart: points to message ID after "<--"
704	// -- pCurrentNameEnd: points to "-->"
705	// -- pNextNameStart: points to _next_ message ID after "<--"
706	// -- pNextCommentStart: points to _next_ comment
707	// -- pEndOfMsg: either pNextNameStart-cbOpenTag
708	// or pNextCommentStart,
709	// whichever comes first
710
711	// calculate table entry data
712	*pCurrentNameEnd = 0;
713	ulCurrentMessagePos = (pCurrentNameEnd - pbFileData) + cbClosingTag;
714	// this points to the first character after the <-- --> tag now;
715	// if this points to a space character, take next char
716	// (V0.9.1 (2000-02-13) [umoeller])
717	while ( (*(pbFileData + ulCurrentMessagePos))
718	&& (*(pbFileData + ulCurrentMessagePos) == ' ')
719	)
720	ulCurrentMessagePos++;
721
722	ulCurrentMessageLen = (pEndOfMsg - pbFileData) - ulCurrentMessagePos;
723	// pszNextNameStart - pbFileData - ulCurrentMessagePos - 1;
724
725	// determine entry
726	sprintf(szEntry, "%s %lu %lu" NEWLINE,
727	pCurrentNameStart,
728	ulCurrentMessagePos,
729	ulCurrentMessageLen);
730
731	_Pmpf(("Found %s at %d, length %d",
732	pCurrentNameStart,
733	ulCurrentMessagePos,
734	ulCurrentMessageLen));
735
736	// need more space ?
737	if ((cbTableDataUsed + strlen(szEntry) + 1) > cbTableDataAllocated)
738	{
739	PBYTE pbTmp;
740	_Pmpf((" Re-allocating!!"));
741
742	cbTableDataAllocated += ulFileDataLength / 2;
743	pbTmp = (PBYTE)realloc(pbTableData, cbTableDataAllocated);
744	if (!pbTmp)
745	{
746	rc = ERROR_NOT_ENOUGH_MEMORY;
747	break;
748	}
749	else
750	pbTableData = pbTmp;
751	}
752
753	// add entry
754	strcat(pbTableData, szEntry);
755	cbTableDataUsed += strlen(szEntry);
756	// added V0.9.1 (99-12-12);
757	// this was 0 all the time and never raised
758
759	// adress next entry
760	pCurrentNameStart = pNextNameStart;
761
762	} // while (pszCurrentNameStart)
763
764	// write new timestamp and table
765	// ### handle 64 kb limit here !!!
766	if (rc == NO_ERROR)
767	{
768	FILESTATUS3 fs3Tmp;
769
770	rc = eahWriteStringEA(hfileMessageFile, EA_TIMESTAMP, szFileStampCurrent);
771	rc = eahWriteStringEA(hfileMessageFile, EA_MSGTABLE, pbTableData);
772
773	if (rc == NO_ERROR)
774	{
775	// fixed V0.9.1 (99-12-12): we need to reset the file date to
776	// the old date,
777	// because writing EAs updates the "last write date" also;
778	// without this, we'd recompile every single time
779	rc = DosQueryFileInfo(hfileMessageFile,
780	FIL_STANDARD,
781	&fs3Tmp,
782	sizeof(fs3Tmp));
783	if (rc == NO_ERROR)
784	{
785	// restore original "last write" date
786	_Pmpf(("Resetting file date"));
787	fs3Tmp.fdateLastWrite = fs3MessageFile.fdateLastWrite;
788	fs3Tmp.ftimeLastWrite = fs3MessageFile.ftimeLastWrite;
789	DosSetFileInfo(hfileMessageFile,
790	FIL_STANDARD,
791	&fs3Tmp,
792	sizeof(fs3Tmp));
793	}
794	}
795	}
796	} while (FALSE);
797
798
799	if (rc == NO_ERROR)
800	{
801	// hand over result
802	*ppbTableDataReturn = pbTableData;
803
804	// make text uppercase
805	rc = DosMapCase(cbTableDataAllocated, &cc, pbTableData);
806	}
807	else
808	{
809	// error occured:
810	if (pbTableData)
811	free(pbTableData);
812	}
813
814	// cleanup
815	if (pbFileData)
816	free(pbFileData);
817	if (hfileMessageFile)
818	DosClose(hfileMessageFile);
819
820	return rc;
821	}
822
823	/*
824	* GetTimeStamp:
825	* this returns the "last write date" timestamp
826	* of the file specified in pfs3.
827	*
828	* <B>Usage:</B> called from CompileMsgTable
829	* to check whether the compilation is
830	* outdated.
831	*
832	* Returns:
833	* -- NO_ERROR
834	* -- ERROR_INVALID_PARAMETER
835	* -- ERROR_BUFFER_OVERFLOW: pszBuffer too small for timestamp
836	*/
837
838	APIRET GetTimeStamp(PFILESTATUS3 pfs3, // in: file to check
839	PSZ pszBuffer, // out: timestamp
840	ULONG ulBufferlen) // in: sizeof(*pszBuffer)
841	{
842
843	APIRET rc = NO_ERROR;
844	CHAR szTimeStamp[15];
845	static PSZ pszFormatTimestamp = "%4u%02u%02u%02u%02u%02u%";
846
847	do
848	{
849	// check parms
850	if ((!pfs3) \|\|
851	(!pszBuffer))
852	{
853	rc = ERROR_INVALID_PARAMETER;
854	break;
855	}
856
857	// create stamp
858	sprintf(szTimeStamp,
859	pszFormatTimestamp,
860	pfs3->fdateLastWrite.year + 1980,
861	pfs3->fdateLastWrite.month,
862	pfs3->fdateLastWrite.day,
863	pfs3->ftimeLastWrite.hours,
864	pfs3->ftimeLastWrite.minutes,
865	pfs3->ftimeLastWrite.twosecs * 2);
866
867	// check bufferlen
868	if (strlen(szTimeStamp) + 1 > ulBufferlen)
869	{
870	rc = ERROR_BUFFER_OVERFLOW;
871	break;
872	}
873
874	// hand over result
875	strcpy(pszBuffer, szTimeStamp);
876	}
877	while (FALSE);
878
879	return rc;
880	}
881

Note: See TracBrowser for help on using the repository browser.

Download in other formats: