| 1 |
#!/usr/bin/env python3 |
| 2 |
|
| 3 |
import sys, os, json, argparse, datetime, io, subprocess |
| 4 |
from shutil import copyfile |
| 5 |
|
| 6 |
CHECKS_FILENAME = 'checks.json' |
| 7 |
_checks = [] |
| 8 |
_specified_check_names = [] |
| 9 |
_available_categories = [] |
| 10 |
|
| 11 |
|
| 12 |
def checkSortKey(check): |
| 13 |
return str(check.level) + check.name |
| 14 |
|
| 15 |
|
| 16 |
def level_num_to_enum(n): |
| 17 |
if n == -1: |
| 18 |
return 'ManualCheckLevel' |
| 19 |
if n >= 0 and n <= 3: |
| 20 |
return 'CheckLevel' + str(n) |
| 21 |
|
| 22 |
return 'CheckLevelUndefined' |
| 23 |
|
| 24 |
|
| 25 |
def level_num_to_name(n): |
| 26 |
if n == -1: |
| 27 |
return 'Manual Level' |
| 28 |
if n >= 0 and n <= 3: |
| 29 |
return 'Level ' + str(n) |
| 30 |
|
| 31 |
return 'undefined' |
| 32 |
|
| 33 |
|
| 34 |
def level_num_to_cmake_readme_variable(n): |
| 35 |
if n == -1: |
| 36 |
return 'README_manuallevel_FILES' |
| 37 |
if n >= 0 and n <= 3: |
| 38 |
return 'README_LEVEL%s_FILES' % str(n) |
| 39 |
|
| 40 |
return 'undefined' |
| 41 |
|
| 42 |
|
| 43 |
def clazy_source_path(): |
| 44 |
return os.path.abspath(os.path.dirname(os.path.realpath(__file__)) + "/..") + "/" |
| 45 |
|
| 46 |
|
| 47 |
def templates_path(): |
| 48 |
return clazy_source_path() + "dev-scripts/templates/" |
| 49 |
|
| 50 |
|
| 51 |
def docs_relative_path(): |
| 52 |
return "docs/checks/" |
| 53 |
|
| 54 |
|
| 55 |
def docs_path(): |
| 56 |
return clazy_source_path() + docs_relative_path() |
| 57 |
|
| 58 |
|
| 59 |
def read_file(filename): |
| 60 |
f = io.open(filename, 'r', newline='\n', encoding='utf8') |
| 61 |
contents = f.read() |
| 62 |
f.close() |
| 63 |
return contents |
| 64 |
|
| 65 |
|
| 66 |
def write_file(filename: str, contents): |
| 67 |
f = io.open(filename, 'w', newline='\n', encoding='utf8') |
| 68 |
f.write(contents) |
| 69 |
f.close() |
| 70 |
if filename.endswith('.h') or filename.endswith('.cpp'): |
| 71 |
subprocess.run(['clang-format', '-i', filename]) |
| 72 |
|
| 73 |
|
| 74 |
def get_copyright(): |
| 75 |
year = datetime.datetime.now().year |
| 76 |
author = os.getenv('GIT_AUTHOR_NAME', 'Author') |
| 77 |
email = os.getenv('GIT_AUTHOR_EMAIL', 'your@email') |
| 78 |
return "Copyright (C) %s %s <%s>" % (year, author, email) |
| 79 |
|
| 80 |
|
| 81 |
class Check: |
| 82 |
def __init__(self): |
| 83 |
self.name = "" |
| 84 |
self.class_name = "" |
| 85 |
self.level = 0 |
| 86 |
self.categories = [] |
| 87 |
self.minimum_qt_version = 40000 # Qt 4.0.0 |
| 88 |
self.fixits = [] |
| 89 |
self.visits_stmts = False |
| 90 |
self.visits_decls = False |
| 91 |
self.preprocessor_callbacks = False |
| 92 |
self.visit_all_typedefs = False |
| 93 |
self.can_ignore_includes = False |
| 94 |
self.ifndef = "" |
| 95 |
|
| 96 |
def include(self): # Returns for example: "returning-void-expression.h" |
| 97 |
oldstyle_headername = (self.name + ".h").replace('-', '') |
| 98 |
if os.path.exists(self.path() + oldstyle_headername): |
| 99 |
return oldstyle_headername |
| 100 |
|
| 101 |
return self.name + '.h' |
| 102 |
|
| 103 |
def qualified_include(self): # Returns for example: "checks/level2/returning-void-expression.h" |
| 104 |
return self.basedir() + self.include() |
| 105 |
|
| 106 |
def qualified_cpp_filename(self): # Returns for example: "checks/level2/returning-void-expression.cpp" |
| 107 |
return self.basedir() + self.cpp_filename() |
| 108 |
|
| 109 |
def cpp_filename(self): # Returns for example: "returning-void-expression.cpp" |
| 110 |
filename = self.include() |
| 111 |
filename = filename.replace(".h", ".cpp") |
| 112 |
return filename |
| 113 |
|
| 114 |
def path(self): |
| 115 |
return clazy_source_path() + self.basedir(True) + "/" |
| 116 |
|
| 117 |
def basedir(self, with_src=False): |
| 118 |
level = 'level' + str(self.level) |
| 119 |
if self.level == -1: |
| 120 |
level = 'manuallevel' |
| 121 |
|
| 122 |
if with_src: |
| 123 |
return "src/checks/" + level + '/' |
| 124 |
return "checks/" + level + '/' |
| 125 |
|
| 126 |
def readme_name(self): |
| 127 |
return "README-" + self.name + ".md" |
| 128 |
|
| 129 |
def readme_path(self): |
| 130 |
return docs_path() + self.readme_name() |
| 131 |
|
| 132 |
def get_class_name(self): |
| 133 |
if self.class_name: |
| 134 |
return self.class_name |
| 135 |
|
| 136 |
# Deduce the class name |
| 137 |
splitted = self.name.split('-') |
| 138 |
classname = "" |
| 139 |
for word in splitted: |
| 140 |
if word == 'qt': |
| 141 |
word = 'Qt' |
| 142 |
else: |
| 143 |
word = word.title() |
| 144 |
if word.startswith('Q'): |
| 145 |
word = 'Q' + word[1:].title() |
| 146 |
|
| 147 |
classname += word |
| 148 |
|
| 149 |
return classname |
| 150 |
|
| 151 |
def valid_name(self): |
| 152 |
if self.name in ['clazy']: |
| 153 |
return False |
| 154 |
if self.name.startswith('level'): |
| 155 |
return False |
| 156 |
if self.name.startswith('fix'): |
| 157 |
return False |
| 158 |
return True |
| 159 |
|
| 160 |
def fixits_text(self): |
| 161 |
if not self.fixits: |
| 162 |
return "" |
| 163 |
|
| 164 |
text = "" |
| 165 |
fixitnames = [] |
| 166 |
for f in self.fixits: |
| 167 |
fixitnames.append("fix-" + f) |
| 168 |
|
| 169 |
text = ','.join(fixitnames) |
| 170 |
|
| 171 |
return "(" + text + ")" |
| 172 |
|
| 173 |
def include_guard(self): |
| 174 |
guard = self.name.replace('-', '_') |
| 175 |
return guard.upper() |
| 176 |
|
| 177 |
|
| 178 |
def load_json(filename): |
| 179 |
jsonContents = read_file(filename) |
| 180 |
decodedJson = json.loads(jsonContents) |
| 181 |
|
| 182 |
if 'checks' not in decodedJson: |
| 183 |
print("No checks found in " + filename) |
| 184 |
return False |
| 185 |
|
| 186 |
checks = decodedJson['checks'] |
| 187 |
|
| 188 |
global _available_categories, _checks, _specified_check_names |
| 189 |
|
| 190 |
if 'available_categories' in decodedJson: |
| 191 |
_available_categories = decodedJson['available_categories'] |
| 192 |
|
| 193 |
for check in checks: |
| 194 |
c = Check() |
| 195 |
try: |
| 196 |
c.name = check['name'] |
| 197 |
c.level = check['level'] |
| 198 |
if 'categories' in check: |
| 199 |
c.categories = check['categories'] |
| 200 |
for cat in c.categories: |
| 201 |
if cat not in _available_categories: |
| 202 |
print('Unknown category ' + cat) |
| 203 |
return False |
| 204 |
except KeyError: |
| 205 |
print("Missing mandatory field while processing " + str(check)) |
| 206 |
return False |
| 207 |
|
| 208 |
if _specified_check_names and c.name not in _specified_check_names: |
| 209 |
continue |
| 210 |
|
| 211 |
if 'class_name' in check: |
| 212 |
c.class_name = check['class_name'] |
| 213 |
|
| 214 |
if 'ifndef' in check: |
| 215 |
c.ifndef = check['ifndef'] |
| 216 |
|
| 217 |
if 'minimum_qt_version' in check: |
| 218 |
c.minimum_qt_version = check['minimum_qt_version'] |
| 219 |
|
| 220 |
if 'visits_stmts' in check: |
| 221 |
c.visits_stmts = check['visits_stmts'] |
| 222 |
|
| 223 |
if 'visits_decls' in check: |
| 224 |
c.visits_decls = check['visits_decls'] |
| 225 |
|
| 226 |
if 'preprocessor_callbacks' in check: |
| 227 |
c.preprocessor_callbacks = check['preprocessor_callbacks'] |
| 228 |
|
| 229 |
if 'visit_all_typedefs' in check: |
| 230 |
c.visit_all_typedefs = check['visit_all_typedefs'] |
| 231 |
|
| 232 |
if 'can_ignore_includes' in check: |
| 233 |
c.can_ignore_includes = check['can_ignore_includes'] |
| 234 |
|
| 235 |
if 'fixits' in check: |
| 236 |
for fixit in check['fixits']: |
| 237 |
if 'name' not in fixit: |
| 238 |
print('fixit doesnt have a name. check=' + str(check)) |
| 239 |
return False |
| 240 |
c.fixits.append(fixit['name']) |
| 241 |
|
| 242 |
if not c.valid_name(): |
| 243 |
print("Invalid check name: %s" % (c.name())) |
| 244 |
return False |
| 245 |
_checks.append(c) |
| 246 |
|
| 247 |
_checks = sorted(_checks, key=checkSortKey) |
| 248 |
return True |
| 249 |
|
| 250 |
|
| 251 |
def print_checks(checks): |
| 252 |
for c in checks: |
| 253 |
print(c.name + " " + str(c.level) + " " + str(c.categories)) |
| 254 |
|
| 255 |
|
| 256 |
def generate_register_checks(checks): |
| 257 |
text = '#include "checkbase.h"\n#include "checkmanager.h"\n' |
| 258 |
for c in checks: |
| 259 |
text += '#include "' + c.qualified_include() + '"\n' |
| 260 |
text += """ |
| 261 |
template<typename T> |
| 262 |
RegisteredCheck check(const char *name, CheckLevel level, RegisteredCheck::Options options, bool canIgnoreIncludes) |
| 263 |
{ |
| 264 |
auto factoryFuntion = [canIgnoreIncludes, name]() { |
| 265 |
return new T(name, canIgnoreIncludes ? CheckBase::Option_CanIgnoreIncludes : CheckBase::Option_None); |
| 266 |
}; |
| 267 |
return RegisteredCheck{name, level, factoryFuntion, options}; |
| 268 |
} |
| 269 |
|
| 270 |
// clang-format off |
| 271 |
void CheckManager::registerChecks() |
| 272 |
{ |
| 273 |
""" |
| 274 |
|
| 275 |
for c in checks: |
| 276 |
qtflags = "RegisteredCheck::Option_None" |
| 277 |
if c.visits_stmts: |
| 278 |
qtflags += " | RegisteredCheck::Option_VisitsStmts" |
| 279 |
if c.visits_decls: |
| 280 |
qtflags += " | RegisteredCheck::Option_VisitsDecls" |
| 281 |
if c.preprocessor_callbacks: |
| 282 |
qtflags += " | RegisteredCheck::Option_PreprocessorCallbacks" |
| 283 |
if c.visit_all_typedefs: |
| 284 |
qtflags += " | RegisteredCheck::Option_VisitAllTypeDefs" |
| 285 |
|
| 286 |
qtflags = qtflags.replace("RegisteredCheck::Option_None | ", "") |
| 287 |
|
| 288 |
if c.ifndef: |
| 289 |
text += "#ifndef " + c.ifndef + "\n" |
| 290 |
|
| 291 |
text += ' registerCheck(check<%s>("%s", %s, %s, %s));\n' % ( |
| 292 |
c.get_class_name(), |
| 293 |
c.name, |
| 294 |
level_num_to_enum(c.level), |
| 295 |
qtflags, |
| 296 |
"true" if c.can_ignore_includes else "false" |
| 297 |
) |
| 298 |
fixitID = 1 |
| 299 |
for fixit in c.fixits: |
| 300 |
text += ' registerFixIt(%d, "%s", "%s");\n' % (fixitID, "fix-" + fixit, c.name) |
| 301 |
fixitID = fixitID * 2 |
| 302 |
|
| 303 |
if c.ifndef: |
| 304 |
text += "#endif" + "\n" |
| 305 |
|
| 306 |
text += "}\n" |
| 307 |
|
| 308 |
comment_text = """ |
| 309 |
/** |
| 310 |
* New scripts should be added to the check.json file and the files should be regenerated |
| 311 |
* ./dev-scripts/generate.py --generate |
| 312 |
* SPDX-License-Identifier: CC0-1.0 |
| 313 |
* SPDX-FileCopyrightText: Clazy Developers |
| 314 |
*/ |
| 315 |
""" |
| 316 |
text = comment_text + '\n' + text |
| 317 |
filename = clazy_source_path() + "src/Checks.h" |
| 318 |
|
| 319 |
old_text = read_file(filename) |
| 320 |
if old_text != text: |
| 321 |
write_file(filename, text) |
| 322 |
print("Generated " + filename) |
| 323 |
return True |
| 324 |
return False |
| 325 |
|
| 326 |
|
| 327 |
def generate_cmake_file(checks): |
| 328 |
text = "# This file was autogenerated by running: ./dev-scripts/generate.py --generate\n# SPDX-License-Identifier: CC0-1.0\n# SPDX-FileCopyrightText: Clazy Developers\n\nset(CLAZY_CHECKS_SRCS ${CLAZY_CHECKS_SRCS}\n" |
| 329 |
for level in [-1, 0, 1, 2, 3]: |
| 330 |
for check in checks: |
| 331 |
if check.level == level: |
| 332 |
text += " ${CMAKE_CURRENT_LIST_DIR}/src/" + check.qualified_cpp_filename() + "\n" |
| 333 |
text += ")\n" |
| 334 |
|
| 335 |
filename = clazy_source_path() + "CheckSources.generated.cmake" |
| 336 |
old_text = read_file(filename) |
| 337 |
if old_text != text: |
| 338 |
write_file(filename, text) |
| 339 |
print("Generated " + filename) |
| 340 |
return True |
| 341 |
return False |
| 342 |
|
| 343 |
|
| 344 |
def create_readmes(checks): |
| 345 |
generated = False |
| 346 |
for check in checks: |
| 347 |
if not os.path.exists(check.readme_path()): |
| 348 |
existing_readme = search_in_all_levels(check.readme_name()) |
| 349 |
if existing_readme: |
| 350 |
contents = read_file(existing_readme) |
| 351 |
write_file(check.readme_path(), contents) |
| 352 |
os.remove(existing_readme) |
| 353 |
print("Moved " + check.readme_name()) |
| 354 |
else: |
| 355 |
contents = read_file(templates_path() + "check-readme.md") |
| 356 |
contents = contents.replace('[check-name]', check.name) |
| 357 |
write_file(check.readme_path(), contents) |
| 358 |
print("Created " + check.readme_path()) |
| 359 |
generated = True |
| 360 |
return generated |
| 361 |
|
| 362 |
|
| 363 |
def create_unittests(checks): |
| 364 |
generated = False |
| 365 |
for check in checks: |
| 366 |
unittest_folder = clazy_source_path() + "tests/" + check.name |
| 367 |
if not os.path.exists(unittest_folder): |
| 368 |
os.mkdir(unittest_folder) |
| 369 |
print("Created " + unittest_folder) |
| 370 |
generated = True |
| 371 |
|
| 372 |
configjson_file = unittest_folder + "/config.json" |
| 373 |
if not os.path.exists(configjson_file): |
| 374 |
copyfile(templates_path() + "test-config.json", configjson_file) |
| 375 |
print("Created " + configjson_file) |
| 376 |
generated = True |
| 377 |
|
| 378 |
testmain_file = unittest_folder + "/main.cpp" |
| 379 |
if not os.path.exists(testmain_file) and check.name != 'non-pod-global-static': |
| 380 |
copyfile(templates_path() + "test-main.cpp", testmain_file) |
| 381 |
print("Created " + testmain_file) |
| 382 |
generated = True |
| 383 |
return generated |
| 384 |
|
| 385 |
|
| 386 |
def search_in_all_levels(filename): |
| 387 |
for level in ['manuallevel', 'level0', 'level1', 'level2']: |
| 388 |
complete_filename = clazy_source_path() + 'src/checks/' + level + '/' + filename |
| 389 |
if os.path.exists(complete_filename): |
| 390 |
return complete_filename |
| 391 |
return "" |
| 392 |
|
| 393 |
|
| 394 |
def create_checks(checks): |
| 395 |
generated = False |
| 396 |
|
| 397 |
for check in checks: |
| 398 |
edit_changelog = False |
| 399 |
include_file = check.path() + check.include() |
| 400 |
cpp_file = check.path() + check.cpp_filename() |
| 401 |
copyright = get_copyright() |
| 402 |
include_missing = not os.path.exists(include_file) |
| 403 |
cpp_missing = not os.path.exists(cpp_file) |
| 404 |
if include_missing: |
| 405 |
|
| 406 |
existing_include_path = search_in_all_levels(check.include()) |
| 407 |
if existing_include_path: |
| 408 |
# File already exists, but is in another level. Just move it: |
| 409 |
contents = read_file(existing_include_path) |
| 410 |
write_file(include_file, contents) |
| 411 |
os.remove(existing_include_path) |
| 412 |
print("Moved " + check.include()) |
| 413 |
else: |
| 414 |
contents = read_file(templates_path() + 'check.h') |
| 415 |
contents = contents.replace('%1', check.include_guard()) |
| 416 |
contents = contents.replace('%2', check.get_class_name()) |
| 417 |
contents = contents.replace('%3', check.name) |
| 418 |
contents = contents.replace('%4', copyright) |
| 419 |
write_file(include_file, contents) |
| 420 |
print("Created " + include_file) |
| 421 |
edit_changelog = True |
| 422 |
generated = True |
| 423 |
if cpp_missing: |
| 424 |
existing_cpp_path = search_in_all_levels(check.cpp_filename()) |
| 425 |
if existing_cpp_path: |
| 426 |
# File already exists, but is in another level. Just move it: |
| 427 |
contents = read_file(existing_cpp_path) |
| 428 |
write_file(cpp_file, contents) |
| 429 |
os.remove(existing_cpp_path) |
| 430 |
print("Moved " + check.cpp_filename()) |
| 431 |
else: |
| 432 |
contents = read_file(templates_path() + 'check.cpp') |
| 433 |
contents = contents.replace('%1', check.include()) |
| 434 |
contents = contents.replace('%2', check.get_class_name()) |
| 435 |
contents = contents.replace('%3', copyright) |
| 436 |
write_file(cpp_file, contents) |
| 437 |
print("Created " + cpp_file) |
| 438 |
generated = True |
| 439 |
|
| 440 |
if edit_changelog: |
| 441 |
# We created a new check, let's also edit the ChangeLog |
| 442 |
changelog_file = clazy_source_path() + 'Changelog' |
| 443 |
contents = read_file(changelog_file) |
| 444 |
contents += '\n - <dont forget changelog entry for ' + check.name + '>\n' |
| 445 |
write_file(changelog_file, contents) |
| 446 |
print('Edited Changelog') |
| 447 |
|
| 448 |
return generated |
| 449 |
|
| 450 |
|
| 451 |
def generate_readme(checks): |
| 452 |
filename = clazy_source_path() + "README.md" |
| 453 |
f = io.open(filename, 'r', newline='\n', encoding='utf8') |
| 454 |
old_contents = f.readlines() |
| 455 |
f.close() |
| 456 |
|
| 457 |
new_text_to_insert = "" |
| 458 |
for level in ['-1', '0', '1', '2']: |
| 459 |
new_text_to_insert += "- Checks from %s:" % level_num_to_name(int(level)) + "\n\n" |
| 460 |
for c in checks: |
| 461 |
if str(c.level) == level: |
| 462 |
fixits_text = c.fixits_text() |
| 463 |
if fixits_text: |
| 464 |
fixits_text = " " + fixits_text |
| 465 |
new_text_to_insert += " - [%s](%sREADME-%s.md)%s" % (c.name, docs_relative_path(), c.name, fixits_text) + "\n" |
| 466 |
new_text_to_insert += "\n" |
| 467 |
|
| 468 |
f = io.open(filename, 'w', newline='\n', encoding='utf8') |
| 469 |
|
| 470 |
skip = False |
| 471 |
for line in old_contents: |
| 472 |
if skip and line.startswith("#"): |
| 473 |
skip = False |
| 474 |
|
| 475 |
if skip: |
| 476 |
continue |
| 477 |
|
| 478 |
if line.startswith("- Checks from Manual Level:"): |
| 479 |
skip = True |
| 480 |
f.write(new_text_to_insert) |
| 481 |
continue |
| 482 |
|
| 483 |
f.write(line) |
| 484 |
f.close() |
| 485 |
|
| 486 |
f = io.open(filename, 'r', newline='\n', encoding='utf8') |
| 487 |
new_contents = f.readlines() |
| 488 |
f.close() |
| 489 |
|
| 490 |
if old_contents != new_contents: |
| 491 |
print("Generated " + filename) |
| 492 |
return True |
| 493 |
return False |
| 494 |
|
| 495 |
|
| 496 |
def generate_ctest(checks): |
| 497 |
# Generates the ClazyTests.cmake file |
| 498 |
filename = clazy_source_path() + 'ClazyTests.generated.cmake' |
| 499 |
|
| 500 |
contents = f""" |
| 501 |
# This file was autogenerated by running: ./dev-scripts/generate.py --generate |
| 502 |
# SPDX-License-Identifier: CC0-1.0 |
| 503 |
# SPDX-FileCopyrightText: Clazy Developers |
| 504 |
{'\n'.join(f"add_clazy_test({c.name})" for c in checks)} |
| 505 |
add_clazy_test(clazy-standalone) |
| 506 |
add_clazy_test(clazy) |
| 507 |
""" |
| 508 |
|
| 509 |
f = io.open(filename, 'w', newline='\n', encoding='utf8') |
| 510 |
f.write(contents) |
| 511 |
f.close() |
| 512 |
return True |
| 513 |
|
| 514 |
|
| 515 |
def generate_readmes_cmake_install(checks): |
| 516 |
old_contents = "" |
| 517 |
filename = clazy_source_path() + 'readmes.cmake' |
| 518 |
if os.path.exists(filename): |
| 519 |
f = io.open(filename, 'r', newline='\n', encoding='utf8') |
| 520 |
old_contents = f.readlines() |
| 521 |
f.close() |
| 522 |
|
| 523 |
new_text_to_insert = "" |
| 524 |
for level in ['-1', '0', '1', '2']: |
| 525 |
new_text_to_insert += 'SET(' + level_num_to_cmake_readme_variable(int(level)) + "\n" |
| 526 |
for c in checks: |
| 527 |
if str(c.level) == level: |
| 528 |
new_text_to_insert += ' ${CMAKE_CURRENT_LIST_DIR}/docs/checks/' + c.readme_name() + '\n' |
| 529 |
new_text_to_insert += ')\n\n' |
| 530 |
|
| 531 |
if old_contents == new_text_to_insert: |
| 532 |
return False |
| 533 |
|
| 534 |
f = io.open(filename, 'w', newline='\n', encoding='utf8') |
| 535 |
f.write(new_text_to_insert) |
| 536 |
f.close() |
| 537 |
return True |
| 538 |
|
| 539 |
|
| 540 |
complete_json_filename = clazy_source_path() + CHECKS_FILENAME |
| 541 |
|
| 542 |
if not os.path.exists(complete_json_filename): |
| 543 |
print("File doesn't exist: " + complete_json_filename) |
| 544 |
exit(1) |
| 545 |
|
| 546 |
parser = argparse.ArgumentParser() |
| 547 |
parser.add_argument("checks", nargs='*', help="Optional check names to build. Useful to speedup builds during development, by building only the specified checks. Default is to build all checks.") |
| 548 |
args = parser.parse_args() |
| 549 |
|
| 550 |
_specified_check_names = args.checks |
| 551 |
|
| 552 |
if not load_json(complete_json_filename): |
| 553 |
exit(1) |
| 554 |
|
| 555 |
generate_register_checks(_checks) |
| 556 |
generate_cmake_file(_checks) |
| 557 |
generate_readme(_checks) |
| 558 |
create_readmes(_checks) |
| 559 |
create_unittests(_checks) |
| 560 |
create_checks(_checks) |
| 561 |
generate_readmes_cmake_install(_checks) |
| 562 |
generate_ctest(_checks) |