ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add clang-format support for fastdep tool

Browse Source
This commit is contained in:
Axel Kohlmeyer
2021-05-05 23:46:26 -04:00
parent 97cd87a198
commit 9e4c618d30
2 changed files with 115 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
src/DEPEND/.clang-format Normal file
View File

@ -0,0 +1,31 @@
---
BasedOnStyle: LLVM
AccessModifierOffset: -1
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Left
AlignOperands: false
AllowShortBlocksOnASingleLine: true
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: WithoutElse
AllowShortLambdasOnASingleLine: None
AllowShortLoopsOnASingleLine: true
BraceWrapping:
AfterFunction: true
BreakBeforeBraces: Custom
BreakConstructorInitializers: AfterColon
BreakInheritanceList: AfterColon
ColumnLimit: 80
IndentCaseLabels: true
IndentWidth: 4
NamespaceIndentation: Inner
ObjCBlockIndentWidth: 2
PenaltyBreakAssignment: 4
ReflowComments: false
SpaceAfterCStyleCast: false
SpacesBeforeTrailingComments: 4
SpacesInContainerLiterals: false
Standard: Cpp11
TabWidth: 2
UseTab: Never
...

174
src/DEPEND/fastdep.c
View File

@ -28,16 +28,16 @@
*/ */
#include <stdio.h> #include <stdio.h>
#include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/types.h> #include <string.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h>
const char version[] = "2.1"; const char version[] = "2.1";
/* store list of accepted extensions for object targets */ /* store list of accepted extensions for object targets */
static const char *extensions[] = { ".cpp", ".c", ".cu" }; static const char *extensions[] = {".cpp", ".c", ".cu"};
static const int numextensions = sizeof(extensions)/sizeof(const char *); static const int numextensions = sizeof(extensions) / sizeof(const char *);
/* strdup() is not part of ANSI C. provide a replacement for portability */ /* strdup() is not part of ANSI C. provide a replacement for portability */
static char *my_strdup(const char *src) static char *my_strdup(const char *src)
@ -47,8 +47,8 @@ static char *my_strdup(const char *src)
if (src == NULL) return NULL; if (src == NULL) return NULL;
len = strlen(src); len = strlen(src);
ptr = (char *)malloc(len+1); ptr = (char *)malloc(len + 1);
if (ptr) memcpy(ptr,src,len+1); if (ptr) memcpy(ptr, src, len + 1);
return ptr; return ptr;
} }
@ -60,8 +60,7 @@ static char *my_strdup(const char *src)
char *trim_path(char *path) char *trim_path(char *path)
{ {
int last = strlen(path) - 1; int last = strlen(path) - 1;
while ((path[last] == '/') || (path[last] == '\\')) while ((path[last] == '/') || (path[last] == '\\')) --last;
--last;
path[++last] = '\0'; path[++last] = '\0';
return path; return path;
} }
@ -73,13 +72,13 @@ int file_exists(const char *path)
struct _stat s; struct _stat s;
if (path == NULL) return 0; if (path == NULL) return 0;
if (_stat(path,&s) != 0) return 0; if (_stat(path, &s) != 0) return 0;
return 1; return 1;
#else #else
struct stat s; struct stat s;
if (path == NULL) return 0; if (path == NULL) return 0;
if (stat(path,&s) != 0) return 0; if (stat(path, &s) != 0) return 0;
return 1; return 1;
#endif #endif
} }
@ -87,14 +86,14 @@ int file_exists(const char *path)
/* simple integer square root */ /* simple integer square root */
static int isqrt(int n) static int isqrt(int n)
{ {
int b = 0; int b = 0;
while(n >= 0) { while (n >= 0) {
n = n - b; n = n - b;
b = b + 1; b = b + 1;
n = n - b; n = n - b;
} }
return b - 1; return b - 1;
} }
/* determine next available prime number */ /* determine next available prime number */
@ -105,10 +104,10 @@ static int next_prime(const int num)
/* nprime has to be larger than num and odd */ /* nprime has to be larger than num and odd */
nprime = num + (num & 1) + 1; nprime = num + (num & 1) + 1;
/* there is always a prime between n and 2n */ /* there is always a prime between n and 2n */
while (nprime < 2*num) { while (nprime < 2 * num) {
/* brute force division test on odd factors up to sqrt(nprime) */ /* brute force division test on odd factors up to sqrt(nprime) */
root = isqrt(nprime)+1; root = isqrt(nprime) + 1;
for (factor = 3; factor < root; factor +=2) { for (factor = 3; factor < root; factor += 2) {
if (nprime % factor == 0) break; if (nprime % factor == 0) break;
} }
/* if the loop didn't exit early, we have found a prime */ /* if the loop didn't exit early, we have found a prime */
@ -216,7 +215,7 @@ static void llist_append(llist_t *ll, const char *key)
if ((ll == NULL) || (key == NULL)) return; if ((ll == NULL) || (key == NULL)) return;
ll->tail->key = my_strdup(key); ll->tail->key = my_strdup(key);
ll->count ++; ll->count++;
tmp = (llnode_t *)malloc(sizeof(llnode_t)); tmp = (llnode_t *)malloc(sizeof(llnode_t));
tmp->key = NULL; tmp->key = NULL;
tmp->next = NULL; tmp->next = NULL;
@ -237,19 +236,18 @@ static void llist_print(llist_t *ll)
tmp = ll->head; tmp = ll->head;
if (tmp->next) { if (tmp->next) {
fputs(tmp->key,stdout); fputs(tmp->key, stdout);
tmp = tmp->next; tmp = tmp->next;
} }
while (tmp->next) { while (tmp->next) {
fputc(':',stdout); fputc(':', stdout);
fputs(tmp->key,stdout); fputs(tmp->key, stdout);
tmp = tmp->next; tmp = tmp->next;
} }
fputc('\n',stdout); fputc('\n', stdout);
} }
/************************************************************************ /************************************************************************
* set functions * set functions
************************************************************************/ ************************************************************************/
@ -260,8 +258,8 @@ static set_t *set_init(int num)
set_t *s = (set_t *)malloc(sizeof(set_t)); set_t *s = (set_t *)malloc(sizeof(set_t));
s->nbuckets = next_prime(num); s->nbuckets = next_prime(num);
s->buckets = malloc(s->nbuckets*sizeof(llnode_t)); s->buckets = malloc(s->nbuckets * sizeof(llnode_t));
memset(s->buckets,0,s->nbuckets*sizeof(llnode_t)); memset(s->buckets, 0, s->nbuckets * sizeof(llnode_t));
s->count = 0; s->count = 0;
return s; return s;
@ -299,10 +297,10 @@ static void set_add(set_t *s, const char *key)
idx = hash_func(key) % s->nbuckets; idx = hash_func(key) % s->nbuckets;
tmp = s->buckets + idx; tmp = s->buckets + idx;
while (tmp->next != NULL) { while (tmp->next != NULL) {
if (strcmp(tmp->key,key) == 0) return; if (strcmp(tmp->key, key) == 0) return;
tmp = tmp->next; tmp = tmp->next;
} }
s->count ++; s->count++;
tmp->key = my_strdup(key); tmp->key = my_strdup(key);
tmp->next = (llnode_t *)malloc(sizeof(llnode_t)); tmp->next = (llnode_t *)malloc(sizeof(llnode_t));
tmp = tmp->next; tmp = tmp->next;
@ -321,7 +319,7 @@ static int set_find(set_t *s, const char *key)
idx = hash_func(key) % s->nbuckets; idx = hash_func(key) % s->nbuckets;
tmp = s->buckets + idx; tmp = s->buckets + idx;
while (tmp->next != NULL) { while (tmp->next != NULL) {
if (strcmp(tmp->key,key) == 0) return 1; if (strcmp(tmp->key, key) == 0) return 1;
tmp = tmp->next; tmp = tmp->next;
} }
return 0; return 0;
@ -344,8 +342,8 @@ static map_t *map_init(int num)
if (!m) return NULL; if (!m) return NULL;
m->nbuckets = next_prime(num); m->nbuckets = next_prime(num);
m->buckets = malloc(m->nbuckets*sizeof(mapnode_t)); m->buckets = malloc(m->nbuckets * sizeof(mapnode_t));
memset(m->buckets,0,m->nbuckets*sizeof(mapnode_t)); memset(m->buckets, 0, m->nbuckets * sizeof(mapnode_t));
m->count = 0; m->count = 0;
return m; return m;
@ -385,13 +383,13 @@ static void map_add(map_t *m, const char *key, const char *val)
idx = hash_func(key) % m->nbuckets; idx = hash_func(key) % m->nbuckets;
tmp = m->buckets + idx; tmp = m->buckets + idx;
while (tmp->next != NULL) { while (tmp->next != NULL) {
if (strcmp(tmp->key,key) == 0) break; if (strcmp(tmp->key, key) == 0) break;
tmp = tmp->next; tmp = tmp->next;
} }
/* add new entry to map */ /* add new entry to map */
if (tmp->next == NULL) { if (tmp->next == NULL) {
m->count ++; m->count++;
tmp->key = my_strdup(key); tmp->key = my_strdup(key);
tmp->val = set_init(50); /* XXX: chosen arbitrarily */ tmp->val = set_init(50); /* XXX: chosen arbitrarily */
tmp->next = (mapnode_t *)malloc(sizeof(mapnode_t)); tmp->next = (mapnode_t *)malloc(sizeof(mapnode_t));
@ -399,7 +397,7 @@ static void map_add(map_t *m, const char *key, const char *val)
tmp->next->val = NULL; tmp->next->val = NULL;
tmp->next->next = NULL; tmp->next->next = NULL;
} }
set_add(tmp->val,val); set_add(tmp->val, val);
} }
/* return an entry in the map */ /* return an entry in the map */
@ -413,7 +411,7 @@ static set_t *map_find(map_t *m, const char *key)
idx = hash_func(key) % m->nbuckets; idx = hash_func(key) % m->nbuckets;
tmp = m->buckets + idx; tmp = m->buckets + idx;
while (tmp->next != NULL) { while (tmp->next != NULL) {
if (strcmp(tmp->key,key) == 0) return tmp->val; if (strcmp(tmp->key, key) == 0) return tmp->val;
tmp = tmp->next; tmp = tmp->next;
} }
return NULL; return NULL;
@ -459,11 +457,11 @@ static void make_path(const char *file, llist_t *paths, char *buffer)
/************************************************************************/ /************************************************************************/
static void find_includes(llnode_t *head, llist_t *todo, llist_t *paths, static void find_includes(llnode_t *head, llist_t *todo, llist_t *paths,
set_t *incl, map_t *deps) set_t *incl, map_t *deps)
{ {
FILE *fp; FILE *fp;
llnode_t *tmp; llnode_t *tmp;
char *buffer,*full,*ptr,*end; char *buffer, *full, *ptr, *end;
const char *file; const char *file;
buffer = (char *)malloc(4096); buffer = (char *)malloc(4096);
@ -472,16 +470,16 @@ static void find_includes(llnode_t *head, llist_t *todo, llist_t *paths,
tmp = head; tmp = head;
while (tmp->next != NULL) { while (tmp->next != NULL) {
file = tmp->key; file = tmp->key;
fp = fopen(file,"r"); fp = fopen(file, "r");
if (fp == NULL) { if (fp == NULL) {
perror("Cannot read source"); perror("Cannot read source");
fprintf(stderr,"For file: %s\n",file); fprintf(stderr, "For file: %s\n", file);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
/* read file line by line and look for #include "..." */ /* read file line by line and look for #include "..." */
while (!feof(fp) && !ferror(fp)) { while (!feof(fp) && !ferror(fp)) {
if (fgets(buffer,4096,fp) == NULL) continue; if (fgets(buffer, 4096, fp) == NULL) continue;
ptr = buffer; ptr = buffer;
while (*ptr == ' ' || *ptr == '\t') ++ptr; while (*ptr == ' ' || *ptr == '\t') ++ptr;
if (*ptr != '#') continue; if (*ptr != '#') continue;
@ -500,7 +498,7 @@ static void find_includes(llnode_t *head, llist_t *todo, llist_t *paths,
end = ptr; end = ptr;
while (*end != '"') { while (*end != '"') {
if (*end == '\0') { if (*end == '\0') {
fprintf(stderr,"Unmatched '\"': %s\n",buffer); fprintf(stderr, "Unmatched '\"': %s\n", buffer);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
++end; ++end;
@ -508,18 +506,18 @@ static void find_includes(llnode_t *head, llist_t *todo, llist_t *paths,
*end = '\0'; *end = '\0';
/* get full path to include file */ /* get full path to include file */
make_path(ptr,paths,full); make_path(ptr, paths, full);
/* skip, if not found or unreadable. */ /* skip, if not found or unreadable. */
if (full[0] == '\0') continue; if (full[0] == '\0') continue;
/* if this is a yet unknown include, add to the /* if this is a yet unknown include, add to the
* todo list, if append is enabled */ * todo list, if append is enabled */
if (set_find(incl,full) == 0) { if (set_find(incl, full) == 0) {
set_add(incl,full); set_add(incl, full);
llist_append(todo,full); llist_append(todo, full);
} }
map_add(deps,file,full); map_add(deps, file, full);
} }
fclose(fp); fclose(fp);
tmp = tmp->next; tmp = tmp->next;
@ -534,26 +532,25 @@ static void add_depend(const char *source, set_t *incl, map_t *deps)
{ {
set_t *mydeps; set_t *mydeps;
llnode_t *tmp; llnode_t *tmp;
int i,num; int i, num;
if (source == NULL) return; if (source == NULL) return;
mydeps = map_find(deps,source); mydeps = map_find(deps, source);
if (mydeps != NULL) { if (mydeps != NULL) {
num = mydeps->nbuckets; num = mydeps->nbuckets;
for (i = 0; i < num; ++i) { for (i = 0; i < num; ++i) {
tmp = mydeps->buckets + i; tmp = mydeps->buckets + i;
while (tmp->next != NULL) { while (tmp->next != NULL) {
if (set_find(incl,tmp->key) == 0) { if (set_find(incl, tmp->key) == 0) {
set_add(incl,tmp->key); set_add(incl, tmp->key);
add_depend(tmp->key,incl,deps); add_depend(tmp->key, incl, deps);
} }
tmp = tmp->next; tmp = tmp->next;
} }
} }
} }
} }
/************************************************************************/ /************************************************************************/
@ -564,23 +561,23 @@ static void do_depend(llnode_t *head, map_t *deps)
set_t *incl; set_t *incl;
const char *source; const char *source;
char *target, *ptr; char *target, *ptr;
int i,num,ext; int i, num, ext;
tmp = head; tmp = head;
while (tmp->next != NULL) { while (tmp->next != NULL) {
source = tmp->key; source = tmp->key;
target = strrchr(source,'/'); target = strrchr(source, '/');
if (target == NULL) { if (target == NULL) {
target = my_strdup(source); target = my_strdup(source);
} else { } else {
target = my_strdup(target+1); target = my_strdup(target + 1);
} }
ext = 0; ext = 0;
ptr = strrchr(target,'.'); ptr = strrchr(target, '.');
if (ptr != NULL) { if (ptr != NULL) {
for (i = 0; i < numextensions; ++i) { for (i = 0; i < numextensions; ++i) {
if (strcmp(ptr,extensions[i]) == 0) ++ext; if (strcmp(ptr, extensions[i]) == 0) ++ext;
} }
if (ext > 0) { if (ext > 0) {
ptr[1] = 'o'; ptr[1] = 'o';
@ -589,23 +586,23 @@ static void do_depend(llnode_t *head, map_t *deps)
} }
if (ext > 0) { if (ext > 0) {
fputs(target,stdout); fputs(target, stdout);
fputs(" : ",stdout); fputs(" : ", stdout);
fputs(source,stdout); fputs(source, stdout);
incl = set_init(50); incl = set_init(50);
add_depend(source,incl,deps); add_depend(source, incl, deps);
num = incl->nbuckets; num = incl->nbuckets;
for (i = 0; i < num; ++i) { for (i = 0; i < num; ++i) {
lnk = incl->buckets + i; lnk = incl->buckets + i;
while (lnk->next != NULL) { while (lnk->next != NULL) {
fputc(' ',stdout); fputc(' ', stdout);
fputs(lnk->key,stdout); fputs(lnk->key, stdout);
lnk = lnk->next; lnk = lnk->next;
} }
} }
fputc('\n',stdout); fputc('\n', stdout);
set_free(incl); set_free(incl);
} }
@ -614,74 +611,71 @@ static void do_depend(llnode_t *head, map_t *deps)
} }
} }
/************************************************************************/ /************************************************************************/
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
llist_t *paths,*src,*todo; llist_t *paths, *src, *todo;
set_t *incl; set_t *incl;
map_t *deps; map_t *deps;
if (argc < 2) { if (argc < 2) {
fprintf(stderr,"FastDep v%s for LAMMPS\n" fprintf(stderr,
"FastDep v%s for LAMMPS\n"
"Usage: %s [-I <path> ...] -- <src1> [<src2> ...]\n", "Usage: %s [-I <path> ...] -- <src1> [<src2> ...]\n",
version,argv[0]); version, argv[0]);
fprintf(stderr,"Supported extensions: %d, %s, %s\n",numextensions, fprintf(stderr, "Supported extensions: %d, %s, %s\n", numextensions,
extensions[0], extensions[1]); extensions[0], extensions[1]);
return 1; return 1;
} }
/* hash tables for all known included files and dependencies /* hash tables for all known included files and dependencies
* we guesstimate a little over 2x as many entries as sources. */ * we guesstimate a little over 2x as many entries as sources. */
incl = set_init(2*argc); incl = set_init(2 * argc);
deps = map_init(2*argc); deps = map_init(2 * argc);
/* list of include search paths. prefixed by "." and "..". */ /* list of include search paths. prefixed by "." and "..". */
paths = llist_init(); paths = llist_init();
llist_append(paths,"."); llist_append(paths, ".");
llist_append(paths,".."); llist_append(paths, "..");
while (++argv, --argc > 0) { while (++argv, --argc > 0) {
if (strncmp(*argv, "-I", 2) == 0) { if (strncmp(*argv, "-I", 2) == 0) {
if ((*argv)[2] != '\0') { if ((*argv)[2] != '\0') {
llist_append(paths,trim_path(*argv+2)); llist_append(paths, trim_path(*argv + 2));
} else { } else {
++argv; ++argv;
--argc; --argc;
if (argc > 0) { if (argc > 0) {
if (strcmp(*argv,"--") == 0) { if (strcmp(*argv, "--") == 0) {
break; break;
} else { } else {
llist_append(paths,trim_path(*argv)); llist_append(paths, trim_path(*argv));
} }
} }
} }
} else if (strcmp(*argv,"--") == 0) { } else if (strcmp(*argv, "--") == 0) {
break; break;
} /* ignore all unrecognized arguments before '--'. */ } /* ignore all unrecognized arguments before '--'. */
} }
src = llist_init(); src = llist_init();
while (++argv, --argc > 0) { while (++argv, --argc > 0) { llist_append(src, *argv); }
llist_append(src,*argv);
}
/* process files to look for includes */ /* process files to look for includes */
todo = llist_init(); todo = llist_init();
find_includes(src->head,todo,paths,incl,deps); find_includes(src->head, todo, paths, incl, deps);
find_includes(todo->head,todo,paths,incl,deps); find_includes(todo->head, todo, paths, incl, deps);
llist_free(todo); llist_free(todo);
fprintf(stdout,"# FastDep v%s for LAMMPS\n",version); fprintf(stdout, "# FastDep v%s for LAMMPS\n", version);
fputs("# Search path: ",stdout); fputs("# Search path: ", stdout);
llist_print(paths); llist_print(paths);
fprintf(stdout,"# % 5d sources\n# % 5d includes\n# % 5d depfiles\n", fprintf(stdout, "# % 5d sources\n# % 5d includes\n# % 5d depfiles\n",
llist_size(src),set_size(incl),map_size(deps)); llist_size(src), set_size(incl), map_size(deps));
set_free(incl); set_free(incl);
do_depend(src->head,deps); do_depend(src->head, deps);
llist_free(src); llist_free(src);
llist_free(paths); llist_free(paths);