Context Navigation

source: trunk/dll/avl.c@ 1750

Visit:

Last change on this file since 1750 was 1750, checked in by John Small, 12 years ago

Ticket #524: Made "searchapath" thread-safe. Function names and signatures were changed.

So calls to these functions, direct and indirect, had to be changed.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 37.4 KB

Line
1
2	/***********************************************************************
3
4	$Id: avl.c 1750 2014-03-01 13:55:57Z jbs $
5
6	archiver.bb2 search, load, save and date parse
7
8	Copyright (c) 1993, 1998 M. Kimes
9	Copyright (c) 2004, 2008 Steven H.Levine
10
11	01 Aug 04 SHL Rework lstrip/rstrip usage
12	13 Aug 05 SHL Beautify with indent
13	13 Aug 05 SHL find_type: correct no sig exists bypass logic
14	13 Aug 05 SHL SBoxDlgProc: avoid dereferencing NULL signature
15	18 Aug 05 SHL Comments
16	31 Dec 05 SHL indent -i2
17	08 Dec 05 SHL load_archivers: allow empty startlist
18	30 Dec 05 SHL load_archivers: use get_archiver_line?(), clean nits
19	29 May 06 SHL SBoxDlgProc: support move, add, delete
20	30 May 06 SHL load_archivers: add reload support
21	16 Jun 06 SHL load_archivers: support signatures containing 0s
22	26 Jun 06 SHL load_archivers: remember where comments are
23	14 Jul 06 SHL Use Runtime_Error
24	29 Jul 06 SHL Use xfgets, xfgets_bstripcr
25	15 Aug 06 SHL Use Runtime_Error more
26	01 Nov 06 SHL Turn off leftover debug code
27	06 Apr 07 GKY Work around PM DragInfo and DrgFreeDISH limit
28	19 Apr 07 SHL Use FreeDragInfoData
29	19 Apr 07 SHL Add more drag/drop error checking
30	20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
31	25 Aug 07 SHL load_archivers: add missing close on error path
32	29 Feb 08 GKY Use xfree where appropriate
33	22 Jun 08 GKY Added free_archivers for fortify checking
34	19 Jul 08 GKY ifdef Fortify free_archivers
35	29 Nov 08 GKY Add ini entry for LastArchiver so the previous archiver is selected in the
36	Select archive dialog if no default is provided.
37	29 Nov 08 GKY Remove or replace with a mutex semaphore DosEnterCriSec where appropriate.
38	11 Jan 08 GKY Replace "ARCHIVER.BB2" in string file with global set at compile in init.c
39	08 Mar 09 GKY Additional strings move to PCSZs in init.c
40	23 Oct 10 GKY Changes to populate and utilize a HELPTABLE for context specific help
41	21 Nov 10 GKY Check if archiver.bb2 has been changed on disk before editing
42	13 Aug 11 GKY Change to Doxygen comment format
43	26 Aug 11 GKY Add the code to correctly format the date time strings for tar.gz archives
44	viewed using tar 1.15+
45	01 Mar 14 JBS Ticket #524: Made "searchapath" thread-safe. Function names and signatures were changed.
46	So calls to these functions had to be changed.
47
48	***********************************************************************/
49
50	#include <stdlib.h>
51	#include <string.h>
52	#include <ctype.h>
53	#include <share.h>
54	#include <sys/stat.h>
55
56	#define INCL_DOS
57	#define INCL_WIN
58	#define INCL_WINSTDDRAG
59	#define INCL_LONGLONG
60
61	#include "fm3dll.h"
62	#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
63	#include "notebook.h" // Data declaration(s)
64	#include "init.h" // Data declaration(s)
65	#include "valid.h" // Data declaration(s)
66	#include "mainwnd.h" // Data declaration(s)
67	#include "fm3dlg.h"
68	#include "fm3str.h"
69	#include "avl.h"
70	#include "strutil.h" // GetPString
71	#include "errutil.h" // Runtime_Error
72	#include "avv.h" // ArcReviewDlgProc, rewrite_archiverbb2
73	#include "droplist.h" // DropHelp, FullDrgName
74	#include "misc.h" // DrawTargetEmphasis
75	#include "draglist.h" // FreeDragInfoData
76	#include "chklist.h" // PosOverOkay
77	#include "literal.h" // literal
78	#include "wrappers.h" // xfgets
79	#include "strips.h" // bstrip
80	#include "srchpath.h" // SearchPathForFile
81	#include "stristr.h" // stristr
82	#include "delims.h" // to_delim
83	#include "fortify.h"
84
85	// Data definitions
86	static PSZ pszSrcFile = __FILE__;
87	static void fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect);
88
89	#pragma data_seg(GLOBAL1)
90	ARC_TYPE *arcsighead;
91	UINT arcsigs_header_lines; // Header comments line count in archiver.bb2
92	UINT arcsigs_trailer_line_num; // Trailer comments start line number (1..n)
93	BOOL arcsigsloaded;
94	BOOL arcsigsmodified;
95	static struct stat Archiverbb2Stats;
96
97	#define ARCHIVER_LINE_BYTES 256
98
99	//=== quick_find_type() ===
100	ARC_TYPE quick_find_type(CHAR filespec, ARC_TYPE * topsig)
101	{
102	ARC_TYPE info, found = NULL;
103	CHAR *p;
104
105	if (!arcsigsloaded)
106	load_archivers();
107	p = strrchr(filespec, '.');
108	if (p) {
109	p++;
110	info = (topsig) ? topsig : arcsighead;
111	while (info) {
112	if (info->ext && *(info->ext) && !stricmp(p, info->ext)) {
113	found = find_type(filespec, topsig);
114	break;
115	}
116	info = info->next;
117	}
118	}
119	return found;
120	}
121
122	//=== fill_listbox() fill or refill listbox from current archiver definitions ===
123
124	static VOID fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect)
125	{
126	ARC_TYPE *pat;
127	BOOL found = FALSE;
128	SHORT sSelect;
129
130	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEALL, MPVOID, MPVOID);
131
132	for (pat = arcsighead; pat; pat = pat->next) {
133	/**
134	* this inner loop tests for a dup signature entry and assures
135	* that only the entry at the top of the list gets used for
136	* conversion; editing any is okay
137	*/
138	if (!fShowAll) {
139	ARC_TYPE *pat2;
140	BOOL isDup = FALSE;
141
142	for (pat2 = arcsighead;
143	pat2 && pat->siglen && pat2 != pat && !isDup; pat2 = pat2->next) {
144	isDup = pat2->siglen == pat->siglen &&
145	!memcmp(pat2->signature, pat->signature, pat->siglen);
146	} // for
147	if (isDup)
148	continue;
149	}
150
151	// If caller is editing archivers or entry useful to caller, show in listbox
152	if (fShowAll \|\| (pat->id && pat->extract && pat->create)) {
153	sSelect = (SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
154	MPFROM2SHORT(LIT_END, 0),
155	MPFROMP(pat->id ? pat->id : "?"));
156	if (!found && *szDefArc && pat->id && !strcmp(szDefArc, pat->id)) {
157	// Highlight default
158	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
159	MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
160	found = TRUE;
161	}
162	}
163	else {
164	// Complain about odd entry
165	if (!pat->id \|\| !*pat->id) {
166	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
167	MPFROM2SHORT(LIT_END, 0),
168	MPFROMP(GetPString(IDS_UNKNOWNUNUSABLETEXT)));
169	}
170	else {
171	CHAR s[81];
172
173	sprintf(s, "%0.12s %s", pat->id, GetPString(IDS_UNUSABLETEXT));
174	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
175	MPFROM2SHORT(LIT_END, 0), MPFROMP(s));
176	}
177	}
178	} // while scanning
179
180	// Try to reselect last selection unless user wants default selection
181	if (sOldSelect == LIT_NONE) {
182	ULONG size = sizeof(SHORT);
183
184	PrfQueryProfileData(fmprof, appname, "LastArchiver", &sOldSelect, &size);
185	}
186	if (sOldSelect != LIT_NONE && !found) {
187	SHORT sItemCount =
188	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMCOUNT,
189	MPVOID, MPVOID);
190
191	if (sOldSelect >= sItemCount)
192	sOldSelect = sItemCount - 1;
193	if (sOldSelect >= 0) {
194	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
195	MPFROMSHORT(sOldSelect), MPFROMSHORT(TRUE));
196	}
197	}
198
199	if (found)
200	PosOverOkay(hwnd);
201	}
202
203	ARC_TYPE find_type(CHAR filespec, ARC_TYPE * topsig)
204	{
205	HFILE handle;
206	ULONG action;
207	ULONG len;
208	ULONG l;
209	ARC_TYPE *info;
210	CHAR *p;
211	CHAR buffer[4096]; // 06 Oct 07 SHL Protect against NTFS defect
212
213	if (!arcsigsloaded)
214	load_archivers();
215	if (!topsig)
216	topsig = arcsighead;
217	DosError(FERR_DISABLEHARDERR);
218	if (DosOpen(filespec,
219	&handle,
220	&action,
221	0,
222	0,
223	OPEN_ACTION_FAIL_IF_NEW \|
224	OPEN_ACTION_OPEN_IF_EXISTS,
225	OPEN_FLAGS_FAIL_ON_ERROR \|
226	OPEN_FLAGS_NOINHERIT \|
227	OPEN_FLAGS_RANDOMSEQUENTIAL \|
228	OPEN_SHARE_DENYNONE \| OPEN_ACCESS_READONLY, 0))
229	return NULL;
230	// Scan signatures
231	for (info = topsig; info; info = info->next) {
232	if (info->siglen == 0) {
233	// No signature -- check extension
234	p = strrchr(filespec, '.');
235	if (p) {
236	p++;
237	if (info->ext && *(info->ext) && !stricmp(p, info->ext))
238	break; // Matched
239
240	}
241	continue; // Next sig
242
243	}
244	// Try signature match
245	l = info->siglen;
246	l = min(l, 79);
247	if (!DosChgFilePtr(handle,
248	abs(info->file_offset),
249	(info->file_offset >= 0) ? FILE_BEGIN : FILE_END,
250	&len)) {
251	if (!DosRead(handle, buffer, l, &len) && len == l) {
252	if (!memcmp(info->signature, buffer, l))
253	break; // Matched
254
255	}
256	}
257	} // for
258
259	DosClose(handle); // Either way, we're done for now
260	return info; // Return signature, if any
261	}
262
263	# ifdef FORTIFY
264
265	VOID free_archivers(VOID)
266	{
267	ARC_TYPE pat, next;
268
269	pat = arcsighead;
270	while (pat) {
271	next = pat->next;
272	xfree(pat->id, pszSrcFile, __LINE__);
273	xfree(pat->ext, pszSrcFile, __LINE__);
274	xfree(pat->list, pszSrcFile, __LINE__);
275	xfree(pat->extract, pszSrcFile, __LINE__);
276	xfree(pat->create, pszSrcFile, __LINE__);
277	xfree(pat->move, pszSrcFile, __LINE__);
278	xfree(pat->delete, pszSrcFile, __LINE__);
279	xfree(pat->signature, pszSrcFile, __LINE__);
280	xfree(pat->startlist, pszSrcFile, __LINE__);
281	xfree(pat->endlist, pszSrcFile, __LINE__);
282	xfree(pat->exwdirs, pszSrcFile, __LINE__);
283	xfree(pat->test, pszSrcFile, __LINE__);
284	xfree(pat->createrecurse, pszSrcFile, __LINE__);
285	xfree(pat->createwdirs, pszSrcFile, __LINE__);
286	xfree(pat->movewdirs, pszSrcFile, __LINE__);
287	xfree(pat, pszSrcFile, __LINE__);
288	pat = next;
289	}
290	arcsighead = NULL;
291	}
292
293	//=== free_arc_type() free allocated ARC_TYPE ===
294
295	# endif
296
297	VOID free_arc_type(ARC_TYPE * pat)
298	{
299	if (pat) {
300	xfree(pat->id, pszSrcFile, __LINE__);
301	xfree(pat->ext, pszSrcFile, __LINE__);
302	xfree(pat->list, pszSrcFile, __LINE__);
303	xfree(pat->extract, pszSrcFile, __LINE__);
304	xfree(pat->create, pszSrcFile, __LINE__);
305	xfree(pat->move, pszSrcFile, __LINE__);
306	xfree(pat->delete, pszSrcFile, __LINE__);
307	xfree(pat->signature, pszSrcFile, __LINE__);
308	xfree(pat->startlist, pszSrcFile, __LINE__);
309	xfree(pat->endlist, pszSrcFile, __LINE__);
310	xfree(pat->exwdirs, pszSrcFile, __LINE__);
311	xfree(pat->test, pszSrcFile, __LINE__);
312	xfree(pat->createrecurse, pszSrcFile, __LINE__);
313	xfree(pat->createwdirs, pszSrcFile, __LINE__);
314	xfree(pat->movewdirs, pszSrcFile, __LINE__);
315	free(pat);
316	}
317	}
318
319	static UINT cur_line_num; // Input file line counter
320
321	//=== get_line_strip_comments() read line, strip comments and whitespace ===
322
323	static PSZ get_line_strip_comments(PSZ pszIn, FILE * fp)
324	{
325	PSZ psz = xfgets(pszIn, ARCHIVER_LINE_BYTES, fp, pszSrcFile, __LINE__);
326	PSZ psz2;
327
328	if (psz) {
329	cur_line_num++;
330	psz2 = strchr(pszIn, ';');
331	if (psz2)
332	*psz2 = 0; // Chop comment
333	bstripcr(pszIn); // Strip leading white and trailing white and CR/LF
334
335	}
336	return psz;
337	}
338
339	//=== get_line_strip_white() read line, strip whitespace ===
340
341	static PSZ get_line_strip_white(PSZ pszIn, FILE * fp)
342	{
343	PSZ psz =
344	xfgets_bstripcr(pszIn, ARCHIVER_LINE_BYTES, fp, pszSrcFile, __LINE__);
345
346	if (psz)
347	cur_line_num++;
348
349	return psz;
350	}
351
352	//=== load_archivers() load or reload archive definitions from archiver.bb2 ===
353
354	INT load_archivers(VOID)
355	{
356	FILE *fp;
357	CHAR sz[ARCHIVER_LINE_BYTES + 1];
358	CHAR *psz;
359	ARC_TYPE *pat = NULL;
360	ARC_TYPE *patLast = NULL;
361	UINT lines_per_arcsig = LINES_PER_ARCSIG;
362	UINT per_sig_comment_line_num = 0;
363	INT i;
364	CHAR *moder = "r";
365
366	// Free current signatures
367	if (arcsighead) {
368	for (pat = arcsighead; pat;) {
369	patLast = pat;
370	pat = pat->next;
371	free_arc_type(patLast);
372	}
373	arcsighead = NULL;
374	}
375
376	arcsigsmodified = FALSE;
377	arcsigs_header_lines = 0;
378	arcsigs_trailer_line_num = 0;
379
380	{
381	CHAR szFullFilename[CCHMAXPATH];
382
383	DosRequestMutexSem(hmtxFM2Globals, SEM_INDEFINITE_WAIT);
384	if (SearchMultiplePathsForFile(PCSZ_ARCHIVERBB2, szFullFilename)) {
385	DosReleaseMutexSem(hmtxFM2Globals);
386	return -1;
387	}
388	stat(szFullFilename, &Archiverbb2Stats);
389	fp = xfsopen(szFullFilename, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
390	DosReleaseMutexSem(hmtxFM2Globals);
391	if (!fp)
392	return -2;
393	strcpy(archiverbb2, szFullFilename); // Remember full path
394	}
395
396	cur_line_num = 0;
397
398	// Line 1 must contain number of lines per signature definition
399	if (!get_line_strip_comments(sz, fp)) {
400	fclose(fp);
401	return -3;
402	}
403	if (*sz)
404	lines_per_arcsig = atoi(sz);
405	if (!*sz \|\| lines_per_arcsig < LINES_PER_ARCSIG) {
406	fclose(fp); // 25 Aug 07 SHL
407	return -3;
408	}
409
410	// Parse rest of file
411	// 1st non-blank line starts definition
412	// Need to determine header size and start of trailer
413
414	while (!feof(fp)) {
415	// If reading header
416	if (!arcsigs_header_lines) {
417	// Reading header - find header size and start of signtures
418	if (!get_line_strip_white(sz, fp))
419	break; // Unexpected EOF
420	if (stristr(sz, "-- Current Archivers --")) {
421	arcsigs_header_lines = cur_line_num;
422	continue;
423	}
424	if (!sz \|\| sz == ';')
425	continue; // Header comment or blank line
426	else {
427	// Not a comment, must be start of signatures
428	PSZ psz2 = strchr(sz, ';');
429
430	if (psz2) {
431	*psz2 = 0; // Chop trailing comment
432	bstripcr(sz); // Strip leading white and trailing white and CR/LF
433	}
434	arcsigs_header_lines = cur_line_num - 1;
435	}
436	}
437	else {
438	// Reading defintiions
439	if (!get_line_strip_comments(sz, fp))
440	break; // EOF
441	}
442
443	// fixme to avoid allocating empty fields
444
445	// Remember start of per sig comments for next definition
446	if (per_sig_comment_line_num == 0)
447	per_sig_comment_line_num = cur_line_num;
448
449	if (*sz) {
450	// At start of defintion
451
452	pat = xmallocz(sizeof(ARC_TYPE), pszSrcFile, __LINE__);
453	if (!pat)
454	break;
455	pat->id = xstrdup(sz, pszSrcFile, __LINE__);
456
457	pat->comment_line_num = per_sig_comment_line_num;
458	pat->defn_line_num = cur_line_num;
459
460	if (!get_line_strip_comments(sz, fp)) // line 2 - extension
461	break;
462	if (*sz)
463	pat->ext = xstrdup(sz, pszSrcFile, __LINE__);
464	else
465	pat->ext = NULL;
466	if (!get_line_strip_comments(sz, fp)) // line 3 - offset to signature
467	break;
468	pat->file_offset = atol(sz);
469	if (!get_line_strip_comments(sz, fp)) // line 4 - list command
470	break;
471	if (*sz)
472	pat->list = xstrdup(sz, pszSrcFile, __LINE__);
473	else
474	pat->list = NULL;
475	if (!pat->list)
476	break; // Must have list command - fixme to complain
477	if (!get_line_strip_comments(sz, fp)) // line 5
478	break;
479	if (*sz)
480	pat->extract = xstrdup(sz, pszSrcFile, __LINE__);
481	else
482	pat->extract = NULL;
483	if (!get_line_strip_comments(sz, fp)) // line 6
484	break;
485	if (*sz)
486	pat->exwdirs = xstrdup(sz, pszSrcFile, __LINE__);
487	else
488	pat->exwdirs = NULL;
489	if (!get_line_strip_comments(sz, fp)) // line 7
490	break;
491	if (*sz)
492	pat->test = xstrdup(sz, pszSrcFile, __LINE__);
493	else
494	pat->test = NULL;
495	if (!get_line_strip_comments(sz, fp)) // line 8
496	break;
497	if (*sz)
498	pat->create = xstrdup(sz, pszSrcFile, __LINE__);
499	else
500	pat->create = NULL;
501	if (!get_line_strip_comments(sz, fp)) // line 9
502	break;
503	if (*sz)
504	pat->createwdirs = xstrdup(sz, pszSrcFile, __LINE__);
505	else
506	pat->createwdirs = NULL;
507	if (!get_line_strip_comments(sz, fp)) // line 10
508	break;
509	if (*sz)
510	pat->createrecurse = xstrdup(sz, pszSrcFile, __LINE__);
511	else
512	pat->createrecurse = NULL;
513	if (!get_line_strip_comments(sz, fp)) // line 11
514	break;
515	if (*sz)
516	pat->move = xstrdup(sz, pszSrcFile, __LINE__);
517	else
518	pat->move = NULL;
519	if (!get_line_strip_comments(sz, fp)) // line 12
520	break;
521	if (*sz)
522	pat->movewdirs = xstrdup(sz, pszSrcFile, __LINE__);
523	else
524	pat->movewdirs = NULL;
525	if (!get_line_strip_comments(sz, fp)) // line 13
526	break;
527	if (*sz)
528	pat->delete = xstrdup(sz, pszSrcFile, __LINE__);
529	else
530	pat->delete = NULL;
531	if (!get_line_strip_white(sz, fp)) // line 14
532	break;
533	i = literal(sz); // Translate \ escapes
534	if (i) {
535	pat->siglen = i;
536	pat->signature = xmalloc(i, pszSrcFile, __LINE__);
537	if (!pat->signature)
538	break;
539	memcpy(pat->signature, sz, i); // signature may not be a string
540	}
541	else {
542	pat->siglen = 0;
543	pat->signature = NULL;
544	}
545	if (!get_line_strip_white(sz, fp)) // line 15
546	break;
547	if (*sz)
548	pat->startlist = xstrdup(sz, pszSrcFile, __LINE__);
549	else
550	pat->startlist = NULL;
551	if (!get_line_strip_white(sz, fp)) // line 16
552	break;
553	if (*sz)
554	pat->endlist = xstrdup(sz, pszSrcFile, __LINE__);
555	else
556	pat->endlist = NULL;
557	if (!get_line_strip_comments(sz, fp)) // line 17
558	break;
559	pat->osizepos = atoi(sz);
560	if (!get_line_strip_comments(sz, fp)) // line 18
561	break;
562	pat->nsizepos = atoi(sz);
563	if (!get_line_strip_comments(sz, fp)) // line 19
564	break;
565	pat->fdpos = atoi(sz);
566	psz = strchr(sz, ',');
567	if (psz) {
568	psz++;
569	pat->datetype = atoi(psz);
570	}
571	if (!get_line_strip_comments(sz, fp)) // line 20
572	break;
573	pat->fdflds = atoi(sz);
574	if (!get_line_strip_comments(sz, fp)) // line 21
575	break;
576	pat->fnpos = atoi(sz);
577	psz = strchr(sz, ',');
578	if (psz) {
579	psz++;
580	pat->nameislast = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
581	psz = strchr(psz, ',');
582	if (psz) {
583	psz++;
584	pat->nameisnext = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
585	psz = strchr(psz, ',');
586	if (psz) {
587	psz++;
588	pat->nameisfirst = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
589	}
590	}
591	}
592	// Ignore unknown lines - must be newer file format
593	for (i = LINES_PER_ARCSIG; i < lines_per_arcsig; i++) {
594	if (!get_line_strip_comments(sz, fp))
595	break; // Unexpected EOF - fixme to complain
596	}
597
598	// Add to list, assume next and prev already NULL
599	if (!arcsighead)
600	arcsighead = patLast = pat;
601	else {
602	patLast->next = pat;
603	pat->prev = patLast;
604	patLast = pat;
605	}
606	pat = NULL; // Done with this defintion
607
608	arcsigs_trailer_line_num = cur_line_num + 1; // In case this is last defintion
609	per_sig_comment_line_num = 0;
610	} // if got definition
611
612	} // while more lines
613
614	fclose(fp);
615
616	free_arc_type(pat); // In case partial definition in progress
617
618	if (!arcsighead)
619	return -4;
620
621	arcsigsloaded = TRUE;
622
623	return 0;
624	}
625
626	#define TEST_DRAG 0 // fixme to be gone or to work
627
628	static MRESULT EXPENTRY SDlgListboxSubclassProc(HWND hwnd, ULONG msg,
629	MPARAM mp1, MPARAM mp2)
630	{
631	PFNWP pfnOldProc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
632
633	PDRAGITEM pDItem;
634	PDRAGINFO pDInfo;
635	BOOL ok;
636
637	static BOOL emphasized = FALSE;
638	static PSZ DRMDRF_LBOX = "<DRM_LBOX,DRF_UNKNOWN>";
639	static PSZ DRM_LBOX = "DRM_LBOX";
640
641	switch (msg) {
642	case WM_BEGINDRAG:
643	{
644	LONG cur_ndx;
645	DRAGITEM ditem;
646	DRAGIMAGE dimage;
647	HWND hwndDrop;
648
649	// fprintf(stderr, "SDlgListboxSubclassProc: BEGINDRAG\n");
650	cur_ndx = WinQueryLboxSelectedItem(hwnd);
651
652	if (cur_ndx != LIT_NONE) {
653	pDInfo = DrgAllocDraginfo(1);
654	if (pDInfo) {
655	pDInfo->usOperation = DO_DEFAULT;
656	pDInfo->hwndSource = hwnd;
657
658	memset(&ditem, 0, sizeof(DRAGITEM));
659	ditem.hwndItem = hwnd;
660	ditem.ulItemID = 1;
661	ditem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
662	ditem.hstrRMF = DrgAddStrHandle(DRMDRF_LBOX);
663	ditem.hstrContainerName = DrgAddStrHandle(NullStr);
664	ditem.hstrSourceName = DrgAddStrHandle(NullStr);
665	ditem.hstrTargetName = DrgAddStrHandle(NullStr);
666	ditem.fsSupportedOps = DO_MOVEABLE;
667
668	memset(&dimage, 0, sizeof(DRAGIMAGE));
669	dimage.cb = sizeof(DRAGIMAGE);
670	dimage.hImage = hptrFile;
671	dimage.cptl = 0;
672	dimage.fl = DRG_ICON;
673	dimage.sizlStretch.cx = 32;
674	dimage.sizlStretch.cy = 32;
675	dimage.cxOffset = -16;
676	dimage.cyOffset = 0;
677	DrgSetDragitem(pDInfo, &ditem, sizeof(DRAGITEM), 0); // Index of DRAGITEM
678	hwndDrop = DrgDrag(hwnd, pDInfo, &dimage, 1, // One DRAGIMAGE
679	VK_ENDDRAG, NULL);
680	if (!hwndDrop)
681	Win_Error(hwnd, hwnd, pszSrcFile, __LINE__, "DrgDrag");
682
683	DrgFreeDraginfo(pDInfo);
684	}
685	}
686	break;
687	}
688
689	case DM_DRAGOVER:
690	ok = FALSE;
691	if (!emphasized) {
692	POINTL ptl;
693	POINTL ptl2;
694
695	emphasized = TRUE;
696	ptl.x = SHORT1FROMMP(mp2);
697	ptl.y = SHORT2FROMMP(mp2);
698	ptl2 = ptl;
699	WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl2, 1);
700	// fprintf(stderr, "DRAGOVER mapped x y %d %d to %d %d\n", ptl.x, ptl.y, ptl2.x, ptl2.y);
701	WinPostMsg(hwnd, WM_BUTTON1CLICK,
702	MPFROM2SHORT((SHORT) ptl2.x, (SHORT) ptl2.y),
703	MPFROM2SHORT(HT_NORMAL, KC_NONE));
704	// fprintf(stderr, "DRAGOVER posted 0x%x WM_BUTTON1CLICK x y %d %d\n", hwnd, ptl2.x, ptl2.y);
705	}
706	pDInfo = (PDRAGINFO) mp1; // Get DRAGINFO pointer
707	if (pDInfo) {
708	if (!DrgAccessDraginfo(pDInfo)) {
709	Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
710	PCSZ_DRGACCESSDRAGINFO);
711	}
712	else {
713	pDItem = DrgQueryDragitemPtr(pDInfo, 0);
714	// Check valid rendering mechanisms and data format
715	ok = DrgVerifyRMF(pDItem, DRM_LBOX, NULL);
716	DrgFreeDraginfo(pDInfo);
717	}
718	}
719	return ok ? MRFROM2SHORT(DOR_DROP, DO_MOVE) :
720	MRFROM2SHORT(DOR_NEVERDROP, 0);
721
722	case DM_DRAGLEAVE:
723	if (emphasized) {
724	emphasized = FALSE;
725	// fixme to draw listbox item emphasized
726	// DrawTargetEmphasis(hwnd, emphasized);
727	// fprintf(stderr, "DRAGLEAVE\n");
728	fflush(stderr);
729	}
730	return 0;
731
732	case DM_DROPHELP:
733	DropHelp(mp1, mp2, hwnd, "fixme to give some help");
734	return 0;
735
736	case DM_DROP:
737	ok = FALSE;
738	if (emphasized) {
739	emphasized = FALSE;
740	// DrawTargetEmphasis(hwnd, emphasized);
741	}
742	pDInfo = (PDRAGINFO) mp1; // Get DRAGINFO pointer
743	if (pDInfo) {
744	if (!DrgAccessDraginfo(pDInfo)) {
745	Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
746	PCSZ_DRGACCESSDRAGINFO);
747	}
748	else {
749	pDItem = DrgQueryDragitemPtr(pDInfo, 0);
750	if (!pDItem)
751	Win_Error(hwnd, hwnd, pszSrcFile, __LINE__, "DM_DROP");
752	// Check valid rendering mechanisms and data
753	ok = DrgVerifyRMF(pDItem, DRM_LBOX, NULL)
754	&& ~pDItem->fsControl & DC_PREPARE;
755	if (ok) {
756	// note: targetfail is returned to source for all items
757	DrgSendTransferMsg(pDInfo->hwndSource, DM_ENDCONVERSATION,
758	MPFROMLONG(pDItem->ulItemID),
759	MPFROMLONG(DMFL_TARGETSUCCESSFUL));
760	}
761	FreeDragInfoData(hwnd, pDInfo);
762	}
763	}
764	return 0;
765	} // switch
766	return pfnOldProc ? pfnOldProc(hwnd, msg, mp1, mp2) :
767	WinDefWindowProc(hwnd, msg, mp1, mp2);
768	}
769
770	//=== SBoxDlgProc() Select archiver to use or edit, supports list reorder too ===
771
772	static PSZ pszCantFindMsg = "Can't find item %d";
773
774	MRESULT EXPENTRY SBoxDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
775	{
776	ARC_TYPE **ppatReturn; // Where to return selected archiver
777	ARC_TYPE *pat;
778	SHORT sSelect;
779	SHORT sItemCount;
780	CHAR szItemText[256];
781	CHAR szPCItemText[256]; // Parent or child item text
782	SHORT i;
783	BOOL fShowAll;
784
785	static SHORT sLastSelect = LIT_NONE;
786
787	switch (msg) {
788	case WM_INITDLG:
789	if (!arcsigsloaded)
790	load_archivers();
791	else {
792	struct stat Buffer;
793
794	// stat(searchpath(PCSZ_ARCHIVERBB2), &Buffer);
795	stat(archiverbb2, &Buffer); // jbs: Re-use full name set by load_achivers
796	if (Archiverbb2Stats.st_size != Buffer.st_size \|\|
797	Archiverbb2Stats.st_mtime != Buffer.st_mtime)
798	if (saymsg(MB_YESNO,
799	hwnd,
800	GetPString(IDS_ADCHANGESONDISKTEXT),
801	GetPString(IDS_ADRELOADMEMTEXT)) == MBID_YES)
802	load_archivers();
803	}
804	if (!(ARC_TYPE **) mp2) {
805	Runtime_Error(pszSrcFile, __LINE__, NULL);
806	WinDismissDlg(hwnd, 0);
807	break;
808	}
809	/** Passed arg points to where to return selected archiver definition
810	* On input arg value controls selection list content
811	* If non-NULL, dup names are suppressed
812	* If NULL, all definitions are shown
813	*/
814	ppatReturn = (ARC_TYPE **) mp2;
815	fShowAll = *ppatReturn == NULL;
816	if (*ppatReturn)
817	*ppatReturn = arcsighead; // Preset to first
818	WinSetWindowPtr(hwnd, QWL_USER, (PVOID) ppatReturn);
819	fill_listbox(hwnd, fShowAll, sLastSelect);
820
821	#ifdef TEST_DRAG // fixme
822	{
823	HWND hwnd2 = WinWindowFromID(hwnd, ASEL_LISTBOX);
824	PFNWP pfn = WinSubclassWindow(hwnd2,
825	SDlgListboxSubclassProc);
826
827	WinSetWindowPtr(hwnd2, QWL_USER, (PVOID) pfn);
828	}
829	#endif // TEST_DRAG fixme
830
831	break;
832
833	case WM_HELP:
834	if (hwndHelp)
835	WinSendMsg(hwndHelp,
836	HM_DISPLAY_HELP,
837	MPFROMSHORT(1), MPFROMSHORT(HM_RESOURCEID));
838	break;
839
840	case WM_COMMAND:
841	ppatReturn = (ARC_TYPE **) WinQueryWindowPtr(hwnd, QWL_USER);
842	switch (SHORT1FROMMP(mp1)) {
843	case DID_OK:
844	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
845	ASEL_LISTBOX,
846	LM_QUERYSELECTION,
847	MPFROMSHORT(LIT_FIRST), MPVOID);
848	if (sSelect == LIT_NONE) {
849	Runtime_Error(pszSrcFile, __LINE__, "list empty");
850	return 0;
851	}
852	pat = arcsighead;
853	if (*ppatReturn) {
854	// If dups hidden, find archiver with matching id
855	*szItemText = 0;
856	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
857	MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
858	if (!*szItemText)
859	pat = NULL;
860	else {
861	for (; pat; pat = pat->next) {
862	if (pat->id && !strcmp(szItemText, pat->id))
863	break; // Found it
864	}
865	}
866	}
867	else {
868	// If dups not hidden, lookup by count
869	for (i = 0; pat && i < sSelect; i++, pat = pat->next) ; // Scan
870	}
871	if (pat && (!*ppatReturn \|\| (pat->id && pat->extract && pat->create))) {
872	*ppatReturn = pat;
873	}
874	else {
875	Runtime_Error(pszSrcFile, __LINE__, "no match");
876	// Refuse to select
877	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
878	MPFROMSHORT(LIT_NONE), FALSE);
879	return 0;
880	}
881	PrfWriteProfileData(fmprof, appname, "LastArchiver", &sSelect, sizeof(SHORT));
882	sLastSelect = sSelect;
883	WinDismissDlg(hwnd, TRUE);
884	return 0;
885
886	case DID_CANCEL:
887	if (arcsigsmodified) {
888	if (saymsg(MB_YESNO,
889	hwnd,
890	GetPString(IDS_ADCHANGESINMEMTEXT),
891	GetPString(IDS_ADREWRITETEXT), NullStr) == MBID_YES) {
892	// 524 PSZ ab2 = searchpath(PCSZ_ARCHIVERBB2); // Rewrite without prompting
893
894	rewrite_archiverbb2(archiverbb2); // jbs: Re-use full path set by load_archivers
895	}
896	}
897	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
898	ASEL_LISTBOX,
899	LM_QUERYSELECTION,
900	MPFROMSHORT(LIT_FIRST), MPVOID);
901	if (sSelect != LIT_NONE) {
902	sLastSelect = sSelect;
903	PrfWriteProfileData(fmprof, appname, "LastArchiver", &sSelect, sizeof(SHORT));
904	}
905	*ppatReturn = NULL;
906	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID); // fixme to understand why needed
907	return 0;
908
909	case ASEL_PB_ADD:
910	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
911	ASEL_LISTBOX,
912	LM_QUERYSELECTION,
913	MPFROMSHORT(LIT_FIRST), MPVOID);
914	if (sSelect != LIT_NONE) {
915	ARCDUMP ad;
916
917	memset(&ad, 0, sizeof(ARCDUMP));
918	ad.info = xmallocz(sizeof(ARC_TYPE), pszSrcFile, __LINE__);
919	if (ad.info) {
920	if (!WinDlgBox(HWND_DESKTOP,
921	hwnd,
922	ArcReviewDlgProc,
923	FM3ModHandle, AD_FRAME, MPFROMP(&ad))) {
924	free(ad.info);
925	}
926	else {
927	// Find self - assume all archivers listed since we are editing
928	for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++) ; // Find self
929
930	if (!pat) {
931	if (arcsighead)
932	Runtime_Error(pszSrcFile, __LINE__, pszCantFindMsg, sSelect);
933	else
934	arcsighead = ad.info;
935	}
936	else {
937	// Insert before
938	if (pat->prev) {
939	ad.info->next = pat;
940	ad.info->prev = pat->prev;
941	pat->prev->next = ad.info;
942	pat->prev = ad.info;
943	}
944	else {
945	arcsighead = ad.info;
946	ad.info->next = pat;
947	pat->prev = ad.info;
948	}
949	}
950	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
951	MPFROM2SHORT(sSelect, 0),
952	MPFROMP(ad.info->id ? ad.info->id : "?"));
953	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
954	MPFROMSHORT(sSelect - 1), MPFROMSHORT(TRUE));
955	arcsigsmodified = TRUE;
956	}
957	}
958	}
959	return 0;
960	case ASEL_PB_DELETE:
961	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
962	ASEL_LISTBOX,
963	LM_QUERYSELECTION,
964	MPFROMSHORT(LIT_FIRST), MPVOID);
965	if (sSelect != LIT_NONE) {
966	// Find self - assume all archivers listed since we are editing
967	for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++) ; // Find self
968
969	if (!pat)
970	Runtime_Error(pszSrcFile, __LINE__, pszCantFindMsg, sSelect);
971	else {
972	// Delete current
973	if (pat->prev) {
974	pat->prev->next = pat->next;
975	if (pat->next)
976	pat->next->prev = pat->prev;
977	}
978	else {
979	arcsighead = pat->next;
980	if (pat->next)
981	pat->next->prev = pat->prev;
982	}
983	}
984	free_arc_type(pat);
985	arcsigsmodified = TRUE;
986	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEITEM,
987	MPFROM2SHORT(sSelect, 0), MPVOID);
988	sItemCount =
989	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMCOUNT,
990	MPVOID, MPVOID);
991	if (sSelect >= sItemCount)
992	sSelect--;
993	if (sSelect >= 0) {
994	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
995	MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
996	}
997	}
998	return 0;
999	case ASEL_PB_UP:
1000	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
1001	ASEL_LISTBOX,
1002	LM_QUERYSELECTION,
1003	MPFROMSHORT(LIT_FIRST), MPVOID);
1004	if (sSelect != LIT_NONE && sSelect > 0) {
1005	// Find self - assume all archivers listed since we are editing
1006	for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++) ; // Find self
1007	if (!pat \|\| !pat->prev)
1008	Runtime_Error(pszSrcFile, __LINE__, pszCantFindMsg, sSelect);
1009	else {
1010	ARC_TYPE *patGDad;
1011	ARC_TYPE *patDad;
1012	ARC_TYPE *patChild;
1013
1014	patChild = pat->next;
1015	patDad = pat->prev;
1016	patGDad = patDad->prev;
1017	patDad->next = patChild;
1018	if (patChild)
1019	patChild->prev = patDad;
1020	patDad->prev = pat;
1021	pat->next = patDad;
1022	if (patGDad) {
1023	patGDad->next = pat;
1024	pat->prev = patGDad;
1025	}
1026	else {
1027	arcsighead = pat;
1028	pat->prev = NULL;
1029	}
1030
1031	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1032	MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
1033	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1034	MPFROM2SHORT(sSelect - 1, 255),
1035	MPFROMP(szPCItemText));
1036	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1037	MPFROMSHORT(sSelect), MPFROMP(szPCItemText));
1038	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1039	MPFROMSHORT(sSelect - 1), MPFROMP(szItemText));
1040	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
1041	MPFROMSHORT(sSelect - 1), MPFROMSHORT(TRUE));
1042	arcsigsmodified = TRUE;
1043	}
1044	}
1045	return 0;
1046	case ASEL_PB_DOWN:
1047	sSelect =
1048	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYSELECTION,
1049	MPFROMSHORT(LIT_FIRST), MPVOID);
1050	sItemCount =
1051	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMCOUNT,
1052	MPVOID, MPVOID);
1053	if (sSelect != LIT_NONE && sSelect < sItemCount - 1) {
1054	// Find self - assume all archivers listed since we are editing
1055	for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++) ; // Find self
1056	if (!pat \|\| !pat->next)
1057	Runtime_Error(pszSrcFile, __LINE__, "Can't find item %d of %d",
1058	sSelect, sItemCount);
1059	else {
1060	ARC_TYPE *patDad;
1061	ARC_TYPE *patChild;
1062
1063	patDad = pat->prev;
1064	patChild = pat->next;
1065	pat->next = patChild->next;
1066	patChild->next = pat;
1067	pat->prev = patChild;
1068	patChild->prev = patDad;
1069	if (patDad) {
1070	patDad->next = patChild;
1071	patChild->prev = patDad;
1072	}
1073	else {
1074	arcsighead = patChild;
1075	patChild->prev = NULL;
1076	}
1077
1078	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1079	MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
1080	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1081	MPFROM2SHORT(sSelect + 1, 255),
1082	MPFROMP(szPCItemText));
1083	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1084	MPFROMSHORT(sSelect), MPFROMP(szPCItemText));
1085	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1086	MPFROMSHORT(sSelect + 1), MPFROMP(szItemText));
1087	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
1088	MPFROMSHORT(sSelect + 1), MPFROMSHORT(TRUE));
1089	arcsigsmodified = TRUE;
1090	}
1091	}
1092	return 0;
1093
1094	case ASEL_PB_REVERT:
1095	// Reload without checking in case changed outside
1096	sSelect =
1097	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYSELECTION,
1098	MPFROMSHORT(LIT_FIRST), MPVOID);
1099	load_archivers();
1100	fill_listbox(hwnd, TRUE, sSelect);
1101	return 0;
1102
1103	case IDM_HELP:
1104	if (hwndHelp) {
1105	WinSendMsg(hwndHelp, HM_DISPLAY_HELP, MPFROM2SHORT(HELP_EDITARC, 0), // fixme to be HELP_SELARC
1106	MPFROMSHORT(HM_RESOURCEID));
1107	}
1108	}
1109	return 0; // WM_COMMAND
1110
1111	case WM_CONTROL:
1112	if (SHORT1FROMMP(mp1) == ASEL_LISTBOX && SHORT2FROMMP(mp1) == LN_ENTER)
1113	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_OK, 0), MPVOID);
1114	return 0;
1115
1116	case WM_CLOSE:
1117	WinDismissDlg(hwnd, FALSE);
1118	return 0;
1119
1120	default:
1121	break;
1122	}
1123	return WinDefDlgProc(hwnd, msg, mp1, mp2);
1124	}
1125
1126	/**
1127	* see archiver.tmp
1128	* 02-08-96 23:55 1
1129	* 8 Feb 96 23:55:32 2
1130	* 8 Feb 96 11:55p 3
1131	* 96-02-08 23:55:32 4
1132	* 31-02-98 23:55 5
1133	* Aug 21 23:55 2011 6 Fixes tar.gz date/time formatting when using tar 1..15+
1134	*/
1135
1136	BOOL ArcDateTime(CHAR * dt, INT type, CDATE * cdate, CTIME * ctime)
1137	{
1138	INT x;
1139	BOOL ret = FALSE;
1140	CHAR p, pp, *pd;
1141
1142	if (dt && cdate && ctime) {
1143	memset(cdate, 0, sizeof(CDATE));
1144	memset(ctime, 0, sizeof(CTIME));
1145	if (type) {
1146	p = dt;
1147	while (p && p == ' ')
1148	p++;
1149	pd = dt;
1150	switch (type) {
1151	case 1:
1152	cdate->month = atoi(pd);
1153	p = to_delim(pd, "-/.");
1154	if (p) {
1155	p++;
1156	cdate->day = atoi(p);
1157	pd = p;
1158	p = to_delim(pd, "-/.");
1159	if (p) {
1160	p++;
1161	cdate->year = atoi(p);
1162	if (cdate->year > 80 && cdate->year < 1900)
1163	cdate->year += 1900;
1164	else if (cdate->year < 1900)
1165	cdate->year += 2000;
1166	ret = TRUE;
1167	p = strchr(p, ' ');
1168	if (p) {
1169	while (p && p == ' ')
1170	p++;
1171	ctime->hours = atoi(p);
1172	p = to_delim(pd, ":.");
1173	if (p) {
1174	p++;
1175	ctime->minutes = atoi(p);
1176	p = to_delim(pd, ":.");
1177	if (p) {
1178	p++;
1179	ctime->seconds = atoi(p);
1180	}
1181	}
1182	}
1183	}
1184	}
1185	break;
1186
1187	case 2:
1188	cdate->day = atoi(p);
1189	p = strchr(p, ' ');
1190	if (p) {
1191	p++;
1192	for (x = 0; x < 12; x++) {
1193	if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1194	break;
1195	}
1196	if (x < 12) {
1197	cdate->month = x + 1;
1198	p = strchr(p, ' ');
1199	if (p) {
1200	p++;
1201	cdate->year = atoi(p);
1202	if (cdate->year > 80 && cdate->year < 1900)
1203	cdate->year += 1900;
1204	else if (cdate->year < 1900)
1205	cdate->year += 2000;
1206	ret = TRUE;
1207	p = strchr(p, ' ');
1208	if (p) {
1209	while (p && p == ' ')
1210	p++;
1211	ctime->hours = atoi(p);
1212	p = to_delim(pd, ":.");
1213	if (p) {
1214	p++;
1215	ctime->minutes = atoi(p);
1216	p = to_delim(pd, ":.");
1217	if (p) {
1218	p++;
1219	ctime->seconds = atoi(p);
1220	}
1221	}
1222	}
1223	}
1224	}
1225	}
1226	break;
1227
1228	case 3:
1229	cdate->day = atoi(p);
1230	p = strchr(p, ' ');
1231	if (p) {
1232	p++;
1233	for (x = 0; x < 12; x++) {
1234	if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1235	break;
1236	}
1237	if (x < 12) {
1238	cdate->month = x + 1;
1239	p = strchr(p, ' ');
1240	if (p) {
1241	p++;
1242	cdate->year = atoi(p);
1243	if (cdate->year > 80 && cdate->year < 1900)
1244	cdate->year += 1900;
1245	else if (cdate->year < 1900)
1246	cdate->year += 2000;
1247	ret = TRUE;
1248	p = strchr(p, ' ');
1249	if (p) {
1250	while (p && p == ' ')
1251	p++;
1252	ctime->hours = atoi(p);
1253	p = to_delim(pd, ":.");
1254	if (p) {
1255	p++;
1256	pp = p;
1257	ctime->minutes = atoi(p);
1258	p = to_delim(pd, ":.");
1259	if (p) {
1260	p++;
1261	ctime->seconds = atoi(p);
1262	p += 2;
1263	if (toupper(*p) == 'P')
1264	ctime->hours += 12;
1265	}
1266	else {
1267	p = pp;
1268	p += 2;
1269	if (toupper(*p) == 'P')
1270	ctime->hours += 12;
1271	}
1272	}
1273	}
1274	}
1275	}
1276	}
1277	break;
1278
1279	case 4:
1280	cdate->year = atoi(p);
1281	if (cdate->year > 80 && cdate->year < 1900)
1282	cdate->year += 1900;
1283	else if (cdate->year < 1900)
1284	cdate->year += 2000;
1285	p = to_delim(pd, "-/.");
1286	if (p) {
1287	p++;
1288	cdate->month = atoi(p);
1289	pd = p;
1290	p = to_delim(pd, "-/.");
1291	if (p) {
1292	p++;
1293	cdate->day = atoi(p);
1294	ret = TRUE;
1295	p = strchr(p, ' ');
1296	if (p) {
1297	while (p && p == ' ')
1298	p++;
1299	ctime->hours = atoi(p);
1300	p = to_delim(pd, ":.");
1301	if (p) {
1302	p++;
1303	ctime->minutes = atoi(p);
1304	p = to_delim(pd, ":.");
1305	if (p) {
1306	p++;
1307	ctime->seconds = atoi(p);
1308	}
1309	}
1310	}
1311	}
1312	}
1313	break;
1314
1315	case 5:
1316	cdate->day = atoi(pd);
1317	p = to_delim(pd, "-/.");
1318	if (p) {
1319	p++;
1320	cdate->month = atoi(p);
1321	pd = p;
1322	p = to_delim(pd, "-/.");
1323	if (p) {
1324	p++;
1325	cdate->year = atoi(p);
1326	if (cdate->year > 80 && cdate->year < 1900)
1327	cdate->year += 1900;
1328	else if (cdate->year < 1900)
1329	cdate->year += 2000;
1330	ret = TRUE;
1331	p = strchr(p, ' ');
1332	if (p) {
1333	while (p && p == ' ')
1334	p++;
1335	ctime->hours = atoi(p);
1336	p = to_delim(pd, ":.");
1337	if (p) {
1338	p++;
1339	ctime->minutes = atoi(p);
1340	p = to_delim(pd, ":.");
1341	if (p) {
1342	p++;
1343	ctime->seconds = atoi(p);
1344	}
1345	}
1346	}
1347	}
1348	}
1349	break;
1350	case 6:
1351	for (x = 0; x < 12; x++) {
1352	if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1353	break;
1354	}
1355	if (x < 12) {
1356	cdate->month = x + 1;
1357	p = strchr(p, ' ');
1358	if (p) {
1359	p++;
1360	cdate->day = atoi(p);
1361	p = strchr(p, ' ');
1362	if (p) {
1363	p++;
1364	ctime->hours = atoi(p);
1365	p = to_delim(pd, ":.");
1366	if (p) {
1367	p++;
1368	ctime->minutes = atoi(p);
1369	p = to_delim(pd, ":.");
1370	p = strchr(p, ' ');
1371	if (p) {
1372	p++;
1373	cdate->year = atoi(p);
1374	if (cdate->year > 80 && cdate->year < 1900)
1375	cdate->year += 1900;
1376	else if (cdate->year < 1900)
1377	cdate->year += 2000;
1378	ret = TRUE;
1379	}
1380	}
1381	}
1382	}
1383	}
1384	break;
1385	default:
1386	break;
1387	}
1388	}
1389	}
1390	return ret;
1391	}
1392
1393	#pragma alloc_text(MISC9,quick_find_type,find_type)
1394	#pragma alloc_text(AVL,load_archivers, get_line_strip_comments, get_line_strip_white, free_archivers)
1395	#pragma alloc_text(FMARCHIVE,SBoxDlgProc,SDlgListboxSubclassProc)
1396	#pragma alloc_text(ARCCNRS,ArcDateTime)

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

Download in other formats: