![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rwinc.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 rwinc.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: rwinc.c
14: *
15: * Does the include file reading and writing.
16: *
17: * Functions:
18: *
19: * OpenIncludeFile()
20: * FreeInclude()
21: * WriteInc()
22: * LoadIncludeFile()
23: * GetChar()
24: * ReadChar()
25: * GetLabel()
26: * GetValue()
27: * GetWord()
28: * FindDefine()
29: * GetNextInc()
30: * RWToOffset()
31: * WriteIncChar()
32: * WriteIncFlush()
33: * WriteChangedInc()
34: * WriteDeletedInc()
35: * WriteAddedInc()
36: * WriteSymbol()
37: * WriteIDInc()
38: *
39: * Comments:
40: *
41: ****************************************************************************/
42:
43: #include "dlgedit.h"
44: #include "dlgfuncs.h"
45: #include "dlgextrn.h"
46:
47: #include <ctype.h>
48:
49:
50: /*
51: * Field width that the symbol is printed within. This indirectly
52: * determines where the id value starts, because blanks are added
53: * after the symbol is printed up to this width value.
54: */
55: #define CCHSYMFIELDWIDTH 27
56:
57: /*
58: * Return codes from the file reading functions.
59: */
60: #define READ_OK 1
61: #define READ_EOF 2
62: #define READ_BAD 3
63: #define READ_WRONG 4
64: #define BAD_POINTER ((VOID *)0xFFFF)
65:
66: /*
67: * Return codes from the GetNextInc function.
68: */
69: #define GNI_DONE 0
70: #define GNI_NOCHANGE 1
71: #define GNI_CHANGED 2
72: #define GNI_DELETED 3
73: #define GNI_ADDED 4
74:
75: static BYTE abBuffer[CCHFILEBUFFER]; /* Buffer for read file data. */
76: static TCHAR achBuffer[CCHFILEBUFFER]; /* Unicode buffer for data. */
77: static INT cbBuf; /* Pointer into achBuffer. */
78: static DWORD cchFile; /* Count of characters read. */
79: static DWORD cchFileMax; /* Max characters in file. */
80: static DWORD fposLastDefine; /* Saves location of "#define". */
81: static DWORD fposWordStart; /* Saves start of id value. */
82: static BOOL fAtNewLine; /* At start or \r or \n. */
83: static HANDLE hfInclude; /* The current include file. */
84:
85: STATICFN BOOL LoadIncludeFile(VOID);
86: STATICFN LPTSTR GetChar(VOID);
87: STATICFN LPTSTR ReadChar(VOID);
88: STATICFN INT GetLabel(BOOL *pfDups);
89: STATICFN INT GetValue(PINT pnValue);
90: STATICFN INT GetWord(LPTSTR pch);
91: STATICFN INT FindDefine(VOID);
92: STATICFN INT GetNextInc(NPLABEL *pplReturn, BOOL fFirst);
93: STATICFN BOOL RWToOffset(HANDLE hfWrite, DWORD lOffset);
94: STATICFN BOOL WriteIncChar(HANDLE hfWrite, TCHAR ch);
95: STATICFN BOOL WriteIncFlush(HANDLE hfWrite);
96: STATICFN BOOL WriteChangedInc(HANDLE hfWrite, NPLABEL plInc);
97: STATICFN BOOL WriteDeletedInc(HANDLE hfWrite, NPLABEL plInc);
98: STATICFN BOOL WriteAddedInc(HANDLE hfWrite, NPLABEL plInc);
99: STATICFN BOOL WriteSymbol(HANDLE hfWrite, LPTSTR pszSymbol);
100: STATICFN BOOL WriteIDInc(HANDLE hfWrite, INT id);
101:
102:
103:
104: /****************************************************************************
105: * OpenIncludeFile
106: *
107: * This function attempts to open and load the include file with name
108: * pointed to by pszOpenInclude. If pszOpenInclude is just a file name, and
109: * not a path, then the path is taken from szFullLoadFile. Otherwise
110: * pszOpenInclude itself is used. The full pathname is put in
111: * szFullIncludeFile and pszIncludeFile is set to point to just the file
112: * name in it.
113: *
114: * If fDoOpen is TRUE, the file is opened. If it is FALSE, it is assumed
115: * that hfInc contains the file handle to the opened include file and this
116: * handle is used. In addition, the caller is responsible for closing
117: * any passed in file handle if an error occurs.
118: *
119: * Any existing includes are freed, szFullIncludeFile is set to the full
120: * include path, pszIncludeFile is set to the filename portion of this full
121: * path and hfInclude will contain the file handle to the include file.
122: *
123: * Arguments:
124: * LPTSTR pszOpenInclude - name of the include file to open.
125: *
126: * Returns:
127: * If the load is successful, TRUE is returned. Otherwise,
128: * FALSE is returned.
129: *
130: ****************************************************************************/
131:
132: BOOL OpenIncludeFile(
133: LPTSTR pszOpenInclude)
134: {
135: TCHAR szFullIncludeFileTemp[CCHMAXPATH];
136: HCURSOR hcurSave;
137: BOOL fSuccess = FALSE;
138:
139: hcurSave = SetCursor(hcurWait);
140:
141: if (FileInPath(pszOpenInclude) == pszOpenInclude) {
142: lstrcpy(szFullIncludeFileTemp, szFullResFile);
143: lstrcpy(FileInPath(szFullIncludeFileTemp), pszOpenInclude);
144: }
145: else {
146: lstrcpy(szFullIncludeFileTemp, pszOpenInclude);
147: }
148:
149: /*
150: * Close any existing include file and free memory.
151: */
152: FreeInclude();
153:
154: if ((hfInclude = CreateFile(szFullIncludeFileTemp, GENERIC_READ,
155: FILE_SHARE_READ, NULL, OPEN_EXISTING,
156: FILE_FLAG_SEQUENTIAL_SCAN, NULL)) != (HANDLE)-1) {
157: if (LoadIncludeFile()) {
158: lstrcpy(szFullIncludeFile, szFullIncludeFileTemp);
159: pszIncludeFile = FileInPath(szFullIncludeFile);
160: fSuccess = TRUE;
161: }
162:
163: CloseHandle(hfInclude);
164: }
165:
166: /*
167: * Update the status windows symbol combo box. Update other fields
168: * also, in case the currently selected control's symbol was affected
169: * by the reading of the new include file.
170: */
171: StatusFillSymbolList(plInclude);
172: StatusUpdate();
173:
174: ShowFileStatus(TRUE);
175: SetCursor(hcurSave);
176:
177: return fSuccess;
178: }
179:
180:
181:
182: /************************************************************************
183: * LoadIncludeFile
184: *
185: * This function creates or adds to plInclude with all the #define
186: * statements in the file with handle hfInclude.
187: *
188: * Returns:
189: * TRUE - Load succeeded.
190: * FALSE - Load failed (a read error).
191: *
192: ************************************************************************/
193:
194: STATICFN BOOL LoadIncludeFile(VOID)
195: {
196: INT RetCode;
197: BOOL fDups = FALSE;
198:
199: /*
200: * Set char count, get file cb.
201: */
202: cchFile = 0L;
203: cchFileMax = GetFileSize((HANDLE)hfInclude, NULL);
204: cbBuf = CCHFILEBUFFER;
205: fAtNewLine = TRUE;
206:
207: /*
208: * Loop through and extract all id definitions.
209: */
210: while ((RetCode = FindDefine()) != READ_EOF) {
211: if (RetCode == READ_BAD || (RetCode = GetLabel(&fDups)) == READ_BAD) {
212: Message(MSG_INTERNAL);
213: return FALSE;
214: }
215: }
216:
217: /*
218: * Warn the user if there were duplicate symbols,
219: * or symbols with duplicate ids.
220: */
221: if (fDups)
222: Message(MSG_IDUPIDS);
223:
224: return TRUE;
225: }
226:
227:
228:
229: /****************************************************************************
230: * FindDefine
231: *
232: * This function looks for ^#define[\s\t], that "#define" at the start
233: * of a line and followed by a space or a tab.
234: *
235: * Returns:
236: * READ_OK -> All OK & #define found.
237: * READ_EOF -> All OK, but EOF found before #define.
238: * READ_BAD = Failure on read.
239: *
240: ****************************************************************************/
241:
242: STATICFN INT FindDefine(VOID)
243: {
244: LPTSTR pchIn;
245: LPTSTR pchCmp;
246: BOOL fLastAtNewLine;
247:
248: tryagain:
249:
250: /*
251: * Skip blank lines looking for a newline followed by a '#'.
252: */
253: while (TRUE) {
254: fLastAtNewLine = fAtNewLine;
255: pchIn = GetChar();
256:
257: if (pchIn == NULL)
258: return READ_EOF;
259: else if (pchIn == BAD_POINTER)
260: return READ_BAD;
261: else if (fLastAtNewLine && *pchIn == CHAR_POUND)
262: break;
263: }
264:
265: /*
266: * At this point a newline followed by a '#' has been found.
267: * Begin checking for "define". Save away the file offset,
268: * in case we have really found one.
269: */
270: fposLastDefine = cchFile - 1;
271: pchCmp = ids(IDS_DEFINE);
272: do {
273: pchIn = GetChar();
274:
275: if (pchIn == BAD_POINTER)
276: return READ_BAD;
277: else if (pchIn == NULL || *pchIn != *pchCmp++)
278: goto tryagain;
279: } while (*pchCmp);
280:
281: /*
282: * Finally, look for the trailing space or tab after the "#define".
283: */
284: pchIn = GetChar();
285: if (pchIn == BAD_POINTER)
286: return READ_BAD;
287: else if (pchIn == NULL || (*pchIn != CHAR_SPACE && *pchIn != CHAR_TAB))
288: goto tryagain;
289:
290: return READ_OK;
291: }
292:
293:
294:
295: /************************************************************************
296: * GetLabel
297: *
298: * This function gets the next two words from the file hfInclude and treats
299: * them as a label and id, respectively. It allocates another LABEL
300: * and string to hold this information.
301: *
302: * Arguments:
303: * BOOL *pfDups = Points to a BOOL that will be set to TRUE if AddLabel
304: * finds a duplicate symbol or id.
305: *
306: * Returns:
307: * READ_OK -> All OK.
308: * READ_BAD = Failure on read.
309: *
310: ************************************************************************/
311:
312: STATICFN INT GetLabel(
313: BOOL *pfDups)
314: {
315: INT id;
316: INT RetCode;
317: TCHAR szLabel[CCHTEXTMAX];
318:
319: /*
320: * Get string and ID at current position
321: */
322: switch (RetCode = GetWord(szLabel)) {
323: case READ_OK:
324: if ((RetCode = GetValue(&id)) == READ_OK) {
325: AddLabel(szLabel, id, fposLastDefine,
326: (INT)(fposWordStart - fposLastDefine),
327: &plInclude, &plDelInclude, NULL, pfDups);
328: }
329:
330: break;
331:
332: default:
333: break;
334: }
335:
336: return RetCode;
337: }
338:
339:
340:
341: /************************************************************************
342: * GetWord
343: *
344: * This function uses GetChar to get the next word from the include
345: * file. First it removes tabs and spaces, then it collects everything
346: * to the next white space. Finally it null terminates the word.
347: *
348: * Arguments:
349: * LPTSTR pch - Where to put the word.
350: *
351: * Returns:
352: * READ_OK - a word was found.
353: * READ_EOF - EOF was found.
354: * READ_BAD - Error on Read.
355: * READ_WRONG - Found other than ' ' or '\t' followed by a letter,
356: * number or _, +, -.
357: *
358: ************************************************************************/
359:
360: STATICFN INT GetWord(
361: LPTSTR pch)
362: {
363: TCHAR ch;
364: LPTSTR pchIn;
365:
366: /*
367: * Skip spaces.
368: */
369: while ((pchIn = GetChar()) != NULL && pchIn != BAD_POINTER &&
370: ((ch = *pchIn) == CHAR_SPACE || ch == CHAR_TAB))
371: ;
372:
373: /*
374: * Errors or EOF?
375: */
376: if (pchIn == NULL)
377: return READ_EOF;
378: else if (pchIn == BAD_POINTER)
379: return READ_BAD;
380: if (!iscsym(ch) && ch != CHAR_MINUS && ch != CHAR_PLUS)
381: return READ_WRONG;
382:
383: /*
384: * Save starting location of the word in the file.
385: */
386: fposWordStart = cchFile - 1;
387:
388: /*
389: * Pick out the current word.
390: */
391: do {
392: *pch++ = ch;
393: } while ((pchIn = GetChar()) != NULL && pchIn != BAD_POINTER &&
394: (ch = *pchIn) != CHAR_SPACE && ch != CHAR_TAB &&
395: ch != CHAR_NEWLINE && ch != CHAR_RETURN);
396:
397: /*
398: * Errors or EOF?
399: */
400: if (pchIn == NULL)
401: return READ_WRONG;
402: else if (pchIn == BAD_POINTER)
403: return READ_BAD;
404:
405: /*
406: * Null terminate the word.
407: */
408: *pch = (TCHAR)0;
409:
410: return READ_OK;
411: }
412:
413:
414:
415: /************************************************************************
416: * GetChar
417: *
418: * This function returns a pointer to the next character in the
419: * stream hfInclude. It calls ReadChar to do the actual work.
420: *
421: * As it is reading the stream, it will compress a comment sequence to
422: * a single space. This means that from a slash+asterisk to the next
423: * asterisk+slash and from a pair of slashes to the end of the line all
424: * that will be returned is a single space character.
425: *
426: * Returns:
427: * A pointer to next character in the stream hfInclude.
428: * NULL => End of file.
429: * BAD_POINTER => Problems reading file.
430: *
431: ************************************************************************/
432:
433: STATICFN LPTSTR GetChar(VOID)
434: {
435: register LPTSTR pch;
436:
437: /*
438: * Read the next character.
439: */
440: pch = ReadChar();
441: if (pch == NULL || pch == BAD_POINTER)
442: return pch;
443:
444: /*
445: * Possibly starting a comment?
446: */
447: if (*pch == CHAR_SLASH) {
448: /*
449: * Starting a traditional comment?
450: */
451: if (*(pch + 1) == CHAR_ASTERISK) {
452: /*
453: * Read the '*'.
454: */
455: pch = ReadChar();
456: if (pch == NULL || pch == BAD_POINTER)
457: return pch;
458:
459: /*
460: * Read until the next asterisk+slash is found.
461: */
462: do {
463: pch = ReadChar();
464: if (pch == NULL || pch == BAD_POINTER)
465: return pch;
466: } while (*pch != CHAR_ASTERISK || *(pch + 1) != CHAR_SLASH);
467:
468: /*
469: * Read the final '/'.
470: */
471: pch = ReadChar();
472: if (pch == NULL || pch == BAD_POINTER)
473: return pch;
474:
475: /*
476: * Change it to a space.
477: */
478: *pch = CHAR_SPACE;
479: }
480: /*
481: * Starting a single line comment?
482: */
483: else if (*(pch + 1) == CHAR_SLASH) {
484: /*
485: * Read up to the end of line.
486: */
487: do {
488: pch = ReadChar();
489: if (pch == NULL || pch == BAD_POINTER)
490: return pch;
491: } while (*(pch + 1) != CHAR_RETURN && *(pch + 1) != CHAR_NEWLINE);
492:
493: /*
494: * Convert the last character before the newline into a space.
495: */
496: *pch = CHAR_SPACE;
497: }
498: }
499:
500: return pch;
501: }
502:
503:
504:
505: /************************************************************************
506: * ReadChar
507: *
508: * This function returns a pointer to the next character in the
509: * stream hfInclude, but does it in a buffered fashion. That is, abBuffer
510: * is filled from hfInclude and pointers are returned to there.
511: * Note that after ReadChar is called, all previous pointers
512: * returned are meaningless.
513: *
514: * Returns:
515: * A pointer to next character in the stream hfInclude.
516: * NULL => End of file.
517: * BAD_POINTER => Problems reading file.
518: *
519: * Comments:
520: * May cause abBuffer to be filled from file with handle hfInclude.
521: * cbBuf is changed.
522: * cchFile is changed.
523: * Sets fAtNewLine = TRUE if char returned is '\n' or '\r', or FALSE
524: * otherwise. Not changed unless a character is returned.
525: *
526: ************************************************************************/
527:
528: STATICFN LPTSTR ReadChar(VOID)
529: {
530: register LPTSTR pch;
531: INT cbRead;
532:
533: if (cchFile >= cchFileMax)
534: return NULL;
535:
536: if (cbBuf >= CCHFILEBUFFER) {
537: if ((cbRead = _lread((HFILE)hfInclude, abBuffer, CCHFILEBUFFER)) == -1)
538: return BAD_POINTER;
539:
540: MultiByteToWideChar(CP_ACP, 0, abBuffer, cbRead, achBuffer,
541: CCHFILEBUFFER);
542:
543: cbBuf = 0;
544: }
545:
546: pch = achBuffer + cbBuf;
547: cbBuf++;
548: cchFile++;
549:
550: if (*pch == CHAR_DOSEOF) {
551: cchFile = cchFileMax;
552: return NULL;
553: }
554:
555: fAtNewLine = (*pch == CHAR_RETURN || *pch == CHAR_NEWLINE) ? TRUE : FALSE;
556:
557: return pch;
558: }
559:
560:
561:
562: /************************************************************************
563: * GetValue
564: *
565: * This function reads the next word in the file hfInclude with GetWord
566: * and converts that word to a number.
567: *
568: * If the second character of the word is an 'x' or 'X', the word is
569: * assumed to be a hex number and it is converted appropriately.
570: *
571: * Arguments:
572: * npsValue - Where to put the value of the next word in file.
573: *
574: * Returns:
575: * READ_OK - success.
576: * READ_BAD - am error occured.
577: * READ_WRONG - Something other than a number was found.
578: *
579: ************************************************************************/
580:
581: STATICFN INT GetValue(
582: PINT pnValue)
583: {
584: TCHAR achValue[CCHTEXTMAX];
585: LPTSTR pch;
586: INT RetValue;
587:
588: *pnValue = 0;
589: if ((RetValue = GetWord(achValue)) != READ_OK)
590: return RetValue;
591:
592: /*
593: * Verify we have only a number.
594: */
595: pch = achValue;
596: if (pch[1] == CHAR_CAP_X || pch[1] == CHAR_X) {
597: if (*pch != CHAR_0) {
598: RetValue = READ_WRONG;
599: }
600: else {
601: for (pch += 2; *pch; pch++) {
602: if (!iswxdigit(*pch)) {
603: RetValue = READ_WRONG;
604: break;
605: }
606: }
607:
608: if (RetValue == READ_OK)
609: *pnValue = axtoi(&achValue[2]);
610: }
611: }
612: else {
613: if (!iswdigit(*pch) && *pch != CHAR_MINUS && *pch != CHAR_PLUS) {
614: RetValue = READ_WRONG;
615: }
616: else {
617: for (pch++; *pch; pch++) {
618: if (!iswdigit(*pch)) {
619: RetValue = READ_WRONG;
620: break;
621: }
622: }
623:
624: if (RetValue == READ_OK)
625: *pnValue = awtoi(achValue);
626: }
627: }
628:
629: return RetValue;
630: }
631:
632:
633:
634: /************************************************************************
635: * FreeInclude
636: *
637: * This function frees the memory associated with an include file,
638: * sets global variables to match, and closes the currently open
639: * include file. It frees plInclude, plDelInclude and all the LABELs in them.
640: * It sets gfIncChged to FALSE, sets pszIncludeFile to NULL, and
641: * closes any open include file.
642: *
643: ************************************************************************/
644:
645: VOID FreeInclude(VOID)
646: {
647: FreeLabels(&plInclude);
648: FreeLabels(&plDelInclude);
649: gfIncChged = FALSE;
650: pszIncludeFile = NULL;
651: }
652:
653:
654:
655: /************************************************************************
656: * WriteInc
657: *
658: * This function writes the labels in plInclude to an include file.
659: *
660: * Arguments:
661: * HANDLE hfWrite - handle to the file to write to.
662: *
663: * Returns:
664: * TRUE if successful, FALSE if not.
665: *
666: ************************************************************************/
667:
668: BOOL WriteInc(
669: HANDLE hfWrite)
670: {
671: INT nGNIRet;
672: NPLABEL plInc;
673: BOOL fEOF;
674:
675: /*
676: * Is there an include file already specified? If so,
677: * open it. If not, we are effectively at EOF now.
678: */
679: if (pszIncludeFile) {
680: if ((hfInclude = CreateFile(szFullIncludeFile, GENERIC_READ,
681: FILE_SHARE_READ, NULL, OPEN_EXISTING,
682: FILE_FLAG_SEQUENTIAL_SCAN, NULL)) == (HANDLE)-1) {
683: //if the include file is missing or locked...
684: return FALSE;
685: }
686:
687: fEOF = FALSE;
688: }
689: else {
690: fEOF = TRUE;
691: }
692:
693: cchFile = 0;
694: cbWritePos = 0;
695: cbBuf = CCHFILEBUFFER;
696: fAtNewLine = TRUE;
697:
698: /*
699: * Loop through all the includes.
700: */
701: nGNIRet = GetNextInc(&plInc, TRUE);
702: while (nGNIRet != GNI_DONE) {
703: switch (nGNIRet) {
704: case GNI_NOCHANGE:
705: break;
706:
707: case GNI_CHANGED:
708: if (!WriteChangedInc(hfWrite, plInc))
709: return FALSE;
710:
711: break;
712:
713: case GNI_DELETED:
714: if (!WriteDeletedInc(hfWrite, plInc))
715: return FALSE;
716:
717: break;
718:
719: case GNI_ADDED:
720: /*
721: * The first time we reach an added label, we know that
722: * there are no more changed or deleted ones to handle
723: * so we read/write up to the end of the old include file.
724: * This only has to be done once.
725: */
726: if (!fEOF) {
727: if (!RWToOffset(hfWrite, FPOS_MAX))
728: return FALSE;
729:
730: fEOF = TRUE;
731:
732: /*
733: * In the unlikely case that the read include file
734: * does not end with a carriage return and/or
735: * linefeed character, add them before beginning
736: * to write added labels. This ensures that the
737: * first label added always starts on a new line.
738: */
739: if (!fAtNewLine) {
740: if (!WriteIncChar(hfWrite, CHAR_RETURN))
741: return FALSE;
742:
743: if (!WriteIncChar(hfWrite, CHAR_NEWLINE))
744: return FALSE;
745: }
746: }
747:
748: if (!WriteAddedInc(hfWrite, plInc))
749: return FALSE;
750:
751: break;
752: }
753:
754: nGNIRet = GetNextInc(&plInc, FALSE);
755: }
756:
757: /*
758: * Write the rest of the file, if there is any left.
759: */
760: if (!fEOF)
761: if (!RWToOffset(hfWrite, FPOS_MAX))
762: return FALSE;
763:
764: /*
765: * Flush any remaining characters in the write buffer.
766: */
767: if (!WriteIncFlush(hfWrite))
768: return FALSE;
769:
770: /*
771: * If we just opened the old include file, close it.
772: */
773: if (pszIncludeFile)
774: CloseHandle(hfInclude);
775:
776: return TRUE;
777: }
778:
779:
780:
781: /************************************************************************
782: * GetNextInc
783: *
784: * This routine will return the next label in the plInclude and plDelInclude
785: * linked lists, as well as the status of the returned label.
786: *
787: * The labels will be returned in order based upon their location in the
788: * lists, which is their order found in the include file if their fpos
789: * field is not FPOS_MAX. This routine looks at the next label in both the
790: * plInclude and plDelInclude lists and returns the one with the lowest
791: * fpos. Labels are returned from plInclude and plDelInclude in order of
792: * their fpos until all have been returned with a valid fpos. After this,
793: * all new includes are returned from plInclude.
794: *
795: * Call it with fFirst equal to TRUE to initialize it.
796: *
797: * Arguments:
798: * NPLABEL *pplReturn - label to return.
799: * BOOL fFirst - TRUE if initializing.
800: *
801: * Returns:
802: * GNI_DONE - No more labels exist.
803: * GNI_NOCHANGE - An existing label is being returned.
804: * GNI_CHANGED - An existing label with a changed id is being returned.
805: * GNI_DELETED - A deleted label is being returned.
806: * GNI_ADDED - An added label is being returned.
807: *
808: ************************************************************************/
809:
810: STATICFN INT GetNextInc(
811: NPLABEL *pplReturn,
812: BOOL fFirst)
813: {
814: static NPLABEL plCur;
815: static NPLABEL plDelCur;
816:
817: /*
818: * Initialize if this is the first time.
819: */
820: if (fFirst) {
821: plCur = plInclude;
822: plDelCur = plDelInclude;
823: }
824:
825: /*
826: * Are we out of valid includes?
827: */
828: if (!plCur) {
829: /*
830: * If there are deleted ones left, return the next one.
831: * Otherwise we are done.
832: */
833: if (plDelCur) {
834: *pplReturn = plDelCur;
835: plDelCur = plDelCur->npNext;
836: return GNI_DELETED;
837: }
838: else {
839: return GNI_DONE;
840: }
841: }
842: /*
843: * Have we reached the added includes (fpos == FPOS_MAX)?
844: */
845: else if (plCur->fpos == FPOS_MAX) {
846: /*
847: * If there are deleted ones remaining, return them first.
848: * Otherwise, return the next added one.
849: */
850: if (plDelCur) {
851: *pplReturn = plDelCur;
852: plDelCur = plDelCur->npNext;
853: return GNI_DELETED;
854: }
855: else {
856: *pplReturn = plCur;
857: plCur = plCur->npNext;
858: return GNI_ADDED;
859: }
860: }
861: else {
862: /*
863: * Return either the next label or the next deleted label,
864: * based on whether there are any deleted labels and who
865: * has the lowest file position (fpos).
866: */
867: if (plDelCur && plDelCur->fpos < plCur->fpos) {
868: *pplReturn = plDelCur;
869: plDelCur = plDelCur->npNext;
870: return GNI_DELETED;
871: }
872: else {
873: *pplReturn = plCur;
874: plCur = plCur->npNext;
875: /*
876: * Return either GNI_CHANGE or GNI_NOCHANGE based on
877: * whether the original id value has been changed.
878: */
879: return ((*pplReturn)->id == (*pplReturn)->idOrig) ?
880: GNI_NOCHANGE : GNI_CHANGED;
881: }
882: }
883: }
884:
885:
886:
887: /************************************************************************
888: * RWToOffset
889: *
890: * This routine reads from the current include file and writes to the
891: * hfWrite file up to the lOffset position in the file. If lOffset is
892: * set to FPOS_MAX, reads/writes are performed up to the end of the
893: * read file.
894: *
895: * Arguments:
896: * HANDLE hfWrite - handle to the file to write to.
897: * DWORD lOffset - where to write up to.
898: *
899: * Returns:
900: * TRUE if successful, FALSE if not.
901: *
902: * Comments:
903: * This routine relies on cchFile and cchFileMax to be properly updated
904: * by the reading and writing routines.
905: *
906: ************************************************************************/
907:
908: STATICFN BOOL RWToOffset(
909: HANDLE hfWrite,
910: DWORD lOffset)
911: {
912: LPTSTR pchIn;
913: DWORD cbWrite;
914:
915: if (lOffset == FPOS_MAX)
916: lOffset = cchFileMax;
917:
918: for (cbWrite = lOffset - cchFile; cbWrite; cbWrite--) {
919: /*
920: * NULL can be returned if there is an EOF character found in
921: * the file. This is not an error, and we will stop reading
922: * and writing at this point.
923: */
924: if ((pchIn = ReadChar()) == NULL)
925: return TRUE;
926:
927: /*
928: * If BAD_POINTER is returned, there was an error reading the
929: * include file.
930: */
931: if (pchIn == BAD_POINTER)
932: return FALSE;
933:
934: /*
935: * Write out the character.
936: */
937: if (!WriteIncChar(hfWrite, *pchIn))
938: return FALSE;
939: }
940:
941: return TRUE;
942: }
943:
944:
945:
946: /************************************************************************
947: * WriteIncChar
948: *
949: * This routine writes a character (ch) to the hfWrite file, doing it in a
950: * buffered fashion. Because it is buffered, before closing the file
951: * any remaining characters in the buffer must be "flushed" to disk.
952: *
953: * Arguments:
954: * HANDLE hfWrite - handle to the file to write to.
955: * TCHAR ch - character to write.
956: *
957: * Returns:
958: * TRUE if successful, FALSE if not.
959: *
960: * Comments:
961: * The globals gachWriteBuffer and cbWritePos are updated by this routine.
962: *
963: ************************************************************************/
964:
965: STATICFN BOOL WriteIncChar(
966: HANDLE hfWrite,
967: TCHAR ch)
968: {
969: INT cbWritten;
970:
971: gachWriteBuffer[cbWritePos++] = ch;
972:
973: /*
974: * Is the buffer full?
975: */
976: if (cbWritePos == CCHFILEBUFFER) {
977: CHAR abWriteBuffer[CCHFILEBUFFER];
978: BOOL fDefCharUsed;
979:
980: WideCharToMultiByte(CP_ACP, 0, gachWriteBuffer, CCHFILEBUFFER,
981: abWriteBuffer, CCHFILEBUFFER, NULL, &fDefCharUsed);
982:
983: cbWritten = (INT)_lwrite((HFILE)hfWrite, abWriteBuffer, cbWritePos);
984: if (cbWritten != cbWritePos)
985: return FALSE;
986:
987: cbWritePos = 0;
988: }
989:
990: return TRUE;
991: }
992:
993:
994:
995: /************************************************************************
996: * WriteIncFlush
997: *
998: * This routine flushes the write buffer. This must be done before
999: * the file is closed or data can be lost.
1000: *
1001: * Arguments:
1002: * HANDLE hfWrite - handle to the file to write to.
1003: *
1004: * Returns:
1005: * TRUE if successful, FALSE if not.
1006: *
1007: * Comments:
1008: * The global cbWritePos is updated by this routine.
1009: *
1010: ************************************************************************/
1011:
1012: STATICFN BOOL WriteIncFlush(
1013: HANDLE hfWrite)
1014: {
1015: INT cbWritten;
1016:
1017: /*
1018: * Are any bytes remaining in the buffer?
1019: */
1020: if (cbWritePos) {
1021: CHAR abWriteBuffer[CCHFILEBUFFER];
1022: BOOL fDefCharUsed;
1023:
1024: WideCharToMultiByte(CP_ACP, 0, gachWriteBuffer, cbWritePos,
1025: abWriteBuffer, CCHFILEBUFFER, NULL, &fDefCharUsed);
1026:
1027: cbWritten = (INT)_lwrite((HFILE)hfWrite, abWriteBuffer, cbWritePos);
1028: if (cbWritten != cbWritePos)
1029: return FALSE;
1030:
1031: cbWritePos = 0;
1032: }
1033:
1034: return TRUE;
1035: }
1036:
1037:
1038:
1039: /************************************************************************
1040: * WriteChangedInc
1041: *
1042: * This routine writes out a label that has had its id changed since the
1043: * include file was last read.
1044: *
1045: * Arguments:
1046: * HANDLE hfWrite - File to write to.
1047: * NPLABEL plInc - Label to write.
1048: *
1049: * Returns:
1050: * TRUE if successful, FALSE if not.
1051: *
1052: * History:
1053: * 03/13/90 Byron Dazey - Created.
1054: ************************************************************************/
1055:
1056: STATICFN BOOL WriteChangedInc(
1057: HANDLE hfWrite,
1058: NPLABEL plInc)
1059: {
1060: TCHAR ch;
1061: LPTSTR pchIn;
1062:
1063: if (!RWToOffset(hfWrite, plInc->fpos + plInc->nValueOffset))
1064: return FALSE;
1065:
1066: /*
1067: * Consume the old id value (up to the next space, tab,
1068: * beginning of a comment, newline or return).
1069: */
1070: while ((pchIn = ReadChar()) != NULL && pchIn != BAD_POINTER &&
1071: (ch = *pchIn) != CHAR_SPACE && ch != CHAR_TAB &&
1072: ch != CHAR_SLASH && ch != CHAR_NEWLINE && ch != CHAR_RETURN)
1073: ;
1074:
1075: /*
1076: * It is an error if ReadChar returns BAD_POINTER. Note that it
1077: * is NOT an error if it reaches EOF (and returns NULL).
1078: */
1079: if (pchIn == BAD_POINTER)
1080: return FALSE;
1081:
1082: /*
1083: * Write the new one.
1084: */
1085: if (!WriteIDInc(hfWrite, plInc->id))
1086: return FALSE;
1087:
1088: /*
1089: * Remember to write the last character read after the old value.
1090: */
1091: if (pchIn != NULL)
1092: if (!WriteIncChar(hfWrite, *pchIn))
1093: return FALSE;
1094:
1095: return TRUE;
1096: }
1097:
1098:
1099:
1100: /************************************************************************
1101: * WriteDeletedInc
1102: *
1103: * This routine deletes a label in the include file, closing up the
1104: * space. The entire line will be deleted, unless a comment is found
1105: * after the id value. If so, the comment and following characters will
1106: * be left.
1107: *
1108: * Arguments:
1109: * HANDLE hfWrite - File to write to.
1110: * NPLABEL plInc - Label to delete.
1111: *
1112: * Returns:
1113: * TRUE if successful, FALSE if not.
1114: *
1115: * History:
1116: * 03/13/90 Byron Dazey - Created.
1117: ************************************************************************/
1118:
1119: STATICFN BOOL WriteDeletedInc(
1120: HANDLE hfWrite,
1121: NPLABEL plInc)
1122: {
1123: register INT i;
1124: TCHAR ch;
1125: LPTSTR pchIn;
1126:
1127: /*
1128: * Read and write up to the #define to be deleted.
1129: */
1130: if (!RWToOffset(hfWrite, plInc->fpos))
1131: return FALSE;
1132:
1133: /*
1134: * Consume up to the id value.
1135: */
1136: for (i = plInc->nValueOffset; i; i--)
1137: if ((pchIn = ReadChar()) == NULL || pchIn == BAD_POINTER)
1138: return FALSE;
1139:
1140: /*
1141: * Consume the id value and following characters up to the end of
1142: * the line or the beginning of a comment.
1143: */
1144: while ((pchIn = ReadChar()) != NULL && pchIn != BAD_POINTER &&
1145: (ch = *pchIn) != CHAR_NEWLINE && ch != CHAR_RETURN &&
1146: ch != CHAR_SLASH)
1147: ;
1148:
1149: if (pchIn == BAD_POINTER)
1150: return FALSE;
1151:
1152: /*
1153: * We are done if we have reached EOF.
1154: */
1155: if (pchIn == NULL)
1156: return TRUE;
1157:
1158: /*
1159: * If the beginning of a comment was found, be sure to write the
1160: * character back out and leave the rest of the comment.
1161: */
1162: if (ch == CHAR_SLASH) {
1163: if (!WriteIncChar(hfWrite, ch))
1164: return FALSE;
1165: }
1166: else {
1167: /*
1168: * At this point either a newline or a return was found
1169: * and we are going to consume it. We also want to check
1170: * for a return following the newline, or a newline
1171: * following the return and consume it also.
1172: */
1173: if ((ch == CHAR_NEWLINE && *(pchIn + 1) == CHAR_RETURN) ||
1174: (ch == CHAR_RETURN && *(pchIn + 1) == CHAR_NEWLINE))
1175: if (ReadChar() == BAD_POINTER)
1176: return FALSE;
1177: }
1178:
1179: return TRUE;
1180: }
1181:
1182:
1183:
1184: /************************************************************************
1185: * WriteAddedInc
1186: *
1187: * Adds a label to the new include file.
1188: *
1189: * Arguments:
1190: * HANDLE hfWrite - File to write to.
1191: * NPLABEL plInc - Label to add.
1192: *
1193: * Returns:
1194: * TRUE if successful, FALSE if not.
1195: *
1196: * History:
1197: * 03/13/90 Byron Dazey - Created.
1198: ************************************************************************/
1199:
1200: STATICFN BOOL WriteAddedInc(
1201: HANDLE hfWrite,
1202: NPLABEL plInc)
1203: {
1204: register LPTSTR psz;
1205:
1206: /*
1207: * Write the "#define " string.
1208: */
1209: psz = ids(IDS_POUNDDEFINE);
1210: while (*psz)
1211: if (!WriteIncChar(hfWrite, *psz++))
1212: return FALSE;
1213:
1214: /*
1215: * Write the symbol, followed by a space.
1216: */
1217: if (!WriteSymbol(hfWrite, plInc->pszLabel))
1218: return FALSE;
1219: if (!WriteIncChar(hfWrite, CHAR_SPACE))
1220: return FALSE;
1221:
1222: /*
1223: * Write the id, followed by a carriage return and newline.
1224: */
1225: if (!WriteIDInc(hfWrite, plInc->id))
1226: return FALSE;
1227: if (!WriteIncChar(hfWrite, CHAR_RETURN))
1228: return FALSE;
1229: if (!WriteIncChar(hfWrite, CHAR_NEWLINE))
1230: return FALSE;
1231:
1232: return TRUE;
1233: }
1234:
1235:
1236:
1237: /************************************************************************
1238: * WriteSymbol
1239: *
1240: * Writes out a "#define DID_xxx " string to hfWrite. If the symbol
1241: * is smaller than CCHSYMFIELDWIDTH, it will be padded with spaces out
1242: * to this width.
1243: *
1244: * Arguments:
1245: * HANDLE hfWrite - handle to the file to write to.
1246: * LPTSTR pszSymbol - symbol to write.
1247: *
1248: * Returns:
1249: * TRUE if successful, FALSE if not.
1250: *
1251: ************************************************************************/
1252:
1253: STATICFN BOOL WriteSymbol(
1254: HANDLE hfWrite,
1255: LPTSTR pszSymbol)
1256: {
1257: register INT cch;
1258:
1259: /*
1260: * Write the symbol.
1261: */
1262: cch = 0;
1263: while (*pszSymbol) {
1264: if (!WriteIncChar(hfWrite, *pszSymbol++))
1265: return FALSE;
1266:
1267: cch++;
1268: }
1269:
1270: /*
1271: * Pad the field with blanks out to CCHSYMFIELDWIDTH, if necessary.
1272: */
1273: if (cch < CCHSYMFIELDWIDTH) {
1274: cch = CCHSYMFIELDWIDTH - cch;
1275: while (cch--)
1276: if (!WriteIncChar(hfWrite, CHAR_SPACE))
1277: return FALSE;
1278: }
1279:
1280: return TRUE;
1281: }
1282:
1283:
1284:
1285: /************************************************************************
1286: * WriteIDInc
1287: *
1288: * Writes out an id value to the hfWrite file. The format will be in
1289: * either hex or decimal, depending on the current mode.
1290: *
1291: * Arguments:
1292: * HANDLE hfWrite - File to write to.
1293: * INT id - ID to write.
1294: *
1295: * Returns:
1296: * TRUE if successful, FALSE if not.
1297: *
1298: ************************************************************************/
1299:
1300: STATICFN BOOL WriteIDInc(
1301: HANDLE hfWrite,
1302: INT id)
1303: {
1304: register LPTSTR psz;
1305: TCHAR szValue[CCHIDMAX + 1];
1306:
1307: Myitoa(id, szValue);
1308:
1309: psz = szValue;
1310: while (*psz)
1311: if (!WriteIncChar(hfWrite, *psz++))
1312: return FALSE;
1313:
1314: return TRUE;
1315: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.