![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to include.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit|
Return to include.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /****************************** Module Header *******************************
13: * Module Name: include.c
14: *
15: * This module contains routines that manipulate the linked lists
16: * of labels (symbols plus id values).
17: *
18: * Functions:
19: * AddLabel()
20: * FindLabel()
21: * FindID()
22: * FindIDInRes()
23: * DeleteLabel()
24: * IsSymbol()
25: * IDToLabel()
26: * LabelToID()
27: * FreeLabels()
28: *
29: * Comments:
30: *
31: * The following describes the linked lists of LABEL structures that
32: * contain all the symbols that are in the include file. It is
33: * important that these structures and lists be maintained properly
34: * for the udpating of the include file to occur properly.
35: *
36: * The following fields are in the LABEL structure:
37: *
38: * npNext - points to * the next label in the list. This is NULL
39: * for the last link in the list.
40: * pszLabel - points to a null terminated, allocated string that
41: * has the symbol. This needs to be free'd if the structure
42: * is free'd.
43: * id - the current id value for this symbol.
44: * idOrig - the id value as read from the include file. This
45: * field is used to determine if the id value has been changed
46: * or not, so it is the same as the id unless the user has
47: * modified the id value of the symbol.
48: * fpos - the file pointer offset to the "#" in the "#define" in
49: * the include file as it was read in. This field is used
50: * to determine where the "#define" line starts in the
51: * file. If the label is added by the user (it does not exist
52: * in the include file) this field will be set to FPOS_MAX.
53: * nValueOffset - the offset in bytes from the fpos value to the start of
54: * the id value in the "#define" line in the include file. This
55: * will be ignored if fpos is set to FPOS_MAX.
56: *
57: * The order of the linked lists of labels are very important. The order
58: * will be exactly the same as is read from the include file. This
59: * allows any changes to be merged back out to the new include file
60: * when it is saved. If any labels are added by the user, they will be
61: * added to the end of the list. The start of the new ones is detected
62: * by the first label with an fpos value of FPOS_MAX (which all the
63: * new ones should have). Because the order of the new labels is not
64: * critical (they will be added to the end of the include file) the
65: * new labels are sorted by id value. Because the id values given
66: * to dialogs and controls by default are ascending, this will tend to
67: * group dialogs labels and their associated control labels together.
68: *
69: * Linked lists of labels always come in pairs. There is the linked
70: * list of current labels (ones read from the include file followed
71: * by labels added later), and there is also a separate linked list
72: * of "deleted" labels. The deleted label list is required because
73: * when the include file is saved, the deleted labels must be removed
74: * from the include file, so the label structure for them (which
75: * contains their file offset and so on) must be kept around. When
76: * the user deletes a label, it is removed from the current label
77: * linked list and added to the deleted label list. The deleted label
78: * list MUST be kept in order by fpos, but if the label that is
79: * deleted is one that did not exist in the include file (its fpos
80: * was FPOS_MAX) then it does NOT have to be added to the deleted
81: * list, and can simply be free'd. When the user adds a new label,
82: * the deleted list is searched first to see if the label was
83: * previously deleted. If it was, it is removed from the deleted list
84: * and placed back in the current label list (sorted by fpos, of
85: * course). If it is a new label, it is simply added to the new labels
86: * at the end of the list (sorted by id value). This is why every
87: * function that takes a pointer to the head of a label list also
88: * takes a pointer to the head of a deleted label list.
89: *
90: ****************************************************************************/
91:
92: #include "dlgedit.h"
93: #include "dlgfuncs.h"
94: #include "dlgextrn.h"
95:
96:
97:
98: /************************************************************************
99: * AddLabel
100: *
101: * This adds a symbol/label into the given include file list. The deleted
102: * include list is first searched and if a deleted label is found with the
103: * same symbol, it is transfered back into the include list. This is to
104: * handle the case where a user reads in an include file, deletes one of
105: * the labels then adds it back in later.
106: *
107: * The npLabelSkip parameter is for the special case of changing a
108: * label. This is done by adding a new label then deleting the old
109: * one, so setting this parameter prevents a spurious "duplicate id"
110: * message during the add.
111: *
112: * The pfDups parameter can be used to set a flag when there is a
113: * duplicate symbol, or a symbol with the same id found in the include
114: * list. If this parameter is NULL, nothing is returned and the appropriate
115: * error message is displayed if a dup is found. If this parameter is not
116: * NULL, it is assumed to point to a BOOL that will be set to TRUE if either
117: * of these conditions is found. The flag will NOT be set to FALSE if this
118: * condition is NOT found, so AddLabel can be used in a loop and when the
119: * loop is done, *pfDups will contain TRUE if there were any duplicates.
120: * Note that if pfDups is not NULL, the dup error messages will be supressed.
121: * This routine truncates pszLabel at the first space. It can allocate
122: * memory for a LABEL and for its string. The pplHead and pplDelHead lists
123: * are updated.
124: *
125: * Arguments:
126: * LPTSTR pszLabel = The label to add.
127: * INT id = The id associated with rgchLabel.
128: * DWORD fpos = The file position in the include file where the
129: * "#define" for this label starts, or FPOS_MAX
130: * if the label was not read from an include file.
131: * INT nValueOffset = Offset from fpos where the id value begins.
132: * NPLABEL *pplHead = Pointer to the head of the include list to use.
133: * NPLABEL *pplDelHead = Pointer to the head of the deleted include list.
134: * NPLABEL npLabelSkip = If not NULL, points to a label to skip when
135: * checking for duplicates.
136: * BOOL *pfDups = Points to a BOOL that is set to TRUE if there
137: * is a duplicate symbol or id found.
138: *
139: * Returns:
140: * Pointer to the allocated LABEL structure - NULL for an error.
141: *
142: ************************************************************************/
143:
144: NPLABEL AddLabel(
145: LPTSTR pszLabel,
146: INT id,
147: DWORD fpos,
148: INT nValueOffset,
149: NPLABEL *pplHead,
150: NPLABEL *pplDelHead,
151: NPLABEL npLabelSkip,
152: BOOL *pfDups)
153: {
154: register NPLABEL npTmp;
155: NPLABEL npLabel;
156: NPLABEL npPrevLabel;
157: BOOL fFoundDeleted = FALSE;
158:
159: /*
160: * First check for a duplicate id or symbol.
161: */
162: for (npTmp = *pplHead; npTmp; npTmp = npTmp->npNext) {
163: if ((npTmp->id == id || lstrcmp(pszLabel, npTmp->pszLabel) == 0) &&
164: npTmp != npLabelSkip) {
165: if (pfDups) {
166: *pfDups = TRUE;
167: }
168: else {
169: if (npTmp->id == id)
170: Message(MSG_LABELDUPID);
171: else
172: Message(MSG_SYMEXISTS);
173: }
174:
175: return NULL;
176: }
177: }
178:
179: /*
180: * Search for this symbol in the deleted list first.
181: */
182: npPrevLabel = NULL;
183: for (npLabel = *pplDelHead; npLabel; npLabel = npLabel->npNext) {
184: if (lstrcmp(pszLabel, npLabel->pszLabel) == 0) {
185: fFoundDeleted = TRUE;
186: break;
187: }
188:
189: npPrevLabel = npLabel;
190: }
191:
192: /*
193: * Was the label found in the deleted list?
194: */
195: if (fFoundDeleted) {
196: /*
197: * Close up the deleted list where the deleted label was.
198: */
199: if (npPrevLabel)
200: npPrevLabel->npNext = npLabel->npNext;
201: else
202: *pplDelHead = npLabel->npNext;
203:
204: /*
205: * Set the id in case the user is adding the same symbol
206: * but with a different id.
207: */
208: npLabel->id = id;
209:
210: /*
211: * Search for where the label should be inserted
212: * based on its fpos.
213: */
214: npPrevLabel = NULL;
215: for (npTmp = *pplHead; npTmp; npTmp = npTmp->npNext) {
216: if (npTmp->fpos == FPOS_MAX || npTmp->fpos > npLabel->fpos)
217: break;
218:
219: npPrevLabel = npTmp;
220: }
221: }
222: else {
223: /*
224: * Label was not found in the deleted list. Allocate, etc.
225: */
226: if (!(npLabel = (NPLABEL)MyAlloc(sizeof(LABEL))))
227: return NULL;
228:
229: npLabel->id = id;
230: npLabel->idOrig = id;
231: npLabel->fpos = fpos;
232: npLabel->nValueOffset = nValueOffset;
233:
234: if (!(npLabel->pszLabel =
235: (LPTSTR)MyAlloc((lstrlen(pszLabel) + 1) * sizeof(TCHAR)))) {
236: MyFree(npLabel);
237: return NULL;
238: }
239:
240: lstrcpy(npLabel->pszLabel, pszLabel);
241:
242: /*
243: * Find where to insert the new label. This will either be
244: * at the end of the list, or in ascending numerical order
245: * among the new labels.
246: */
247: npPrevLabel = NULL;
248: for (npTmp = *pplHead;
249: npTmp && (npTmp->fpos != FPOS_MAX || npTmp->id < id);
250: npTmp = npTmp->npNext)
251: npPrevLabel = npTmp;
252: }
253:
254: /*
255: * At this point, npLabel points to the label to add, either
256: * transferred from the deleted list, or allocated fresh.
257: * The variable npPrevLabel points to the label to insert
258: * after, or is NULL to indicate that the new label should
259: * be inserted at the head of the list.
260: */
261:
262: /*
263: * If this is the first label in the list, or if the
264: * first label had a greater fpos than the new label,
265: * insert the new label at the head of the list.
266: */
267: if (!npPrevLabel) {
268: npLabel->npNext = *pplHead;
269: *pplHead = npLabel;
270: }
271: /*
272: * Otherwise, insert it either in the middle of the
273: * list or at the end.
274: */
275: else {
276: npLabel->npNext = npPrevLabel->npNext;
277: npPrevLabel->npNext = npLabel;
278: }
279:
280: return npLabel;
281: }
282:
283:
284:
285: /************************************************************************
286: * FindLabel
287: *
288: * Tells you if the named label is in the given include label list.
289: *
290: * Arguments:
291: * LPTSTR pszLabel = The label to find.
292: * NPLABEL plHead = Head of the include list to traverse.
293: *
294: * Returns:
295: * NULL if the label is not found.
296: * Pointer to label structure if the label was found.
297: *
298: *
299: ************************************************************************/
300:
301: NPLABEL FindLabel(
302: LPTSTR pszLabel,
303: NPLABEL plHead)
304: {
305: NPLABEL npLabel;
306:
307: for (npLabel = plHead; npLabel; npLabel = npLabel->npNext) {
308: if (lstrcmp(pszLabel, npLabel->pszLabel) == 0)
309: break;
310: }
311:
312: return npLabel;
313: }
314:
315:
316:
317: /************************************************************************
318: * FindID
319: *
320: * Tells you if the named id is in the given include file buffer.
321: *
322: * Arguments:
323: * INT id = The id to find.
324: * NPLABEL plHead = Head of the label list to use.
325: *
326: * Returns:
327: * NULL if the id was not found.
328: * Pointer to label struct if the id was found.
329: *
330: *
331: ************************************************************************/
332:
333: NPLABEL FindID(
334: INT id,
335: NPLABEL plHead)
336: {
337: NPLABEL npLabel;
338:
339: for (npLabel = plHead; npLabel; npLabel = npLabel->npNext) {
340: if (npLabel->id == id)
341: break;
342: }
343:
344: return npLabel;
345: }
346:
347:
348:
349: /************************************************************************
350: * FindIDInRes
351: *
352: * Tells you if the named id is used by any control in the current
353: * resource list. This also includes searching through the dialog
354: * currently being edited, if there is one.
355: *
356: * Arguments:
357: * INT id = The id to find.
358: *
359: * Returns:
360: * TRUE if the id was found, or FALSE if it was not.
361: *
362: *
363: ************************************************************************/
364:
365: BOOL FindIDInRes(
366: INT id)
367: {
368: INT cControls;
369: PRESLINK prl;
370: PRES pRes;
371: PDIALOGBOXHEADER pdbh;
372: PCONTROLDATA pcd;
373: NPCTYPE npc;
374: BOOL fFound = FALSE;
375:
376: /*
377: * Is there a current dialog? If so, search it first and
378: * we will skip any image for it in the resource list (the
379: * resource list is probably out of date, anyways).
380: */
381: if (gfEditingDlg) {
382: /*
383: * Is the id the same as the current dialog's name?
384: */
385: if (IsOrd(gcd.pszDlgName) && id == (INT)OrdID(gcd.pszDlgName))
386: return TRUE;
387:
388: /*
389: * Loop through the current controls, looking for an id match.
390: */
391: for (npc = npcHead; npc; npc = npc->npcNext)
392: if (npc->id == id)
393: return TRUE;
394: }
395:
396: for (prl = gprlHead; prl && !fFound; prl = prl->prlNext) {
397: /*
398: * Is this a dialog resource and is it NOT the current
399: * dialog being edited? If it is the current dialog,
400: * we skip it because it is probably out of date.
401: */
402: if (prl->fDlgResource && prl != gcd.prl) {
403: if (IsOrd(prl->pszName) && id == (INT)OrdID(prl->pszName)) {
404: fFound = TRUE;
405: }
406: else {
407: pRes = (PRES)GlobalLock(prl->hRes);
408: pdbh = (PDIALOGBOXHEADER)SkipResHeader(pRes);
409: cControls = (INT)pdbh->NumberOfItems;
410: pcd = SkipDialogBoxHeader(pdbh);
411: while (cControls--) {
412: if (id == (INT)pcd->wId) {
413: fFound = TRUE;
414: break;
415: }
416:
417: pcd = SkipControlData(pcd);
418: }
419:
420: GlobalUnlock(prl->hRes);
421: }
422: }
423: }
424:
425: return fFound;
426: }
427:
428:
429:
430: /************************************************************************
431: * DeleteLabel
432: *
433: * Removes the LABEL with text pszLabel from the list of labels in
434: * pplHead, closing up the link, and might add it to the deleted list.
435: *
436: * If the label is one that exists in the include file (fpos is valid)
437: * then the label is added to the pplDelHead list in the proper position
438: * (sorted ascending by fpos). If the label does not exist in the
439: * include file, there is no need to track it and it can be tossed.
440: *
441: * Arguments:
442: * LPTSTR pszLabel = The text of the label to delete.
443: * NPLABEL *pplHead = Pointer to the head of the include list to use.
444: * NPLABEL *pplDelHead = Pointer to the head of the deleted include list.
445: *
446: * Side Effects:
447: * Deletes from the pplHead list.
448: * Can null *pplHead if the last label is deleted.
449: * Can add to the pplDelHead list.
450: * Can free the memory associated with the LABEL and its string.
451: *
452: *
453: ************************************************************************/
454:
455: VOID DeleteLabel(
456: LPTSTR pszLabel,
457: NPLABEL *pplHead,
458: NPLABEL *pplDelHead)
459: {
460: NPLABEL npLabel;
461: NPLABEL npDelLabel;
462: NPLABEL npPrevLabel;
463:
464: npPrevLabel = NULL;
465: for (npLabel = *pplHead; npLabel; npLabel = npLabel->npNext) {
466: if (lstrcmp(pszLabel, npLabel->pszLabel) == 0) {
467: /*
468: * Close up the linked list where the deleted label was.
469: */
470: if (npPrevLabel)
471: npPrevLabel->npNext = npLabel->npNext;
472: else
473: *pplHead = npLabel->npNext;
474:
475: /*
476: * Is this a label that is NOT in the include file?
477: * If so, just toss it away.
478: */
479: if (npLabel->fpos == FPOS_MAX) {
480: MyFree(npLabel->pszLabel);
481: MyFree(npLabel);
482: }
483: /*
484: * Otherwise, it must be added to the deleted list.
485: */
486: else {
487: /*
488: * Search for where the label should be inserted
489: * based on its fpos.
490: */
491: npPrevLabel = NULL;
492: for (npDelLabel = *pplDelHead; npDelLabel;
493: npDelLabel = npDelLabel->npNext) {
494: if (npDelLabel->fpos > npLabel->fpos)
495: break;
496:
497: npPrevLabel = npDelLabel;
498: }
499:
500: /*
501: * If this is the first label in the deleted list, or
502: * if the first label had a greater fpos than the new
503: * label, insert the new label at the head of the list.
504: */
505: if (!npPrevLabel) {
506: npLabel->npNext = *pplDelHead;
507: *pplDelHead = npLabel;
508: }
509: /*
510: * Otherwise, insert it either in the middle of the
511: * list or at the end.
512: */
513: else {
514: npLabel->npNext = npPrevLabel->npNext;
515: npPrevLabel->npNext = npLabel;
516: }
517: }
518:
519: break;
520: }
521:
522: npPrevLabel = npLabel;
523: }
524: }
525:
526:
527:
528: /****************************************************************************
529: * IsSymbol
530: *
531: * This routine returns TRUE if the given string is a valid "C" or "RC"
532: * identifier.
533: *
534: * Valid is: First char is a letter or '_'.
535: *
536: ****************************************************************************/
537:
538: BOOL IsSymbol(
539: LPTSTR pszSym)
540: {
541: register TCHAR ch = *pszSym;
542:
543: return ((ch >= CHAR_CAP_A && ch <= CHAR_CAP_Z) ||
544: (ch >= CHAR_A && ch <= CHAR_Z) ||
545: (ch == CHAR_UNDERLINE));
546: }
547:
548:
549:
550: /************************************************************************
551: * IDToLabel
552: *
553: * This function finds the label with the given id.
554: * The first LABEL in the list with the given id will be found.
555: * The label will be put in pchLabel.
556: * If the id was not found then the id is converted to an ascii
557: * representation and put in pchLabel. This ascii representation
558: * will be in hex notation if hex mode is in effect (unless fHexOK
559: * is FALSE).
560: *
561: * This function special cases the IDOK and IDCANCEL id values.
562: * If there happens to be a label in the include file for these values
563: * then that label will be returned, but if not, either "IDOK" or
564: * "IDCANCEL" will be returned.
565: *
566: * Arguments:
567: * LPTSTR pchLabel - Where to put the label.
568: * INT id - The id of the label to find or match.
569: * BOOL fHexOK - TRUE if hex representations of the id are allowed.
570: *
571: *
572: ************************************************************************/
573:
574: VOID IDToLabel(
575: LPTSTR pchLabel,
576: INT id,
577: BOOL fHexOK)
578: {
579: NPLABEL npLabel;
580:
581: npLabel = FindID(id, plInclude);
582:
583: if (npLabel) {
584: lstrcpy(pchLabel, npLabel->pszLabel);
585: }
586: else {
587: if (id == IDOK && !FindLabel(ids(IDS_IDOK), plInclude)) {
588: lstrcpy(pchLabel, ids(IDS_IDOK));
589: }
590: else if (id == IDCANCEL && !FindLabel(ids(IDS_IDCANCEL), plInclude)) {
591: lstrcpy(pchLabel, ids(IDS_IDCANCEL));
592: }
593: else {
594: if (fHexOK)
595: Myitoa(id, pchLabel);
596: else
597: itoaw(id, pchLabel, 10);
598: }
599: }
600: }
601:
602:
603:
604: /************************************************************************
605: * LabelToID
606: *
607: * This function converts a label string to its associated id value.
608: * It first checks the labels in the current include file for a
609: * match. If it is not found, it then checks for some special values,
610: * like "IDOK", "IDCANCEL" and "(Unused)".
611: *
612: * The return value will be TRUE of the label (symbol) was found, or
613: * FALSE if it was not.
614: *
615: * Arguments:
616: * LPTSTR pszLabel - The symbol to search for.
617: * PINT pID - Where to return the associated id, if found.
618: *
619: ************************************************************************/
620:
621: BOOL LabelToID(
622: LPTSTR pszLabel,
623: PINT pID)
624: {
625: INT id;
626: NPLABEL npLabel;
627:
628: /*
629: * Is it an existing label?
630: */
631: if (npLabel = FindLabel(pszLabel, plInclude)) {
632: id = npLabel->id;
633: }
634: /*
635: * Is it the "unused" symbol?
636: */
637: else if (lstrcmp(pszLabel, ids(IDS_UNUSED)) == 0) {
638: id = IDUNUSED;
639: }
640: /*
641: * How about the special IDOK entry?
642: */
643: else if (lstrcmp(pszLabel, ids(IDS_IDOK)) == 0) {
644: id = IDOK;
645: }
646: /*
647: * How about the special IDCANCEL entry?
648: */
649: else if (lstrcmp(pszLabel, ids(IDS_IDCANCEL)) == 0) {
650: id = IDCANCEL;
651: }
652: else {
653: return FALSE;
654: }
655:
656: *pID = id;
657: return TRUE;
658: }
659:
660:
661:
662: /****************************************************************************
663: * FreeLabels
664: *
665: * This function frees the labels in the label list pointed to by
666: * nppLabels, including the strings. When it is done, the label
667: * list head is set to NULL.
668: *
669: ****************************************************************************/
670:
671: VOID FreeLabels(
672: NPLABEL *nppLabels)
673: {
674: register NPLABEL npl;
675: register NPLABEL nplTemp;
676:
677: npl = *nppLabels;
678:
679: while (npl) {
680: MyFree(npl->pszLabel);
681:
682: nplTemp = npl->npNext;
683:
684: MyFree(npl);
685: npl = nplTemp;
686: }
687:
688: *nppLabels = NULL;
689: }
690:
691:
692:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.