Context Navigation

source: trunk/dll/avl.c@ 1158

Visit:

Last change on this file since 1158 was 1158, checked in by John Small, 17 years ago
Ticket 187: Draft 1: Functions only
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.4 KB

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

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

Download in other formats: