source: trunk/tools/fastdep/fastdep.c@ 3676

Last change on this file since 3676 was 3676, checked in by bird, 25 years ago

Corrected bug in textbufferCreate. It failed creating buffers on empty files.
File size: 86.2 KB
Line 
1/* $Id: fastdep.c,v 1.21 2000-06-08 16:27:14 bird Exp $
2 *
3 * Fast dependents. (Fast = Quick and Dirty!)
4 *
5 * Copyright (c) 1999-2000 knut st. osmundsen
6 *
7 * Project Odin Software License can be found in LICENSE.TXT
8 *
9 */
10
11/*******************************************************************************
12* Defined Constants And Macros *
13*******************************************************************************/
14#define INCL_DOSERRORS
15#define INCL_FILEMGR
16
17
18/*******************************************************************************
19* Header Files *
20*******************************************************************************/
21#include <os2.h>
22#include <stdio.h>
23#include <string.h>
24#include <stdlib.h>
25#include <direct.h>
26
27#include "avl.h"
28
29#ifndef INLINE
30# if defined(__IBMC__)
31# define INLINE _Inline
32# elif defined(__IBMCPP__)
33# define INLINE inline
34# else
35# error "unknown compiler - inline keyword unknown!"
36# endif
37#endif
38
39/*
40 * This following section is used while testing fastdep.
41 * stdio.h should be included; string.h never included.
42 */
43/*
44#include <stdio.h>
45#include <stdlib.h>
46#include <string.h>
47*/
48
49#if 1
50#include <stdio.h>
51#else
52#include <string.h>
53#include <string.h>
54#endif
55
56/*
57 */ /* */ /*
58#include <string.h>
59 */
60#if 1
61# if 1
62 #if 0
63# include <string.h>
64 #else
65# if 1
66 #if 1
67 #if 0
68# include <string.h>
69 #else /* */ /*
70*/
71 # include <stdio.h>
72 #endif
73 #endif
74 #endif
75 #endif
76 #endif
77#endif
78
79/*******************************************************************************
80* Structures and Typedefs *
81*******************************************************************************/
82typedef struct _Options
83{
84 const char * pszInclude;
85 const char * pszExclude;
86 BOOL fExcludeAll;
87 const char * pszObjectExt;
88 const char * pszObjectDir;
89 BOOL fObjectDir; /* replace object directory? */
90 const char * pszRsrcExt;
91 BOOL fObjRule;
92 BOOL fNoObjectPath;
93 BOOL fSrcWhenObj;
94 BOOL fAppend; /* append to the output file, not overwrite it. */
95 BOOL fCheckCyclic; /* allways check for cylic dependency before inserting an dependent. */
96 BOOL fCacheSearchDirs; /* cache entire search dirs. */
97} OPTIONS, *POPTIONS;
98
99
100/*
101 * Language specific analysis functions type.
102 */
103typedef int ( _FNLANG) (const char *pszFilename, const char *pszNormFilename,
104 void *pvFile, BOOL fHeader, POPTIONS pOptions);
105typedef _FNLANG *PFNLANG;
106
107
108/**
109 * This struct holds the static configuration of the util.
110 */
111typedef struct _ConfigEntry
112{
113 const char **papszExts; /* Pointer to an array of pointer to extentions for this handler. */
114 /* If NULL this is the last entry. */
115 int iFirstHdr; /* Index into the papszExts array of the first headerfile/copybook. */
116 /* Set it to the NULL element of the array if no headers for this extention. */
117 /* A non-header file may get a object rule. */
118 PFNLANG pfn; /* Pointer to handler function. */
119} CONFIGENTRY, *PCONFIGENTRY;
120
121
122/**
123 * Dependant Rule
124 */
125typedef struct _DepRule
126{
127 AVLNODECORE avlCore;
128 char * pszRule; /* Pointer to rule name */
129 int cDeps; /* Entries in the dependant array. */
130 char ** papszDep; /* Pointer to an array of pointers to dependants. */
131} DEPRULE, *PDEPRULE;
132
133
134/**
135 * Filename cache entry.
136 */
137#define FCACHEENTRY AVLNODECORE
138#define PFCACHEENTRY PAVLNODECORE
139
140
141/*******************************************************************************
142* Internal Functions *
143*******************************************************************************/
144static void syntax(void);
145static int makeDependent(const char *pszFilename, POPTIONS pOptions);
146
147int langC_CPP(const char *pszFilename, const char *pszNormFilename, void *pvFile, BOOL fHeader, POPTIONS pOptions);
148int langAsm(const char *pszFilename, const char *pszNormFilename, void *pvFile, BOOL fHeader, POPTIONS pOptions);
149int langRC(const char *pszFilename, const char *pszNormFilename, void *pvFile, BOOL fHeader, POPTIONS pOptions);
150int langCOBOL(const char *pszFilename, const char *pszNormFilename, void *pvFile, BOOL fHeader, POPTIONS pOptions);
151
152
153/* string operations */
154static int strnicmpwords(const char *pszS1, const char *pszS2, int cch);
155
156/* file operations */
157static char *fileNormalize(char *pszFilename);
158static char *fileNormalize2(const char *pszFilename, char *pszBuffer);
159 char *filePath(const char *pszFilename, char *pszBuffer);
160static char *filePathSlash(const char *pszFilename, char *pszBuffer);
161static char *filePathSlash2(const char *pszFilename, char *pszBuffer);
162static char *fileName(const char *pszFilename, char *pszBuffer);
163static char *fileNameNoExt(const char *pszFilename, char *pszBuffer);
164static char *fileExt(const char *pszFilename, char *pszBuffer);
165
166/* filecache operations */
167static BOOL filecacheAddFile(const char *pszFilename);
168static BOOL filecacheAddDir(const char *pszDir);
169INLINE BOOL filecacheFind(const char *pszFilename);
170INLINE BOOL filecacheIsDirCached(const char *pszDir);
171
172/* pathlist operations */
173static char *pathlistFindFile(const char *pszPathList, const char *pszFilename, char *pszBuffer, POPTIONS pOptions);
174static BOOL pathlistFindFile2(const char *pszPathList, const char *pszFilename, POPTIONS pOptions);
175
176/* word operations */
177static char *findEndOfWord(char *psz);
178#if 0 /* not used */
179static char *findStartOfWord(char *psz, const char *pszStart);
180#endif
181
182/* file helpers */
183static signed long fsize(FILE *phFile);
184
185/* text helpers */
186INLINE char *trim(char *psz);
187INLINE char *trimR(char *psz);
188
189/* textbuffer */
190static void *textbufferCreate(const char *pszFilename);
191static void textbufferDestroy(void *pvBuffer);
192static char *textbufferNextLine(void *pvBuffer, char *psz);
193static char *textbufferGetNextLine(void *pvBuffer, void **ppv, char *pszLineBuffer, int cchLineBuffer);
194
195/* depend workers */
196static BOOL depReadFile(const char *pszFilename, POPTIONS pOptions);
197static BOOL depWriteFile(const char *pszFilename);
198static void depRemoveAll(void);
199static void *depAddRule(const char *pszRulePath, const char *pszName, const char *pszExt);
200static BOOL depAddDepend(void *pvRule, const char *pszDep, BOOL fCheckCyclic);
201#if 0 /* not used */
202static BOOL depCleanFile(const char *pszFilename);
203#endif
204static BOOL depCheckCyclic(PDEPRULE pdepRule, const char *pszDep);
205
206
207/*******************************************************************************
208* Global Variables *
209*******************************************************************************/
210/*
211 * Pointer to the list of dependencies.
212 */
213static PDEPRULE pdepTree = NULL;
214
215
216/*
217 * Filecache - tree starts here.
218 */
219static PFCACHEENTRY pfcTree = NULL;
220static unsigned cfcNodes = 0;
221static PFCACHEENTRY pfcDirTree = NULL;
222
223
224/*
225 * Current directory stuff
226 */
227static char szCurDir[CCHMAXPATH];
228static int aiSlashes[CCHMAXPATH];
229static int cSlashes;
230
231
232/*
233 * Environment variables used.
234 * (These has the correct case.)
235 */
236static char * pszIncludeEnv;
237
238
239/*
240 * Configuration stuff.
241 */
242static const char pszDefaultDepFile[] = ".depend";
243static const char *apszExtC_CPP[] = {"c", "sqc", "cpp", "h", "hpp", NULL};
244static const char *apszExtAsm[] = {"asm", "inc", NULL};
245static const char *apszExtRC[] = {"rc", "orc", "dlg", NULL};
246static const char *apszExtCOBOL[] = {"cbl", "cob", "sqb", NULL};
247static CONFIGENTRY aConfig[] =
248{
249 {
250 apszExtC_CPP,
251 3,
252 langC_CPP,
253 },
254
255 {
256 apszExtAsm,
257 1,
258 langAsm,
259 },
260
261 {
262 apszExtRC,
263 2,
264 langRC,
265 },
266
267 {
268 apszExtCOBOL,
269 3,
270 langCOBOL,
271 },
272
273 /* terminating entry */
274 {
275 NULL,
276 -1,
277 NULL
278 }
279};
280
281
282/**
283 * Main function.
284 * @returns 0 on success.
285 * -n count of failiures.
286 * @param
287 * @param
288 * @equiv
289 * @precond
290 * @methdesc
291 * @result
292 * @time
293 * @sketch
294 * @algo
295 * @remark
296 */
297int main(int argc, char **argv)
298{
299 int rc = 0;
300 int argi = 1;
301 int i;
302 char * psz;
303 char * psz2;
304 const char *pszDepFile = pszDefaultDepFile;
305 char achBuffer[4096];
306
307 static char szObjectDir[CCHMAXPATH];
308 static char szObjectExt[64] = "obj";
309 static char szRsrcExt[64] = "res";
310 static char szInclude[32768] = ";";
311 static char szExclude[32768] = ";";
312
313 OPTIONS options =
314 {
315 szInclude, /* pszInclude */
316 szExclude, /* pszExclude */
317 FALSE, /* fExcludeAll */
318 szObjectExt, /* pszObjectExt */
319 szObjectDir, /* pszObjectDir */
320 FALSE, /* fObjectDir */
321 szRsrcExt, /* pszRsrcExt */
322 TRUE, /* fObjRule */
323 FALSE, /* fNoObjectPath */
324 TRUE, /* fSrcWhenObj */
325 FALSE, /* fAppend */
326 TRUE, /* fCheckCyclic */
327 TRUE /* fCacheSearchDirs */
328 };
329
330 szObjectDir[0] = '\0';
331
332 if (argc == 1)
333 {
334 syntax();
335 return -87;
336 }
337
338 /*
339 * Initiate current directory stuff
340 */
341 if (_getcwd(szCurDir, sizeof(szCurDir)) == NULL)
342 {
343 fprintf(stderr, "fatal error: failed to get current directory\n");
344 return -88;
345 }
346 strlwr(szCurDir);
347 aiSlashes[0] = 0;
348 for (i = 1, cSlashes; szCurDir[i] != '\0'; i++)
349 {
350 if (szCurDir[i] == '/')
351 szCurDir[i] = '\\';
352 if (szCurDir[i] == '\\')
353 aiSlashes[cSlashes++] = i;
354 }
355 if (szCurDir[i-1] != '\\')
356 {
357 aiSlashes[cSlashes] = i;
358 szCurDir[i++] = '\\';
359 szCurDir[i] = '\0';
360 }
361
362
363 /*
364 * Initiate environment variables used: INCLUDE
365 */
366 psz = getenv("INCLUDE");
367 if (psz != NULL)
368 {
369 pszIncludeEnv = strdup(psz);
370 strlwr(pszIncludeEnv);
371 }
372 else
373 pszIncludeEnv = "";
374
375
376 /*
377 * parse arguments
378 */
379 while (argi < argc)
380 {
381 if (argv[argi][0] == '-' || argv[argi][0] == '/')
382 {
383 /* parameters */
384 switch (argv[argi][1])
385 {
386 case 'A':
387 case 'a': /* Append to the output file */
388 options.fAppend = argv[argi][2] != '-';
389 break;
390
391 case 'D':
392 case 'd': /* "-d <filename>" */
393 {
394 const char *pszOld = pszDepFile;
395 if (argv[argi][2] != '\0')
396 pszDepFile = &argv[argi][2];
397 else
398 {
399 if (argi + 1 < argc)
400 pszDepFile = argv[++argi];
401 else
402 {
403 fprintf(stderr, "invalid parameter -d, filename missing!\n");
404 return -1;
405 }
406 }
407
408 /* if dependencies are generated we'll flush them to the old filename */
409 if (pdepTree != NULL && pszOld != pszDepFile)
410 {
411 if (!depWriteFile(pszOld))
412 fprintf(stderr, "error: failed to write (flush) dependencies.\n");
413 depRemoveAll();
414 }
415 break;
416 }
417
418 case 'C': /* forced directory cache 'ca' or cylic check 'cy'*/
419 case 'c':
420 if (argv[argi][2] == 'a' || argv[argi][2] == 'A')
421 options.fCacheSearchDirs = TRUE;
422 else if ((argv[argi][2] == 'y' || argv[argi][2] == 'Y'))
423 options.fCheckCyclic = argv[argi][3] != '-';
424 break;
425
426 case 'E': /* list of paths. If a file is found in one of these directories the */
427 case 'e': /* filename will be used without the directory path. */
428 /* Eall<[+]|-> ? */
429 if (strlen(&argv[argi][1]) <= 5 && strnicmp(&argv[argi][1], "Eall", 4) == 0)
430 {
431 options.fExcludeAll = argv[argi][5] != '-';
432 break;
433 }
434 /* path or path list */
435 if (strlen(argv[argi]) > 2)
436 psz = &argv[argi][2];
437 else
438 {
439 psz = argv[argi+1];
440 argi++;
441 }
442 /* check if enviroment variable */
443 if (*psz == '%')
444 {
445 psz2 = strdup(psz+1);
446 if (psz2 != NULL && *psz2 != '\0')
447 {
448 if (psz2[strlen(psz2)-1] == '%')
449 psz2[strlen(psz2)-1] = '\0';
450 psz = getenv(psz2);
451 free(psz2);
452 if (psz == NULL)
453 break;
454 }
455 else
456 {
457 fprintf(stderr, "error: -E% is not an valid argument!\n");
458 return -1;
459 }
460 }
461 if (psz != NULL)
462 {
463 strcat(szExclude, psz);
464 strlwr(szExclude);
465 if (szExclude[strlen(szExclude)-1] != ';')
466 strcat(szExclude, ";");
467 }
468 break;
469
470 case 'I': /* optional include path. This has precedence over the INCLUDE environment variable. */
471 case 'i':
472 if (strlen(argv[argi]) > 2)
473 psz = &argv[argi][2];
474 else
475 {
476 psz = argv[argi+1];
477 argi++;
478 }
479 /* check if enviroment variable */
480 if (*psz == '%')
481 {
482 psz2 = strdup(psz+1);
483 if (psz2 != NULL && *psz2 != '\0')
484 {
485 if (psz2[strlen(psz2)-1] == '%')
486 psz2[strlen(psz2)-1] = '\0';
487 psz = getenv(psz2);
488 free(psz2);
489 if (psz == NULL)
490 break;
491 }
492 else
493 {
494 fprintf(stderr, "error: -I% is not an valid argument!\n");
495 return -1;
496 }
497 }
498 if (psz != NULL)
499 {
500 strcat(szInclude, psz);
501 strlwr(szInclude);
502 if (szInclude[strlen(szInclude)-1] != ';')
503 strcat(szInclude, ";");
504 }
505 break;
506
507 case 'n': /* no object path , -N<[+]|-> */
508 case 'N':
509 if (strlen(argv[argi]) <= 1+1+1)
510 options.fNoObjectPath = argv[argi][2] != '-';
511 else
512 {
513 fprintf(stderr, "error: invalid parameter!, '%s'\n", argv[argi]);
514 return -1;
515 }
516 break;
517
518 case 'o': /* object base directory, Obj or Obr<[+]|-> */
519 case 'O':
520 if (strlen(&argv[argi][1]) <= 4 && strnicmp(&argv[argi][1], "Obr", 3) == 0)
521 {
522 options.fObjRule = argv[argi][4] != '-';
523 break;
524 }
525
526 if (strlen(&argv[argi][1]) >= 4 && strnicmp(&argv[argi][1], "Obj", 3) == 0)
527 {
528 if (strlen(argv[argi]) > 4)
529 strcpy(szObjectExt, argv[argi]+4);
530 else
531 {
532 strcpy(szObjectExt, argv[argi+1]);
533 argi++;
534 }
535 break;
536 }
537
538 /* path: -o or -o- */
539 options.fObjectDir = TRUE;
540 if (strlen(argv[argi]) > 2)
541 {
542 if (argv[argi][2] == '-') /* no object path */
543 szObjectDir[0] = '\0';
544 else
545 strcpy(szObjectDir, argv[argi]+2);
546 }
547 else
548 {
549 strcpy(szObjectDir, argv[argi+1]);
550 argi++;
551 }
552 if (szObjectDir[0] != '\0'
553 && szObjectDir[strlen(szObjectDir)-1] != '\\'
554 && szObjectDir[strlen(szObjectDir)-1] != '/'
555 )
556 strcat(szObjectDir, "\\");
557 break;
558
559 case 'r':
560 case 'R':
561 if (strlen(argv[argi]) > 2)
562 strcpy(szObjectExt, argv[argi]+2);
563 else
564 {
565 strcpy(szObjectExt, argv[argi+1]);
566 argi++;
567 }
568 break;
569
570 case 'h':
571 case 'H':
572 case '?':
573 syntax();
574 return 1;
575
576 default:
577 fprintf(stderr, "error: invalid parameter! '%s'\n", argv[argi]);
578 return -1;
579 }
580
581 }
582 else if (argv[argi][0] == '@')
583 { /*
584 * Parameter file (debugger parameter length restrictions led to this):
585 * Create a textbuffer.
586 * Parse the file and create a new parameter vector.
587 * Set argv to the new parameter vector, argi to 0 and argc to
588 * the parameter count.
589 * Restrictions: Parameters enclosed in "" is not implemented.
590 * No commandline parameters are processed after the @file
591 */
592 char *pszBuffer = (char*)textbufferCreate(&argv[argi][1]); /* !ASSUMS! that pvBuffer is the file string! */
593 if (pszBuffer != NULL)
594 {
595 char **apszArgs = NULL;
596 char *psz = pszBuffer;
597 int i = 0;
598
599 while (*psz != '\0')
600 {
601 /* find end of parameter word */
602 char *pszEnd = psz + 1;
603 char ch = *pszEnd;
604 while (ch != ' ' && ch != '\t' && ch != '\n' && ch != '\r' && ch != '\0')
605 ch = *++pszEnd;
606
607 /* allocate more arg array space? */
608 if ((i % 512) == 0)
609 {
610 apszArgs = realloc(apszArgs, sizeof(char*) * 512);
611 if (apszArgs == NULL)
612 {
613 fprintf(stderr, "error: out of memory. (line=%d)\n", __LINE__);
614 return -8;
615 }
616 }
617 *pszEnd = '\0';
618 apszArgs[i++] = psz;
619
620 /* next */
621 psz = pszEnd + 1;
622 ch = *psz;
623 while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')
624 ch = *++psz;
625 }
626
627 argc = i;
628 argi = 0;
629 argv = apszArgs;
630 continue;
631 }
632 else
633 {
634 fprintf(stderr, "error: could not open parameter file\n");
635 return -1;
636 }
637 }
638 else
639 { /* not a parameter! */
640 ULONG ulRc;
641 PFILEFINDBUF3 pfindbuf3 = (PFILEFINDBUF3)(void*)&achBuffer[0];
642 HDIR hDir = HDIR_CREATE;
643 ULONG cFiles = ~0UL;
644 int i;
645
646 /*
647 * If append option is specified we'll have to read the existing dep file
648 * before starting adding new dependencies.
649 */
650 if (pdepTree == NULL && options.fAppend)
651 depReadFile(pszDepFile, &options);
652
653 /*
654 * Search for the files specified.
655 */
656 ulRc = DosFindFirst(argv[argi], &hDir,
657 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_ARCHIVED,
658 pfindbuf3, sizeof(achBuffer), &cFiles, FIL_STANDARD);
659 if (!options.fCacheSearchDirs)
660 options.fCacheSearchDirs = cFiles > 25;
661 while (ulRc == NO_ERROR)
662 {
663 for (i = 0;
664 i < cFiles;
665 i++, pfindbuf3 = (PFILEFINDBUF3)((int)pfindbuf3 + pfindbuf3->oNextEntryOffset)
666 )
667 {
668 char *psz;
669 char szSource[CCHMAXPATH];
670
671 /*
672 * Make full path.
673 */
674 if ((psz = strrchr(argv[argi], '\\')) || (psz = strrchr(argv[argi], '/')))
675 {
676 strncpy(szSource, argv[argi], psz - argv[argi] + 1);
677 szSource[psz - argv[argi] + 1] = '\0';
678 }
679 else
680 szSource[0] = '\0';
681 strcat(szSource, pfindbuf3->achName);
682 strlwr(szSource);
683 fileNormalize(szSource);
684
685 /*
686 * Analyse the file.
687 */
688 rc -= makeDependent(&szSource[0], &options);
689 }
690
691 /* next file */
692 cFiles = ~0UL;
693 pfindbuf3 = (PFILEFINDBUF3)(void*)&achBuffer[0];
694 ulRc = DosFindNext(hDir, pfindbuf3, sizeof(achBuffer), &cFiles);
695 }
696 DosFindClose(hDir);
697 }
698 /* next */
699 argi++;
700 }
701
702 /* Write the depend file! */
703 if (!depWriteFile(pszDepFile))
704 fprintf(stderr, "error: failed to write dependencies file!\n");
705 #if 0
706 printf("cfcNodes=%d\n", cfcNodes);
707 #endif
708
709 return rc;
710}
711
712
713/**
714 * Displays the syntax description for this util.
715 * @status completely implemented.
716 * @author knut st. osmundsen
717 */
718static void syntax(void)
719{
720 printf(
721 "FastDep v0.3\n"
722 "Dependency scanner. Creates a makefile readable depend file.\n"
723 " - was quick and dirty, now it's just quick -\n"
724 "\n"
725 "Syntax: FastDep [-a<[+]|->] [-ca] [-cy<[+]|->] [-d <outputfn>]\n"
726 " [-e <excludepath>] [-eall<[+]|->] [-i <include>] [-n<[+]|->]\n"
727 " [-o <objdir>] [-obr<[+]|->] <files>\n"
728 " or\n"
729 " FastDep [options] @<parameterfile>\n"
730 "\n"
731 " -a<[+]|-> Append to the output file. Default: Overwrite.\n"
732 " -ca Force search directory caching.\n"
733 " Default: cache if more that 25 files are to be searched.\n"
734 " (more than 25 in the first file expression.)\n"
735 " -cy<[+]|-> Check for cylic dependencies. Default: -cy-\n"
736 " -d <outputfn> Output filename. Default: %s\n"
737 " -e excludepath Exclude paths. If a filename is found in any\n"
738 " of these paths only the filename is used, not\n"
739 " the path+filename (which is default).\n"
740 " -eall<[+]|-> Include and source filenames, paths or no paths.\n"
741 " -eall+: No path are added to the filename.\n"
742 " -eall-: The filename is appended the include path\n"
743 " was found in.\n"
744 " Default: eall-\n"
745 " -i <include> Additional include paths. INCLUDE is searched after this.\n"
746 " -n<[+]|-> No path for object files in the rules.\n"
747 " -o <objdir> Path were object files are placed. This path replaces the\n"
748 " entire filename path\n"
749 " -o- No object path\n"
750 " -obr<[+]|-> -obr+: Object rule.\n"
751 " -obr-: No object rule, rule for source filename is generated.\n"
752 " -obj[ ]<objext> Object extention. Default: obj\n"
753 " -r[ ]<rsrcext> Resource binary extention. Default: res\n"
754 " <files> Files to scan. Wildchars are allowed.\n"
755 "\n"
756 " copyright (c) 1999-2000 knut st. osmundsen (knut.stange.osmundsen@pmsc.no)\n",
757 pszDefaultDepFile
758 );
759}
760
761
762/**
763 * Generates depend info on this file, these are stored internally
764 * and written to file later.
765 * @returns
766 * @param pszFilename Pointer to source filename. Correct case is assumed!
767 * @param pOptions Pointer to options struct.
768 * @status completely implemented.
769 * @author knut st. osmundsen
770 */
771static int makeDependent(const char *pszFilename, POPTIONS pOptions)
772{
773 int rc = -1;
774 void * pvFile;
775
776 pvFile = textbufferCreate(pszFilename);
777 if (pvFile != NULL)
778 {
779 char szExt[CCHMAXPATH];
780 PCONFIGENTRY pCfg = &aConfig[0];
781 BOOL fHeader;
782
783 /*
784 * Find which filetype this is...
785 */
786 fileExt(pszFilename, szExt);
787 while (pCfg->papszExts != NULL)
788 {
789 const char **ppsz = pCfg->papszExts;
790 while (*ppsz != NULL && stricmp(*ppsz, szExt) != 0)
791 ppsz++;
792 if (*ppsz != NULL)
793 {
794 fHeader = &pCfg->papszExts[pCfg->iFirstHdr] <= ppsz;
795 break;
796 }
797 pCfg++;
798 }
799
800 /* Found? */
801 if (pCfg->papszExts != NULL)
802 {
803 char szNormFile[CCHMAXPATH];
804 fileNormalize2(pszFilename, szNormFile);
805 rc = (*pCfg->pfn)(pszFilename, &szNormFile[0], pvFile, fHeader, pOptions);
806 }
807 else
808 {
809 if (*fileName(pszFilename, szExt) != '.') /* these are 'hidden' files, like .cvsignore, let's ignore them. */
810 fprintf(stderr, "warning: '%s' has an unknown file type.\n", pszFilename);
811 rc = 0;
812 }
813
814 textbufferDestroy(pvFile);
815 }
816 else
817 fprintf(stderr, "failed to open '%s'\n", pszFilename);
818
819 return rc;
820}
821
822
823/**
824 * Generates depend info on this C or C++ file, these are stored internally
825 * and written to file later.
826 * @returns 0 on success.
827 * !0 on error.
828 * @param pszFilename Pointer to source filename. Correct case is assumed!
829 * @param pszNormFilename Pointer to normalized source filename.
830 * @param pvFile Pointer to file textbuffer.
831 * @param pOptions Pointer to options struct.
832 * @status completely implemented.
833 * @author knut st. osmundsen
834 */
835int langC_CPP(const char *pszFilename, const char *pszNormFilename, void *pvFile, BOOL fHeader, POPTIONS pOptions)
836{
837 void * pvRule; /* Handle to the current rule. */
838 char szBuffer[4096]; /* Max line length is 4096... should not be a problem. */
839 int iLine; /* Linenumber. */
840 void * pv = NULL; /* An index used by textbufferGetNextLine. */
841 BOOL fComment; /* TRUE when within a multiline comment. */
842 /* FALSE when not within a multiline comment. */
843 int iIfStack; /* StackPointer. */
844 struct IfStackEntry
845 {
846 int fIncluded : 1; /* TRUE: include this code;
847 * FALSE: excluded */
848 int fIf : 1; /* TRUE: #if part of the expression.
849 * FALSE: #else part of the expression. */
850 int fSupported : 1; /* TRUE: supported if/else statement
851 * FALSE: unsupported all else[<something>] are ignored
852 * All code is included.
853 */
854 } achIfStack[256];
855
856
857 /**********************************/
858 /* Add the depend rule */
859 /**********************************/
860 if (pOptions->fObjRule && !fHeader)
861 {
862 if (pOptions->fNoObjectPath)
863 pvRule = depAddRule(fileNameNoExt(pszFilename, szBuffer), NULL, pOptions->pszObjectExt);
864 else
865 pvRule = depAddRule(pOptions->fObjectDir ?
866 pOptions->pszObjectDir :
867 filePathSlash(pszFilename, szBuffer),
868 fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
869 pOptions->pszObjectExt);
870
871 if (pOptions->fSrcWhenObj && pvRule)
872 depAddDepend(pvRule,
873 pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, pszNormFilename, pOptions) ?
874 fileName(pszFilename, szBuffer) : pszNormFilename,
875 pOptions->fCheckCyclic);
876 }
877 else
878 pvRule = depAddRule(pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, pszNormFilename, pOptions) ?
879 fileName(pszFilename, szBuffer) : pszNormFilename, NULL, NULL);
880
881 /* duplicate rule? */
882 if (pvRule == NULL)
883 return 0;
884
885
886 /*******************/
887 /* find dependants */
888 /*******************/
889 /* Initiate the IF-stack, comment state and line number. */
890 iIfStack = 0;
891 achIfStack[iIfStack].fIf = TRUE;
892 achIfStack[iIfStack].fIncluded = TRUE;
893 achIfStack[iIfStack].fSupported = TRUE;
894 fComment = FALSE;
895 iLine = 0;
896 while (textbufferGetNextLine(pvFile, &pv, szBuffer, sizeof(szBuffer)) != NULL) /* line loop */
897 {
898 /* search for #include */
899 register char *pszC;
900 int cbLen;
901 int i = 0;
902 iLine++;
903
904 /* skip blank chars */
905 cbLen = strlen(szBuffer);
906 while (i + 2 < cbLen && (szBuffer[i] == ' ' || szBuffer[i] == '\t'))
907 i++;
908
909 /* preprocessor statement? */
910 if (!fComment && szBuffer[i] == '#')
911 {
912 /*
913 * Preprocessor checks
914 * We known that we have a preprocessor statment (starting with an '#' * at szBuffer[i]).
915 * Depending on the word afterwards we'll take some different actions.
916 * So we'll start of by extracting that word and make a string swich on it.
917 * Note that there might be some blanks between the hash and the word.
918 */
919 int cchWord;
920 char * pszEndWord;
921 char * pszArgument;
922 i++; /* skip hash ('#') */
923 while (szBuffer[i] == '\t' || szBuffer[i] == ' ') /* skip blanks */
924 i++;
925 pszArgument = pszEndWord = findEndOfWord(&szBuffer[i]);
926 cchWord = pszEndWord - &szBuffer[i];
927
928 /*
929 * Find the argument by skipping the blanks.
930 */
931 while (*pszArgument == '\t' || *pszArgument == ' ') /* skip blanks */
932 pszArgument++;
933
934 /*
935 * string switch.
936 */
937 if (strncmp(&szBuffer[i], "include", cchWord) == 0)
938 {
939 /*
940 * #include
941 *
942 * Are we in a state where this file is to be included?
943 */
944 if (achIfStack[iIfStack].fIncluded)
945 {
946 char szFullname[CCHMAXPATH];
947 char *psz;
948 BOOL f = FALSE;
949 int j;
950
951 /* extract info between "" or <> */
952 while (i < cbLen && !(f = (szBuffer[i] == '"' || szBuffer[i] == '<')))
953 i++;
954 i++; /* skip '"' or '<' */
955
956 /* if invalid statement then continue with the next line! */
957 if (!f) continue;
958
959 /* find end */
960 j = f = 0;
961 while (i + j < cbLen && j < CCHMAXPATH &&
962 !(f = (szBuffer[i+j] == '"' || szBuffer[i+j] == '>')))
963 j++;
964
965 /* if invalid statement then continue with the next line! */
966 if (!f) continue;
967
968 /* copy filename */
969 strncpy(szFullname, &szBuffer[i], j);
970 szFullname[j] = '\0'; /* ensure terminatition. */
971 strlwr(szFullname);
972
973 /* find include file! */
974 psz = pathlistFindFile(pOptions->pszInclude, szFullname, szBuffer, pOptions);
975 if (psz == NULL)
976 psz = pathlistFindFile(pszIncludeEnv, szFullname, szBuffer, pOptions);
977
978 /* did we find the include? */
979 if (psz != NULL)
980 {
981 if (pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, szBuffer, pOptions))
982 depAddDepend(pvRule, szFullname, pOptions->fCheckCyclic);
983 else
984 depAddDepend(pvRule, szBuffer, pOptions->fCheckCyclic);
985 }
986 else
987 fprintf(stderr, "%s(%d): warning include file '%s' not found!\n",
988 pszFilename, iLine, szFullname);
989 }
990 }
991 else
992 /*
993 * #if
994 */
995 if (strncmp(&szBuffer[i], "if", cchWord) == 0)
996 { /* #if 0 and #if <1-9> are supported */
997 pszEndWord = findEndOfWord(pszArgument);
998 iIfStack++;
999 if ((pszEndWord - pszArgument) == 1
1000 && *pszArgument >= '0' && *pszArgument <= '9')
1001 {
1002 if (*pszArgument != '0')
1003 achIfStack[iIfStack].fIncluded = TRUE;
1004 else
1005 achIfStack[iIfStack].fIncluded = FALSE;
1006 }
1007 else
1008 achIfStack[iIfStack].fSupported = FALSE;
1009 achIfStack[iIfStack].fIncluded = TRUE;
1010 achIfStack[iIfStack].fIf = TRUE;
1011 }
1012 else
1013 /*
1014 * #else
1015 */
1016 if (strncmp(&szBuffer[i], "else", cchWord) == 0)
1017 {
1018 if (achIfStack[iIfStack].fSupported)
1019 {
1020 if (achIfStack[iIfStack].fIncluded) /* ARG!! this'll prevent warning */
1021 achIfStack[iIfStack].fIncluded = FALSE;
1022 else
1023 achIfStack[iIfStack].fIncluded = TRUE;
1024 }
1025 achIfStack[iIfStack].fIf = FALSE;
1026 }
1027 else
1028 /*
1029 * #endif
1030 */
1031 if (strncmp(&szBuffer[i], "endif", cchWord) == 0)
1032 { /* Pop the if-stack. */
1033 if (iIfStack > 0)
1034 iIfStack--;
1035 else
1036 fprintf(stderr, "%s(%d): If-Stack underflow!\n", pszFilename, iLine);
1037 }
1038 /*
1039 * general if<something> and elseif<something> implementations
1040 */
1041 else
1042 if (strncmp(&szBuffer[i], "elseif", 6) == 0)
1043 {
1044 achIfStack[iIfStack].fSupported = FALSE;
1045 achIfStack[iIfStack].fIncluded = TRUE;
1046 }
1047 else
1048 if (strncmp(&szBuffer[i], "if", 2) == 0)
1049 {
1050 iIfStack++;
1051 achIfStack[iIfStack].fIf = TRUE;
1052 achIfStack[iIfStack].fSupported = FALSE;
1053 achIfStack[iIfStack].fIncluded = TRUE;
1054 }
1055 /* The rest of them aren't implemented yet.
1056 else if (strncmp(&szBuffer[i], "if") == 0)
1057 {
1058 }
1059 */
1060 }
1061
1062 /*
1063 * Comment checks.
1064 * -Start at first non-blank.
1065 * -Loop thru the line since we might have more than one
1066 * comment statement on a single line.
1067 */
1068 pszC = &szBuffer[i];
1069 while (pszC != NULL && *pszC != '\0')
1070 {
1071 if (fComment)
1072 pszC = strstr(pszC, "*/"); /* look for end comment mark. */
1073 else
1074 {
1075 char *pszLC;
1076 pszLC= strstr(pszC, "//"); /* look for single line comment mark. */
1077 pszC = strstr(pszC, "/*"); /* look for start comment mark */
1078 if (pszLC && pszLC < pszC) /* if there is an single line comment mark before the */
1079 break; /* muliline comment mark we'll ignore the multiline mark. */
1080 }
1081
1082 /* Comment mark found? */
1083 if (pszC != NULL)
1084 {
1085 fComment = !fComment;
1086 pszC += 2; /* skip comment mark */
1087
1088 /* debug */
1089 /*
1090 if (fComment)
1091 fprintf(stderr, "starts at line %d\n", iLine);
1092 else
1093 fprintf(stderr, "ends at line %d\n", iLine);
1094 */
1095 }
1096 }
1097 } /*while*/
1098
1099 return 0;
1100}
1101
1102
1103/**
1104 * Generates depend info on this file, these are stored internally
1105 * and written to file later.
1106 * @returns 0 on success.
1107 * !0 on error.
1108 * @param pszFilename Pointer to source filename. Correct case is assumed!
1109 * @param pszNormFilename Pointer to normalized source filename.
1110 * @param pvFile Pointer to file textbuffer.
1111 * @param pOptions Pointer to options struct.
1112 * @status completely implemented.
1113 * @author knut st. osmundsen
1114 */
1115int langAsm(const char *pszFilename, const char *pszNormFilename, void *pvFile, BOOL fHeader, POPTIONS pOptions)
1116{
1117 void * pvRule; /* Handle to the current rule. */
1118 char szBuffer[4096]; /* Temporary buffer (max line lenght size...) */
1119 int iLine; /* current line number */
1120 void * pv = NULL; /* An index used by textbufferGetNextLine. */
1121
1122
1123 /**********************************/
1124 /* Add the depend rule */
1125 /**********************************/
1126 if (pOptions->fObjRule && !fHeader)
1127 {
1128 if (pOptions->fNoObjectPath)
1129 pvRule = depAddRule(fileNameNoExt(pszFilename, szBuffer), NULL, pOptions->pszObjectExt);
1130 else
1131 pvRule = depAddRule(pOptions->fObjectDir ?
1132 pOptions->pszObjectDir :
1133 filePathSlash(pszFilename, szBuffer),
1134 fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
1135 pOptions->pszObjectExt);
1136
1137 if (pOptions->fSrcWhenObj && pvRule)
1138 depAddDepend(pvRule,
1139 pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, pszNormFilename, pOptions) ?
1140 fileName(pszFilename, szBuffer) : pszNormFilename,
1141 pOptions->fCheckCyclic);
1142 }
1143 else
1144 pvRule = depAddRule(pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, pszNormFilename, pOptions) ?
1145 fileName(pszFilename, szBuffer) : pszNormFilename, NULL, NULL);
1146
1147 /* duplicate rule? */
1148 if (pvRule == NULL)
1149 return 0;
1150
1151
1152 /*******************/
1153 /* find dependants */
1154 /*******************/
1155 iLine = 0;
1156 while (textbufferGetNextLine(pvFile, &pv, szBuffer, sizeof(szBuffer)) != NULL) /* line loop */
1157 {
1158 /* search for include */
1159 int cbLen;
1160 int i = 0;
1161 iLine++;
1162
1163 /* skip blank chars */
1164 cbLen = strlen(szBuffer);
1165 while (i + 9 < cbLen && (szBuffer[i] == ' ' || szBuffer[i] == '\t'))
1166 i++;
1167
1168 /* is this an include? */
1169 if (strnicmp(&szBuffer[i], "include", 7) == 0
1170 && (szBuffer[i + 7] == '\t' || szBuffer[i + 7] == ' ')
1171 )
1172 {
1173 char szFullname[CCHMAXPATH];
1174 char *psz;
1175 int j;
1176
1177 /* skip to first no blank char */
1178 i += 7;
1179 while (i < cbLen && (szBuffer[i] == ' ' || szBuffer[i] == '\t'))
1180 i++;
1181
1182 /* comment check - if comment found, no filename was given. continue. */
1183 if (szBuffer[i] == ';') continue;
1184
1185 /* find end */
1186 j = 0;
1187 while (i + j < cbLen
1188 && j < CCHMAXPATH
1189 && szBuffer[i+j] != ' ' && szBuffer[i+j] != '\t' && szBuffer[i+j] != '\n'
1190 && szBuffer[i+j] != '\0' && szBuffer[i+j] != ';' && szBuffer[i+j] != '\r'
1191 )
1192 j++;
1193
1194 /* copy filename */
1195 strncpy(szFullname, &szBuffer[i], j);
1196 szFullname[j] = '\0'; /* ensure terminatition. */
1197 strlwr(szFullname);
1198
1199 /* find include file! */
1200 psz = pathlistFindFile(pOptions->pszInclude, szFullname, szBuffer, pOptions);
1201 if (psz == NULL)
1202 psz = pathlistFindFile(pszIncludeEnv, szFullname, szBuffer, pOptions);
1203
1204 /* Did we find the include? */
1205 if (psz != NULL)
1206 {
1207 if (pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, szBuffer, pOptions))
1208 depAddDepend(pvRule, szFullname, pOptions->fCheckCyclic);
1209 else
1210 depAddDepend(pvRule, szBuffer, pOptions->fCheckCyclic);
1211 }
1212 else
1213 fprintf(stderr, "%s(%d): warning include file '%s' not found!\n",
1214 pszFilename, iLine, szFullname);
1215 }
1216 } /*while*/
1217
1218 return 0;
1219}
1220
1221
1222/**
1223 * Generates depend info on this Resource file, these are stored internally
1224 * and written to file later.
1225 * @returns 0 on success.
1226 * !0 on error.
1227 * @param pszFilename Pointer to source filename. Correct case is assumed!
1228 * @param pszNormFilename Pointer to normalized source filename.
1229 * @param pvFile Pointer to file textbuffer.
1230 * @param pOptions Pointer to options struct.
1231 * @status completely implemented.
1232 * @author knut st. osmundsen
1233 */
1234int langRC(const char *pszFilename, const char *pszNormFilename, void *pvFile, BOOL fHeader, POPTIONS pOptions)
1235{
1236 void * pvRule; /* Handle to the current rule. */
1237 char szBuffer[4096]; /* Temporary buffer (max line lenght size...) */
1238 int iLine; /* current line number */
1239 void * pv = NULL; /* An index used by textbufferGetNextLine. */
1240
1241
1242 /**********************************/
1243 /* Add the depend rule */
1244 /**********************************/
1245 if (pOptions->fObjRule && !fHeader)
1246 {
1247 if (pOptions->fNoObjectPath)
1248 pvRule = depAddRule(fileNameNoExt(pszFilename, szBuffer), NULL, pOptions->pszRsrcExt);
1249 else
1250 pvRule = depAddRule(pOptions->fObjectDir ?
1251 pOptions->pszObjectDir :
1252 filePathSlash(pszFilename, szBuffer),
1253 fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
1254 pOptions->pszRsrcExt);
1255
1256 if (pOptions->fSrcWhenObj && pvRule)
1257 depAddDepend(pvRule,
1258 pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, pszNormFilename, pOptions) ?
1259 fileName(pszFilename, szBuffer) : fileNormalize2(pszFilename, szBuffer),
1260 pOptions->fCheckCyclic);
1261 }
1262 else
1263 pvRule = depAddRule(pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, pszNormFilename, pOptions) ?
1264 fileName(pszFilename, szBuffer) : pszNormFilename, NULL, NULL);
1265
1266 /* duplicate rule? */
1267 if (pvRule == NULL)
1268 return 0;
1269
1270
1271 /*******************/
1272 /* find dependants */
1273 /*******************/
1274 iLine = 0;
1275 while (textbufferGetNextLine(pvFile, &pv, szBuffer, sizeof(szBuffer)) != NULL) /* line loop */
1276 {
1277 /* search for #include */
1278 int cbLen;
1279 int i = 0;
1280 int i1;
1281 iLine++;
1282
1283 /* skip blank chars */
1284 cbLen = strlen(szBuffer);
1285 while (i + 9 < cbLen && (szBuffer[i] == ' ' || szBuffer[i] == '\t'))
1286 i++;
1287
1288 /* is this an include? */
1289 i1 = 1;
1290 if ( strncmp(&szBuffer[i], "#include", 8) == 0
1291 || (i1 = strncmp(&szBuffer[i], "RCINCLUDE", 9)) == 0
1292 || strncmp(&szBuffer[i], "DLGINCLUDE", 10) == 0
1293 )
1294 {
1295 char szFullname[CCHMAXPATH];
1296 char *psz;
1297 BOOL f = FALSE;
1298 int j;
1299
1300 if (i1 != 0)
1301 { /*
1302 * #include <file.h>, #include "file.h" or DLGINCLUDE 1 "file.h"
1303 *
1304 * extract info between "" or <>
1305 */
1306 while (i < cbLen && !(f = (szBuffer[i] == '"' || szBuffer[i] == '<')))
1307 i++;
1308 i++; /* skip '"' or '<' */
1309
1310 /* if invalid statement then continue with the next line! */
1311 if (!f) continue;
1312
1313 /* find end */
1314 j = f = 0;
1315 while (i + j < cbLen && j < CCHMAXPATH &&
1316 !(f = (szBuffer[i+j] == '"' || szBuffer[i+j] == '>')))
1317 j++;
1318
1319 /* if invalid statement then continue with the next line! */
1320 if (!f) continue;
1321 }
1322 else
1323 { /*
1324 * RCINCLUDE ["]filename.dlg["]
1325 * Extract filename.
1326 */
1327
1328 /* skip to filename.dlg start - if eol will continue to loop. */
1329 i += 9;
1330 while (szBuffer[i] == ' ' || szBuffer[i] == '\t' || szBuffer[i] == '"')
1331 i++;
1332 if (szBuffer[i] == '\0')
1333 continue;
1334
1335 /* search to end of filename. */
1336 j = i+1;
1337 while ( szBuffer[i+j] != ' ' && szBuffer[i+j] != '\t'
1338 && szBuffer[i+j] != '"' && szBuffer[i+j] != '\0')
1339 j++;
1340 }
1341
1342 /* copy filename */
1343 strncpy(szFullname, &szBuffer[i], j);
1344 szFullname[j] = '\0'; /* ensure terminatition. */
1345 strlwr(szFullname);
1346
1347 /* find include file! */
1348 psz = pathlistFindFile(pOptions->pszInclude, szFullname, szBuffer, pOptions);
1349 if (psz == NULL)
1350 psz = pathlistFindFile(pszIncludeEnv, szFullname, szBuffer, pOptions);
1351
1352 /* did we find the include? */
1353 if (psz != NULL)
1354 {
1355 if (pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, szBuffer, pOptions))
1356 depAddDepend(pvRule, szFullname, pOptions->fCheckCyclic);
1357 else
1358 depAddDepend(pvRule, szBuffer, pOptions->fCheckCyclic);
1359 }
1360 else
1361 fprintf(stderr, "%s(%d): warning include file '%s' not found!\n",
1362 pszFilename, iLine, szFullname);
1363 }
1364 } /*while*/
1365
1366 return 0;
1367}
1368
1369
1370/**
1371 * Generates depend info on this COBOL file, these are stored internally
1372 * and written to file later.
1373 * @returns 0 on success.
1374 * !0 on error.
1375 * @param pszFilename Pointer to source filename. Correct case is assumed!
1376 * @param pszNormFilename Pointer to normalized source filename.
1377 * @param pvFile Pointer to file textbuffer.
1378 * @param pOptions Pointer to options struct.
1379 * @status completely implemented.
1380 * @author knut st. osmundsen
1381 */
1382int langCOBOL(const char *pszFilename, const char *pszNormFilename, void *pvFile, BOOL fHeader, POPTIONS pOptions)
1383{
1384 void * pvRule; /* Handle to the current rule. */
1385 char szBuffer[4096]; /* Temporary buffer (max line lenght size...) */
1386 int iLine; /* current line number */
1387 void * pv = NULL; /* An index used by textbufferGetNextLine. */
1388
1389
1390 /**********************************/
1391 /* Add the depend rule */
1392 /**********************************/
1393 if (pOptions->fObjRule && !fHeader)
1394 {
1395 if (pOptions->fNoObjectPath)
1396 pvRule = depAddRule(fileNameNoExt(pszFilename, szBuffer), NULL, pOptions->pszObjectExt);
1397 else
1398 pvRule = depAddRule(pOptions->fObjectDir ?
1399 pOptions->pszObjectDir :
1400 filePathSlash(pszFilename, szBuffer),
1401 fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
1402 pOptions->pszObjectExt);
1403
1404 if (pOptions->fSrcWhenObj && pvRule)
1405 depAddDepend(pvRule,
1406 pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, pszNormFilename, pOptions) ?
1407 fileName(pszFilename, szBuffer) : fileNormalize2(pszFilename, szBuffer),
1408 pOptions->fCheckCyclic);
1409 }
1410 else
1411 pvRule = depAddRule(pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, pszNormFilename, pOptions) ?
1412 fileName(pszFilename, szBuffer) : pszNormFilename, NULL, NULL);
1413
1414 /* duplicate rule? */
1415 if (pvRule == NULL)
1416 return 0;
1417
1418
1419 /*******************/
1420 /* find dependants */
1421 /*******************/
1422 iLine = 0;
1423 while (textbufferGetNextLine(pvFile, &pv, szBuffer, sizeof(szBuffer)) != NULL) /* line loop */
1424 {
1425 /* search for #include */
1426 int cbLen;
1427 int i = 0;
1428 int i1, i2;
1429 iLine++;
1430
1431 /* check for comment mark (column 7) */
1432 if (szBuffer[6] == '*')
1433 continue;
1434
1435 /* skip blank chars */
1436 cbLen = strlen(szBuffer);
1437 while (i + 9 < cbLen && (szBuffer[i] == ' ' || szBuffer[i] == '\t'))
1438 i++;
1439
1440 /* is this an include? */
1441 if ( (i1 = strnicmp(&szBuffer[i], "COPY", 4)) == 0
1442 || (i2 = strnicmpwords(&szBuffer[i], "EXEC SQL INCLUDE", 16)) == 0
1443 )
1444 {
1445 char szFullname[CCHMAXPATH];
1446 char *psz;
1447 int j;
1448
1449 /* skip statement */
1450 i += 4;
1451 if (i1 != 0)
1452 {
1453 int y = 2; /* skip two words */
1454 do
1455 {
1456 /* skip blanks */
1457 while (szBuffer[i] == ' ' || szBuffer[i] == '\t')
1458 i++;
1459 /* skip word */
1460 while (szBuffer[i] != ' ' && szBuffer[i] != '\t'
1461 && szBuffer[i] != '\0' && szBuffer[i] != '\n')
1462 i++;
1463 y--;
1464 } while (y > 0);
1465 }
1466
1467 /* check for blank */
1468 if (szBuffer[i] != ' ' && szBuffer[i] != '\t') /* no copybook specified... */
1469 continue;
1470
1471 /* skip blanks */
1472 while (szBuffer[i] == ' ' || szBuffer[i] == '\t')
1473 i++;
1474
1475 /* if invalid statement then continue with the next line! */
1476 if (szBuffer[i] == '\0' || szBuffer[i] == '\n')
1477 continue;
1478
1479 /* find end */
1480 j = 0;
1481 while (i + j < cbLen && j < CCHMAXPATH
1482 && szBuffer[i+j] != '.'
1483 && szBuffer[i+j] != ' ' && szBuffer[i+j] != '\t'
1484 && szBuffer[i+j] != '\0' && szBuffer[i+j] != '\n'
1485 )
1486 j++;
1487
1488 /* if invalid statement then continue with the next line! */
1489 if (szBuffer[i+j] != '.' && szBuffer[i+j] != ' ' && szBuffer[i] != '\t')
1490 continue;
1491
1492 /* copy filename */
1493 strncpy(szFullname, &szBuffer[i], j);
1494 szFullname[j] = '\0'; /* ensure terminatition. */
1495 strlwr(szFullname);
1496
1497 /* add extention .cpy - hardcoded for the moment. */
1498 strcat(szFullname, ".cpy");
1499
1500 /* find include file! */
1501 psz = pathlistFindFile(pOptions->pszInclude, szFullname, szBuffer, pOptions);
1502
1503 /* did we find the include? */
1504 if (psz != NULL)
1505 {
1506 if (pOptions->fExcludeAll || pathlistFindFile2(pOptions->pszExclude, szBuffer, pOptions))
1507 depAddDepend(pvRule, szFullname, pOptions->fCheckCyclic);
1508 else
1509 depAddDepend(pvRule, szBuffer, pOptions->fCheckCyclic);
1510 }
1511 else
1512 fprintf(stderr, "%s(%d): warning include file '%s' not found!\n",
1513 pszFilename, iLine, szFullname);
1514 }
1515 } /*while*/
1516
1517 return 0;
1518}
1519
1520#define upcase(ch) \
1521 (ch >= 'a' && ch <= 'z' ? ch - ('a' - 'A') : ch)
1522
1523/**
1524 * Compares words. Multiple spaces are treates as on single blank i both string when comparing them.
1525 * @returns 0 equal. (same as strnicmp)
1526 * @param pszS1 String 1
1527 * @param pszS2 String 2
1528 * @param cch Length to compare (relative to string 1)
1529 * @author knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
1530 */
1531static int strnicmpwords(const char *pszS1, const char *pszS2, int cch)
1532{
1533 do
1534 {
1535 while (cch > 0 && upcase(*pszS1) == upcase(*pszS2) && *pszS1 != ' ')
1536 pszS1++, pszS2++, cch--;
1537
1538 /* blank test and skipping */
1539 if (cch > 0 && *pszS1 == ' ' && *pszS2 == ' ')
1540 {
1541 while (cch > 0 && *pszS1 == ' ')
1542 pszS1++, cch--;
1543
1544 while (*pszS2 == ' ')
1545 pszS2++;
1546 }
1547 else
1548 break;
1549 } while (cch > 0);
1550
1551 return cch == 0 ? 0 : *pszS1 - *pszS2;
1552}
1553
1554
1555/**
1556 * Normalizes the path slashes for the filename. It will partially expand paths too.
1557 * @returns pszFilename
1558 * @param pszFilename Pointer to filename string. Not empty string!
1559 * Much space to play with.
1560 */
1561char *fileNormalize(char *pszFilename)
1562{
1563 char *psz = pszFilename;
1564
1565 /* correct slashes */
1566 while ((pszFilename = strchr(pszFilename, '//')) != NULL)
1567 *pszFilename++ = '\\';
1568
1569 /* expand path? */
1570 pszFilename = psz;
1571 if (pszFilename[1] != ':')
1572 { /* relative path */
1573 int iSlash;
1574 char szFile[CCHMAXPATH];
1575 char * psz = szFile;
1576
1577 strcpy(szFile, pszFilename);
1578 iSlash = *psz == '\\' ? 1 : cSlashes;
1579 while (*psz != '\0')
1580 {
1581 if (*psz == '.' && psz[1] == '.' && psz[2] == '\\')
1582 { /* up one directory */
1583 if (iSlash > 0)
1584 iSlash--;
1585 psz += 3;
1586 }
1587 else if (*psz == '.' && psz[1] == '\\')
1588 { /* no change */
1589 psz += 2;
1590 }
1591 else
1592 { /* completed expantion! */
1593 strncpy(pszFilename, szCurDir, aiSlashes[iSlash]+1);
1594 strcpy(pszFilename + aiSlashes[iSlash]+1, psz);
1595 break;
1596 }
1597 }
1598 }
1599 /* else: assume full path */
1600
1601 return psz;
1602}
1603
1604
1605/**
1606 * Normalizes the path slashes for the filename. It will partially expand paths too.
1607 * Makes name all lower case too.
1608 * @returns pszFilename
1609 * @param pszFilename Pointer to filename string. Not empty string!
1610 * Much space to play with.
1611 * @param pszBuffer Pointer to output buffer.
1612 */
1613char *fileNormalize2(const char *pszFilename, char *pszBuffer)
1614{
1615 char * psz = pszBuffer;
1616 int iSlash;
1617
1618 if (pszFilename[1] != ':')
1619 {
1620 /* iSlash */
1621 if (*pszFilename == '\\' || *pszFilename == '/')
1622 iSlash = 1;
1623 else
1624 iSlash = cSlashes;
1625
1626 /* interpret . and .. */
1627 while (*pszFilename != '\0')
1628 {
1629 if (*pszFilename == '.' && pszFilename[1] == '.' && (pszFilename[2] == '\\' || pszFilename[1] == '/'))
1630 { /* up one directory */
1631 if (iSlash > 0)
1632 iSlash--;
1633 pszFilename += 3;
1634 }
1635 else if (*pszFilename == '.' && (pszFilename[1] == '\\' || pszFilename[1] == '/'))
1636 { /* no change */
1637 pszFilename += 2;
1638 }
1639 else
1640 { /* completed expantion! - TODO ..\ or .\ may appare within the remaining path too... */
1641 strncpy(pszBuffer, szCurDir, aiSlashes[iSlash]+1);
1642 strcpy(pszBuffer + aiSlashes[iSlash]+1, pszFilename);
1643 break;
1644 }
1645 }
1646 }
1647 else
1648 { /* have drive letter specified - assume ok (TODO)*/
1649 strcpy(pszBuffer, pszFilename);
1650 }
1651
1652 /* correct slashes */
1653 while ((pszBuffer = strchr(pszBuffer, '//')) != NULL)
1654 *pszBuffer++ = '\\';
1655
1656 /* lower case it */
1657 /*strlwr(psz);*/
1658
1659 return psz;
1660}
1661
1662
1663/**
1664 * Copies the path part (excluding the slash) into pszBuffer and returns
1665 * a pointer to the buffer.
1666 * If no path is found "" is returned.
1667 * @returns Pointer to pszBuffer with path.
1668 * @param pszFilename Pointer to readonly filename.
1669 * @param pszBuffer Pointer to output Buffer.
1670 * @status completely implemented.
1671 * @author knut st. osmundsen
1672 */
1673char *filePath(const char *pszFilename, char *pszBuffer)
1674{
1675 char *psz = strrchr(pszFilename, '\\');
1676 if (psz == NULL)
1677 psz = strrchr(pszFilename, '/');
1678
1679 if (psz == NULL)
1680 *pszBuffer = '\0';
1681 else
1682 {
1683 strncpy(pszBuffer, pszFilename, psz - pszFilename);
1684 pszBuffer[psz - pszFilename] = '\0';
1685 }
1686
1687 return pszBuffer;
1688}
1689
1690
1691/**
1692 * Copies the path part including the slash into pszBuffer and returns
1693 * a pointer to the buffer.
1694 * If no path is found "" is returned.
1695 * @returns Pointer to pszBuffer with path.
1696 * @param pszFilename Pointer to readonly filename.
1697 * @param pszBuffer Pointer to output Buffer.
1698 * @status completely implemented.
1699 * @author knut st. osmundsen
1700 */
1701static char *filePathSlash(const char *pszFilename, char *pszBuffer)
1702{
1703 char *psz = strrchr(pszFilename, '\\');
1704 if (psz == NULL)
1705 psz = strrchr(pszFilename, '/');
1706
1707 if (psz == NULL)
1708 *pszBuffer = '\0';
1709 else
1710 {
1711 strncpy(pszBuffer, pszFilename, psz - pszFilename + 1);
1712 pszBuffer[psz - pszFilename + 1] = '\0';
1713 }
1714
1715 return pszBuffer;
1716}
1717
1718
1719/**
1720 * Copies the path part including the slash into pszBuffer and returns
1721 * a pointer to the buffer. If no path is found "" is returned.
1722 * The path is normalized to only use '\\'.
1723 * @returns Pointer to pszBuffer with path.
1724 * @param pszFilename Pointer to readonly filename.
1725 * @param pszBuffer Pointer to output Buffer.
1726 * @status completely implemented.
1727 * @author knut st. osmundsen
1728 */
1729static char *filePathSlash2(const char *pszFilename, char *pszBuffer)
1730{
1731 char *psz = strrchr(pszFilename, '\\');
1732 if (psz == NULL)
1733 psz = strrchr(pszFilename, '/');
1734
1735 if (psz == NULL)
1736 *pszBuffer = '\0';
1737 else
1738 {
1739 strncpy(pszBuffer, pszFilename, psz - pszFilename + 1);
1740 pszBuffer[psz - pszFilename + 1] = '\0';
1741
1742 /* normalize all '/' to '\\' */
1743 psz = pszBuffer;
1744 while ((psz = strchr(psz, '/')) != NULL)
1745 *psz++ = '\\';
1746 }
1747
1748 return pszBuffer;
1749}
1750
1751
1752/**
1753 * Copies the filename (with extention) into pszBuffer and returns
1754 * a pointer to the buffer.
1755 * @returns Pointer to pszBuffer with path.
1756 * @param pszFilename Pointer to readonly filename.
1757 * @param pszBuffer Pointer to output Buffer.
1758 * @status completely implemented.
1759 * @author knut st. osmundsen
1760 */
1761char *fileName(const char *pszFilename, char *pszBuffer)
1762{
1763 char *psz = strrchr(pszFilename, '\\');
1764 if (psz == NULL)
1765 psz = strrchr(pszFilename, '/');
1766
1767 strcpy(pszBuffer, psz == NULL ? pszFilename : psz + 1);
1768
1769 return pszBuffer;
1770}
1771
1772
1773/**
1774 * Copies the name part with out extention into pszBuffer and returns
1775 * a pointer to the buffer.
1776 * If no name is found "" is returned.
1777 * @returns Pointer to pszBuffer with path.
1778 * @param pszFilename Pointer to readonly filename.
1779 * @param pszBuffer Pointer to output Buffer.
1780 * @status completely implemented.
1781 * @author knut st. osmundsen
1782 */
1783char *fileNameNoExt(const char *pszFilename, char *pszBuffer)
1784{
1785 char *psz = strrchr(pszFilename, '\\');
1786 if (psz == NULL)
1787 psz = strrchr(pszFilename, '/');
1788
1789 strcpy(pszBuffer, psz == NULL ? pszFilename : psz + 1);
1790
1791 psz = strrchr(pszBuffer, '.');
1792 if (psz > pszBuffer) /* an extetion on it's own (.depend) is a filename not an extetion! */
1793 *psz = '\0';
1794
1795 return pszBuffer;
1796}
1797
1798
1799/**
1800 * Copies the extention part into pszBuffer and returns
1801 * a pointer to the buffer.
1802 * If no extention is found "" is returned.
1803 * The dot ('.') is not included!
1804 * @returns Pointer to pszBuffer with path.
1805 * @param pszFilename Pointer to readonly filename.
1806 * @param pszBuffer Pointer to output Buffer.
1807 * @status completely implemented.
1808 * @author knut st. osmundsen
1809 */
1810char *fileExt(const char *pszFilename, char *pszBuffer)
1811{
1812 char *psz = strrchr(pszFilename, '.');
1813 if (psz != NULL)
1814 {
1815 if (strchr(psz, '\\') != NULL || strchr(psz, '/') != NULL)
1816 *pszBuffer = '\0';
1817 else
1818 strcpy(pszBuffer, psz + 1);
1819 }
1820 else
1821 *pszBuffer = '\0';
1822
1823 return pszBuffer;
1824}
1825
1826
1827/**
1828 * Adds a file to the cache.
1829 * @returns Success indicator.
1830 * @param pszFilename Name of the file which is to be added. (with path!)
1831 */
1832static BOOL filecacheAddFile(const char *pszFilename)
1833{
1834 PFCACHEENTRY pfcNew;
1835
1836 /* allocate new block and fill in data */
1837 pfcNew = malloc(sizeof(FCACHEENTRY) + strlen(pszFilename) + 1);
1838 if (pfcNew == NULL)
1839 {
1840 fprintf(stderr, "error: out of memory! (line=%d)\n", __LINE__);
1841 return FALSE;
1842 }
1843 pfcNew->Key = (char*)(void*)pfcNew + sizeof(FCACHEENTRY);
1844 strcpy((char*)(unsigned)pfcNew->Key, pszFilename);
1845 if (!AVLInsert(&pfcTree, pfcNew))
1846 {
1847 free(pfcNew);
1848 return TRUE;
1849 }
1850 cfcNodes++;
1851
1852 return TRUE;
1853}
1854
1855
1856
1857/**
1858 * Adds a file to the cache.
1859 * @returns Success indicator.
1860 * @param pszDir Name of the path which is to be added. (with slash!)
1861 */
1862static BOOL filecacheAddDir(const char *pszDir)
1863{
1864 PFCACHEENTRY pfcNew;
1865 APIRET rc;
1866 char szDir[CCHMAXPATH];
1867 int cchDir;
1868 char achBuffer[16384];
1869 PFILEFINDBUF3 pfindbuf3 = (PFILEFINDBUF3)(void*)&achBuffer[0];
1870 HDIR hDir = HDIR_CREATE;
1871 ULONG cFiles = 0xFFFFFFF;
1872 int i;
1873
1874 /* Make path */
1875 filePathSlash2(pszDir, szDir);
1876 //strlwr(szDir); /* Convert name to lower case to allow faster searchs! */
1877 cchDir = strlen(szDir);
1878
1879
1880 /* Add directory to pfcDirTree. */
1881 pfcNew = malloc(sizeof(FCACHEENTRY) + cchDir + 1);
1882 if (pfcNew == NULL)
1883 {
1884 fprintf(stderr, "error: out of memory! (line=%d)\n", __LINE__);
1885 DosFindClose(hDir);
1886 return FALSE;
1887 }
1888 pfcNew->Key = (char*)(void*)pfcNew + sizeof(FCACHEENTRY);
1889 strcpy((char*)(unsigned)pfcNew->Key, szDir);
1890 AVLInsert(&pfcDirTree, pfcNew);
1891
1892
1893 /* Start to search directory - all files */
1894 strcat(szDir + cchDir, "*");
1895 rc = DosFindFirst(szDir, &hDir, FILE_NORMAL,
1896 pfindbuf3, sizeof(achBuffer),
1897 &cFiles, FIL_STANDARD);
1898 while (rc == NO_ERROR)
1899 {
1900 for (i = 0;
1901 i < cFiles;
1902 i++, pfindbuf3 = (PFILEFINDBUF3)((int)pfindbuf3 + pfindbuf3->oNextEntryOffset)
1903 )
1904 {
1905 pfcNew = malloc(sizeof(FCACHEENTRY) + cchDir + pfindbuf3->cchName + 1);
1906 if (pfcNew == NULL)
1907 {
1908 fprintf(stderr, "error: out of memory! (line=%d)\n", __LINE__);
1909 DosFindClose(hDir);
1910 return FALSE;
1911 }
1912 pfcNew->Key = (char*)(void*)pfcNew + sizeof(FCACHEENTRY);
1913 strcpy((char*)(unsigned)pfcNew->Key, szDir);
1914 strcpy((char*)(unsigned)pfcNew->Key + cchDir, pfindbuf3->achName);
1915 strlwr((char*)(unsigned)pfcNew->Key + cchDir); /* Convert name to lower case to allow faster searchs! */
1916 if (!AVLInsert(&pfcTree, pfcNew))
1917 free(pfcNew);
1918 else
1919 cfcNodes++;
1920 }
1921
1922 /* next */
1923 cFiles = 0xFFFFFFF;
1924 pfindbuf3 = (PFILEFINDBUF3)(void*)&achBuffer[0];
1925 rc = DosFindNext(hDir, pfindbuf3, sizeof(achBuffer), &cFiles);
1926 }
1927
1928 DosFindClose(hDir);
1929
1930 return TRUE;
1931}
1932
1933
1934/**
1935 * Checks if pszFilename is exists in the cache.
1936 * @return TRUE if found. FALSE if not found.
1937 * @param pszFilename Name of the file to be found. (with path!)
1938 * This is in lower case!
1939 */
1940INLINE BOOL filecacheFind(const char *pszFilename)
1941{
1942 return AVLGet(&pfcTree, (AVLKEY)pszFilename) != NULL;
1943}
1944
1945
1946/**
1947 * Checks if pszFilename is exists in the cache.
1948 * @return TRUE if found. FALSE if not found.
1949 * @param pszFilename Name of the file to be found. (with path!)
1950 * This is in lower case!
1951 */
1952INLINE BOOL filecacheIsDirCached(const char *pszDir)
1953{
1954 return AVLGet(&pfcDirTree, (AVLKEY)pszDir) != NULL;
1955}
1956
1957
1958
1959/**
1960 * Finds a filename in a specified pathlist.
1961 * @returns Pointer to a filename consiting of the path part + the given filename.
1962 * (pointer into pszBuffer)
1963 * NULL if file is not found. ("" in buffer)
1964 * @param pszPathList Path list to search for filename.
1965 * @parma pszFilename Filename to find.
1966 * @parma pszBuffer Ouput Buffer.
1967 * @param pOptions Pointer to options struct.
1968 * @status completely implemented.
1969 * @author knut st. osmundsen
1970 */
1971static char *pathlistFindFile(const char *pszPathList, const char *pszFilename, char *pszBuffer, POPTIONS pOptions)
1972{
1973 const char *psz = pszPathList;
1974 const char *pszNext = NULL;
1975
1976 *pszBuffer = '\0';
1977
1978 if (pszPathList == NULL)
1979 return NULL;
1980
1981 while (*psz != '\0')
1982 {
1983 /* find end of this path */
1984 pszNext = strchr(psz, ';');
1985 if (pszNext == NULL)
1986 pszNext = psz + strlen(psz);
1987
1988 if (pszNext - psz > 0)
1989 {
1990 APIRET rc;
1991
1992 /* make search statment */
1993 strncpy(pszBuffer, psz, pszNext - psz);
1994 pszBuffer[pszNext - psz] = '\0';
1995 if (pszBuffer[pszNext - psz - 1] != '\\' && pszBuffer[pszNext - psz - 1] != '/')
1996 strcpy(&pszBuffer[pszNext - psz], "\\");
1997 strcat(pszBuffer, pszFilename);
1998 fileNormalize(pszBuffer);
1999
2000 /*
2001 * Search for the file in this directory.
2002 * Search cache first
2003 */
2004 if (!filecacheFind(pszBuffer))
2005 {
2006 char szDir[CCHMAXPATH];
2007
2008 filePathSlash(pszBuffer, szDir);
2009 if (!filecacheIsDirCached(szDir))
2010 {
2011 /*
2012 * If caching of entire dirs are enabled, we'll
2013 * add the directory to the cache and search it.
2014 */
2015 if (pOptions->fCacheSearchDirs && filecacheAddDir(szDir))
2016 {
2017 if (filecacheFind(pszBuffer))
2018 return pszBuffer;
2019 }
2020 else
2021 {
2022 FILESTATUS3 fsts3;
2023
2024 /* ask the OS */
2025 rc = DosQueryPathInfo(pszBuffer, FIL_STANDARD, &fsts3, sizeof(fsts3));
2026 if (rc == NO_ERROR)
2027 { /* add file to cache. */
2028 filecacheAddFile(pszBuffer);
2029 return pszBuffer;
2030 }
2031 }
2032 }
2033 }
2034 else
2035 return pszBuffer;
2036 }
2037
2038 /* next */
2039 if (*pszNext != ';')
2040 break;
2041 psz = pszNext + 1;
2042 }
2043
2044 return NULL;
2045}
2046
2047
2048
2049/**
2050 * Checks if the given filename may exist within any of the given paths.
2051 * This check only matches the filename path agianst the paths in the pathlist.
2052 * @returns TRUE: if exists.
2053 * FALSE: don't exist.
2054 * @param pszPathList Path list to search for filename.
2055 * @parma pszFilename Filename to find. The filename should be normalized!
2056 * @param pOptions Pointer to options struct.
2057 * @status completely implemented.
2058 * @author knut st. osmundsen
2059 */
2060static BOOL pathlistFindFile2(const char *pszPathList, const char *pszFilename, POPTIONS pOptions)
2061{
2062 const char *psz = pszPathList;
2063 const char *pszNext = NULL;
2064 char szBuffer[CCHMAXPATH];
2065 char szBuffer2[CCHMAXPATH];
2066 char *pszPathToFind = &szBuffer2[0];
2067
2068 /*
2069 * Input checking
2070 */
2071 if (pszPathList == NULL)
2072 return FALSE;
2073
2074 /*
2075 * Normalize the filename and get it's path.
2076 */
2077 filePath(pszFilename, pszPathToFind);
2078
2079
2080 /*
2081 * Loop thru the path list.
2082 */
2083 while (*psz != '\0')
2084 {
2085 /* find end of this path */
2086 pszNext = strchr(psz, ';');
2087 if (pszNext == NULL)
2088 pszNext = psz + strlen(psz);
2089
2090 if (pszNext - psz > 0)
2091 {
2092 char * pszPath = &szBuffer[0];
2093
2094 /*
2095 * Extract and normalize the path
2096 */
2097 strncpy(pszPath, psz, pszNext - psz);
2098 pszPath[pszNext - psz] = '\0';
2099 if (pszPath[pszNext - psz - 1] == '\\' && pszPath[pszNext - psz - 1] == '/')
2100 pszPath[pszNext - psz - 1] = '\0';
2101 fileNormalize(pszPath);
2102
2103 /*
2104 * Check if it matches the path of the filename
2105 */
2106 if (strcmp(pszPath, pszPathToFind) == 0)
2107 return TRUE;
2108 }
2109
2110 /*
2111 * Next part of the path list.
2112 */
2113 if (*pszNext != ';')
2114 break;
2115 psz = pszNext + 1;
2116 }
2117
2118 pOptions = pOptions;
2119 return FALSE;
2120}
2121
2122
2123/**
2124 * Finds the first char after word.
2125 * @returns Pointer to the first char after word.
2126 * @param psz Where to start.
2127 * @author knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
2128 */
2129static char *findEndOfWord(char *psz)
2130{
2131
2132 while (*psz != '\0' &&
2133 (
2134 (*psz >= 'A' && *psz <= 'Z') || (*psz >= 'a' && *psz <= 'z')
2135 ||
2136 (*psz >= '0' && *psz <= '9')
2137 ||
2138 *psz == '_'
2139 )
2140 )
2141 ++psz;
2142 return (char *)psz;
2143}
2144
2145#if 0 /* not used */
2146/**
2147 * Find the starting char of a word
2148 * @returns Pointer to first char in word.
2149 * @param psz Where to start.
2150 * @param pszStart Where to stop.
2151 * @author knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
2152 */
2153static char *findStartOfWord(const char *psz, const char *pszStart)
2154{
2155 const char *pszR = psz;
2156 while (psz >= pszStart &&
2157 (
2158 (*psz >= 'A' && *psz <= 'Z')
2159 || (*psz >= 'a' && *psz <= 'z')
2160 || (*psz >= '0' && *psz <= '9')
2161 || *psz == '_'
2162 )
2163 )
2164 pszR = psz--;
2165 return (char*)pszR;
2166}
2167#endif
2168
2169/**
2170 * Find the size of a file.
2171 * @returns Size of file. -1 on error.
2172 * @param phFile File handle.
2173 */
2174static signed long fsize(FILE *phFile)
2175{
2176 int ipos;
2177 signed long cb;
2178
2179 if ((ipos = ftell(phFile)) < 0
2180 ||
2181 fseek(phFile, 0, SEEK_END) != 0
2182 ||
2183 (cb = ftell(phFile)) < 0
2184 ||
2185 fseek(phFile, ipos, SEEK_SET) != 0
2186 )
2187 cb = -1;
2188 return cb;
2189}
2190
2191
2192
2193/**
2194 * Trims a string, ie. removing spaces (and tabs) from both ends of the string.
2195 * @returns Pointer to first not space or tab char in the string.
2196 * @param psz Pointer to the string which is to be trimmed.
2197 * @status completely implmented.
2198 * @author knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
2199 */
2200INLINE char *trim(char *psz)
2201{
2202 int i;
2203 if (psz == NULL)
2204 return NULL;
2205 while (*psz == ' ' || *psz == '\t')
2206 psz++;
2207 i = strlen(psz) - 1;
2208 while (i >= 0 && (psz[i] == ' ' || *psz == '\t'))
2209 i--;
2210 psz[i+1] = '\0';
2211 return psz;
2212}
2213
2214
2215/**
2216 * Right trims a string, ie. removing spaces (and tabs) from the end of the stri
2217 * @returns Pointer to the string passed in.
2218 * @param psz Pointer to the string which is to be right trimmed.
2219 * @status completely implmented.
2220 * @author knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
2221 */
2222INLINE char *trimR(char *psz)
2223{
2224 int i;
2225 if (psz == NULL)
2226 return NULL;
2227 i = strlen(psz) - 1;
2228 while (i >= 0 && (psz[i] == ' ' || *psz == '\t'))
2229 i--;
2230 psz[i+1] = '\0';
2231 return psz;
2232}
2233
2234
2235/**
2236 * Creates a memory buffer for a text file.
2237 * @returns Pointer to file memoryblock. NULL on error.
2238 * @param pszFilename Pointer to filename string.
2239 * @remark This function is the one using most of the execution
2240 * time (DosRead + DosOpen) - about 70% of the execution time!
2241 */
2242static void *textbufferCreate(const char *pszFilename)
2243{
2244 void *pvFile = NULL;
2245 FILE *phFile;
2246
2247 phFile = fopen(pszFilename, "rb");
2248 if (phFile != NULL)
2249 {
2250 signed long cbFile = fsize(phFile);
2251 if (cbFile >= 0)
2252 {
2253 pvFile = malloc(cbFile + 1);
2254 if (pvFile != NULL)
2255 {
2256 memset(pvFile, 0, cbFile + 1);
2257 if (cbFile > 0 && fread(pvFile, 1, cbFile, phFile) == 0)
2258 { /* failed! */
2259 free(pvFile);
2260 pvFile = NULL;
2261 }
2262 }
2263 else
2264 fprintf(stderr, "warning/error: failed to open file %s\n", pszFilename);
2265 }
2266 fclose(phFile);
2267 }
2268 return pvFile;
2269}
2270
2271
2272/**
2273 * Destroys a text textbuffer.
2274 * @param pvBuffer Buffer handle.
2275 */
2276static void textbufferDestroy(void *pvBuffer)
2277{
2278 free(pvBuffer);
2279}
2280
2281
2282/**
2283 * Gets the next line from an textbuffer.
2284 * @returns Pointer to the next line.
2285 * @param pvBuffer Buffer handle.
2286 * @param psz Pointer to current line.
2287 * NULL is passed in to get the first line.
2288 */
2289static char *textbufferNextLine(void *pvBuffer, register char *psz)
2290{
2291 register char ch;
2292
2293 /* if first line psz is NULL. */
2294 if (psz == NULL)
2295 return (char*)pvBuffer;
2296
2297 /* skip till end of file or end of line. */
2298 ch = *psz;
2299 while (ch != '\0' && ch != '\n' && ch != '\r')
2300 ch = *++psz;
2301
2302 /* skip line end */
2303 if (ch == '\r')
2304 ch = *++psz;
2305 if (ch == '\n')
2306 psz++;
2307
2308 return psz;
2309}
2310
2311
2312/**
2313 * Gets the next line from an textbuffer.
2314 * (fgets for textbuffer)
2315 * @returns Pointer to pszOutBuffer. NULL when end of file.
2316 * @param pvBuffer Buffer handle.
2317 * @param ppv Pointer to a buffer index pointer. (holds the current buffer index)
2318 * Pointer to a null pointer is passed in to get the first line.
2319 * @param pszLineBuffer Output line buffer. (!= NULL)
2320 * @param cchLineBuffer Size of the output line buffer. (> 0)
2321 * @remark '\n' and '\r' are removed!
2322 */
2323static char *textbufferGetNextLine(void *pvBuffer, void **ppv, char *pszLineBuffer, int cchLineBuffer)
2324{
2325 char * pszLine = pszLineBuffer;
2326 char * psz = *(char**)(void*)ppv;
2327 register char ch;
2328
2329 /* first line? */
2330 if (psz == NULL)
2331 psz = pvBuffer;
2332
2333 /* Copy to end of the line or end of the linebuffer. */
2334 ch = *psz;
2335 cchLineBuffer--; /* reserve space for '\0' */
2336 while (cchLineBuffer > 0 && ch != '\0' && ch != '\n' && ch != '\r')
2337 {
2338 *pszLine++ = ch;
2339 ch = *++psz;
2340 }
2341 *pszLine = '\0';
2342
2343 /* skip line end */
2344 if (ch == '\r')
2345 ch = *++psz;
2346 if (ch == '\n')
2347 psz++;
2348
2349 /* check if position has changed - if unchanged it's the end of file! */
2350 if (*ppv == (void*)psz)
2351 pszLineBuffer = NULL;
2352
2353 /* store current position */
2354 *ppv = (void*)psz;
2355
2356 return pszLineBuffer;
2357}
2358
2359
2360/**
2361 * Appends a depend file to the internal file.
2362 */
2363static BOOL depReadFile(const char *pszFilename, POPTIONS pOptions)
2364{
2365 void *pvFile;
2366 char *pszNext;
2367 BOOL fMoreDeps = FALSE;
2368 void *pvRule = NULL;
2369
2370 /* read depend file */
2371 pvFile = textbufferCreate(pszFilename);
2372 if (pvFile == NULL)
2373 return FALSE;
2374
2375 /* parse the original depend file */
2376 pszNext = pvFile;
2377 while (*pszNext != '\0')
2378 {
2379 int i;
2380 int cch;
2381 char *psz;
2382
2383 /* get the next line. */
2384 psz = pszNext;
2385 pszNext = textbufferNextLine(pvFile, pszNext);
2386
2387 /*
2388 * Process the current line:
2389 * Start off by terminating the line.
2390 * Trim the line,
2391 * Skip empty lines.
2392 * If not looking for more deps Then
2393 * Check if new rule starts here.
2394 * Endif
2395 *
2396 * If more deps to last rule Then
2397 * Get dependant name.
2398 * Endif
2399 */
2400 i = -1;
2401 while (psz <= &pszNext[i] && pszNext[i] == '\n' || pszNext[i] == '\r')
2402 pszNext[i--] = '\0';
2403 trimR(psz);
2404 cch = strlen(psz);
2405 if (cch == 0)
2406 continue;
2407
2408 /* new rule? */
2409 if (!fMoreDeps && *psz != ' ' && *psz != '\t' && *psz != '\0')
2410 {
2411 i = 0;
2412 while (psz[i] != '\0')
2413 {
2414 if (psz[i] == ':'
2415 && (psz[i+1] == ' '
2416 || psz[i+1] == '\t'
2417 || psz[i+1] == '\0'
2418 || (psz[i+1] == '\\' && psz[i+2] == '\0')
2419 )
2420 )
2421 {
2422 psz[i] = '\0';
2423 pvRule = depAddRule(trimR(psz), NULL, NULL);
2424 psz += i + 1;
2425 cch -= i + 1;
2426 fMoreDeps = TRUE;
2427 break;
2428 }
2429 i++;
2430 }
2431 }
2432
2433 /* more dependants */
2434 if (fMoreDeps)
2435 {
2436 if (cch > 0 && psz[cch-1] == '\\')
2437 {
2438 fMoreDeps = TRUE;
2439 psz[cch-1] = '\0';
2440 }
2441 else
2442 fMoreDeps = FALSE;
2443
2444 /* if not duplicate rule */
2445 if (pvRule != NULL)
2446 {
2447 psz = trim(psz);
2448 if (*psz != '\0')
2449 depAddDepend(pvRule, psz, pOptions->fCheckCyclic);
2450 }
2451 }
2452 } /* while */
2453
2454
2455 /* return succesfully */
2456 textbufferDestroy(pvFile);
2457 return TRUE;
2458}
2459
2460/**
2461 *
2462 * @returns Success indicator.
2463 * @params pszFilename Pointer to name of the output file.
2464 */
2465static BOOL depWriteFile(const char *pszFilename)
2466{
2467 FILE *phFile;
2468 phFile = fopen(pszFilename, "w");
2469 if (phFile != NULL)
2470 {
2471 AVLENUMDATA EnumData;
2472 PDEPRULE pdep;
2473 char szBuffer[4096];
2474 int iBuffer = 0;
2475 int cch;
2476
2477 pdep = (PDEPRULE)(void*)AVLBeginEnumTree((PPAVLNODECORE)(void*)&pdepTree, &EnumData, TRUE);
2478 while (pdep != NULL)
2479 {
2480 /* Write rule. Flush the buffer first if necessary. */
2481 cch = strlen(pdep->pszRule);
2482 if (iBuffer + cch + 2 >= sizeof(szBuffer))
2483 {
2484 fwrite(szBuffer, iBuffer, 1, phFile);
2485 iBuffer = 0;
2486 }
2487 strcpy(szBuffer + iBuffer, pdep->pszRule);
2488 iBuffer += cch;
2489 strcpy(szBuffer + iBuffer++, ":");
2490
2491 /* write rule dependants. */
2492 if (pdep->papszDep != NULL)
2493 {
2494 char **ppsz = pdep->papszDep;
2495 while (*ppsz != NULL)
2496 {
2497 /* flush buffer? */
2498 if (iBuffer + strlen(*ppsz) + 20 >= sizeof(szBuffer))
2499 {
2500 fwrite(szBuffer, iBuffer, 1, phFile);
2501 iBuffer = 0;
2502 }
2503 iBuffer += sprintf(szBuffer + iBuffer, " \\\n %s", *ppsz);
2504
2505 /* next dependant */
2506 ppsz++;
2507 }
2508 }
2509
2510 /* Add two new lines. Flush buffer first if necessary. */
2511 if (iBuffer + 2 >= sizeof(szBuffer))
2512 {
2513 fwrite(szBuffer, iBuffer, 1, phFile);
2514 iBuffer = 0;
2515 }
2516 strcpy(szBuffer + iBuffer, "\n\n");
2517 iBuffer += 2;
2518
2519 /* next rule */
2520 pdep = (PDEPRULE)(void*)AVLGetNextNode(&EnumData);
2521 }
2522
2523 /* flush buffer. */
2524 fwrite(szBuffer, iBuffer, 1, phFile);
2525
2526 fclose(phFile);
2527 return TRUE;
2528 }
2529
2530 return FALSE;
2531}
2532
2533
2534/**
2535 * Removes all nodes in the tree of dependencies. (pdepTree)
2536 */
2537static void depRemoveAll(void)
2538{
2539 AVLENUMDATA EnumData;
2540 PDEPRULE pdep;
2541
2542 pdep = (PDEPRULE)(void*)AVLBeginEnumTree((PPAVLNODECORE)(void*)&pdepTree, &EnumData, TRUE);
2543 while (pdep != NULL)
2544 {
2545 /* free this */
2546 if (pdep->papszDep != NULL)
2547 {
2548 char ** ppsz = pdep->papszDep;
2549 while (*ppsz != NULL)
2550 free(*ppsz++);
2551 free(pdep->papszDep);
2552 }
2553 free(pdep);
2554
2555 /* next */
2556 pdep = (PDEPRULE)(void*)AVLGetNextNode(&EnumData);
2557 }
2558 pdepTree = NULL;
2559}
2560
2561
2562/**
2563 * Adds a rule to the list of dependant rules.
2564 * @returns Rule handle. NULL if rule exists/error.
2565 * @param pszRulePath Pointer to rule text. Empty strings are banned!
2566 * This string might only contain the path of the rule. (with '\\')
2567 * @param pszName Name of the rule.
2568 * NULL if pszRulePath contains the entire rule.
2569 * @param pszExt Extention (without '.')
2570 * NULL if pszRulePath or pszRulePath and pszName contains the entire rule.
2571 */
2572static void *depAddRule(const char *pszRulePath, const char *pszName, const char *pszExt)
2573{
2574 char szRule[CCHMAXPATH*2];
2575 PDEPRULE pNew;
2576 int cch;
2577
2578 /* make rulename */
2579 strcpy(szRule, pszRulePath);
2580 cch = strlen(szRule);
2581 if (pszName != NULL)
2582 {
2583 strcpy(szRule + cch, pszName);
2584 cch += strlen(szRule + cch);
2585 }
2586 if (pszExt != NULL)
2587 {
2588 strcat(szRule + cch++, ".");
2589 strcat(szRule + cch, pszExt);
2590 cch += strlen(szRule + cch);
2591 }
2592
2593
2594 /*
2595 * Allocate a new rule structure and fill in data
2596 * Note. One block for both the DEPRULE and the pszRule string.
2597 */
2598 pNew = malloc(sizeof(DEPRULE) + cch + 1);
2599 if (pNew == NULL)
2600 {
2601 fprintf(stderr, "error: out of memory. (line=%d)\n", __LINE__);
2602 return NULL;
2603 }
2604 pNew->pszRule = (char*)(void*)(pNew + 1);
2605 strcpy(pNew->pszRule, szRule);
2606 pNew->cDeps = 0;
2607 pNew->papszDep = NULL;
2608 pNew->avlCore.Key = pNew->pszRule;
2609
2610 /* Insert rule */
2611 if (!AVLInsert((PPAVLNODECORE)(void*)&pdepTree, &pNew->avlCore))
2612 { /* rule existed - return NULL */
2613 free(pNew);
2614 return NULL;
2615 }
2616
2617 return pNew;
2618}
2619
2620
2621
2622/**
2623 * Adds a dependant to a rule.
2624 * @returns Successindicator. TRUE = success.
2625 * FALSE = cyclic or out of memory.
2626 * @param pvRule Rule handle.
2627 * @param pszDep Pointer to dependant name
2628 * @param fCheckCyclic When set we'll check that we're not creating an cyclic dependency.
2629 */
2630static BOOL depAddDepend(void *pvRule, const char *pszDep, BOOL fCheckCyclic)
2631{
2632 PDEPRULE pdep = (PDEPRULE)pvRule;
2633
2634 if (fCheckCyclic && depCheckCyclic(pdep, pszDep))
2635 {
2636 fprintf(stderr, "warning: Cylic dependancy caused us to ignore '%s' in rule '%s'.\n",
2637 pszDep, pdep->pszRule);
2638 return FALSE;
2639 }
2640
2641 /* allocate more array space */
2642 if (((pdep->cDeps) % 48) == 0)
2643 {
2644 pdep->papszDep = realloc(pdep->papszDep, sizeof(char*) * (pdep->cDeps + 50));
2645 if (pdep->papszDep == NULL)
2646 {
2647 pdep->cDeps = 0;
2648 fprintf(stderr, "error: out of memory, (line=%d)\n", __LINE__);
2649 return FALSE;
2650 }
2651 }
2652
2653 /* allocate string space and copy pszDep */
2654 if ((pdep->papszDep[pdep->cDeps] = malloc(strlen(pszDep) + 1)) == NULL)
2655 {
2656 fprintf(stderr, "error: out of memory, (line=%d)\n", __LINE__);
2657 return FALSE;
2658 }
2659 strcpy(pdep->papszDep[pdep->cDeps], pszDep);
2660
2661 /* terminate array and increment dep count */
2662 pdep->papszDep[++pdep->cDeps] = NULL;
2663
2664 /* successful! */
2665 return TRUE;
2666}
2667
2668
2669/**
2670 * Checks if adding this dependent will create a cylic dependency.
2671 * @returns TRUE: Cyclic.
2672 * FALSE: Non-cylic.
2673 * @param pdepRule Rule pszDep is to be inserted in.
2674 * @param pszDep Depend name.
2675 */
2676static BOOL depCheckCyclic(PDEPRULE pdepRule, const char *pszDep)
2677{
2678 #define DEPTH 32
2679 char * pszRule = pdepRule->pszRule;
2680 char ** appsz[DEPTH];
2681 PDEPRULE pdep;
2682 int i;
2683
2684 /* self check */
2685 if (strcmp(pdepRule->pszRule, pszDep) == 0)
2686 return TRUE;
2687
2688 /* find rule for the dep. */
2689 if ((pdep = (PDEPRULE)(void*)AVLGet((PPAVLNODECORE)(void*)&pdepTree, pszDep)) == NULL
2690 || pdep->papszDep == NULL)
2691 return FALSE; /* no rule, or no dependents, not cyclic */
2692
2693 i = 0;
2694 appsz[0] = pdep->papszDep;
2695 while (i >= 0)
2696 {
2697 register char ** ppsz = appsz[i];
2698
2699 while (*ppsz != NULL)
2700 {
2701 /* check if equal to the main rule */
2702 if (strcmp(pszRule, *ppsz) == 0)
2703 return TRUE;
2704
2705 /* push onto stack (ppsz is incremented in this test!) */
2706 if ((pdep = (PDEPRULE)(void*)AVLGet((PPAVLNODECORE)(void*)&pdepTree, *ppsz++)) != NULL
2707 && pdep->papszDep != NULL)
2708 {
2709 if (i >= DEPTH)
2710 {
2711 fprintf(stderr, "error: too deap chain (%d). pszRule=%s pszDep=%s\n",
2712 i, pszRule, pszDep);
2713 return FALSE;
2714 }
2715 appsz[i++] = ppsz; /* save next */
2716 ppsz = pdep->papszDep; /* start processing new node */
2717 }
2718 }
2719
2720 /* pop stack */
2721 i--;
2722 }
2723
2724 return FALSE;
2725}
2726
2727
2728/*
2729 * Testing purpose.
2730 */
2731#include <os2.h>
2732#ifdef OLEMANN
2733#include "olemann.h"
2734#endif
2735
2736
2737
Note: See TracBrowser for help on using the repository browser.