Team 2 - Converter; Able to convert hello world build.ninja into build.ninja.cc

.circleci/config.yml

@@ -0,0 +1,39 @@
+# Use the latest 2.1 version of CircleCI pipeline process engine.
+# See: https://circleci.com/docs/configuration-reference
+version: 2.1
+
+# Define a job to be invoked later in a workflow.
+# See: https://circleci.com/docs/jobs-steps/#jobs-overview & https://circleci.com/docs/configuration-reference/#jobs
+jobs:
+  ninja:
+    docker:
+      - image: cimg/base:current
+    steps:
+      - checkout
+      - run:
+          name: Install ctest, clang-tidy and compiler
+          command: |
+            sudo apt-get update
+            sudo apt-get install -y cmake g++ clang-tidy
+      - run:
+          name: Copy clang-tidy config
+          command: |
+            cp .clang-tidy /tmp/.clang-tidy
+      - run:
+          name: Run clang-tidy, build ninja and run ctest
+          command: |
+              mkdir build
+              cd build
+              cmake ..
+              cmake --build .
+              make
+              ctest
+
+
+# Orchestrate jobs using workflows
+# See: https://circleci.com/docs/workflows/ & https://circleci.com/docs/configuration-reference/#workflows
+workflows:
+  build-and-test: # This is the name of the workflow, feel free to change it to better match your workflow.
+    # Inside the workflow, you define the jobs you want to run.
+    jobs:
+      - ninja

CMakeLists.txt

@@ -123,6 +123,9 @@ set(NINJA_PYTHON "python" CACHE STRING "Python interpreter to use for the browse
 
 check_platform_supports_browse_mode(platform_supports_ninja_browse)
 
+# run clang-tidy before source code is built
+set(CMAKE_CXX_CLANG_TIDY "clang-tidy;--config-file=/tmp/.clang-tidy")
+
 # Core source files all build into ninja library.
 add_library(libninja OBJECT
 	src/build_log.cc
@@ -135,6 +138,7 @@ add_library(libninja OBJECT
 	src/deps_log.cc
 	src/disk_interface.cc
 	src/edit_distance.cc
+	src/elide_middle.cc
 	src/eval_env.cc
 	src/graph.cc
 	src/graphviz.cc
@@ -265,6 +269,7 @@ if(BUILD_TESTING)
     src/disk_interface_test.cc
     src/dyndep_parser_test.cc
     src/edit_distance_test.cc
+    src/elide_middle_test.cc
     src/explanations_test.cc
     src/graph_test.cc
     src/json_test.cc
@@ -295,6 +300,7 @@ if(BUILD_TESTING)
     canon_perftest
     clparser_perftest
     depfile_parser_perftest
+    elide_middle_perftest
     hash_collision_bench
     manifest_parser_perftest
   )

README.md

@@ -1,100 +1,19 @@
-# Ninja
-
-Ninja is a small build system with a focus on speed.
-https://ninja-build.org/
-
-See [the manual](https://ninja-build.org/manual.html) or
-`doc/manual.asciidoc` included in the distribution for background
-and more details.
-
-Binaries for Linux, Mac and Windows are available on
-  [GitHub](https://github.com/ninja-build/ninja/releases).
-Run `./ninja -h` for Ninja help.
-
-Installation is not necessary because the only required file is the
-resulting ninja binary. However, to enable features like Bash
-completion and Emacs and Vim editing modes, some files in misc/ must be
-copied to appropriate locations.
-
-If you're interested in making changes to Ninja, read
-[CONTRIBUTING.md](CONTRIBUTING.md) first.
-
-## Building Ninja itself
-
-You can either build Ninja via the custom generator script written in Python or
-via CMake. For more details see
-[the wiki](https://github.com/ninja-build/ninja/wiki).
-
-### Python
-
-```
-./configure.py --bootstrap
+# Shadowdash Converter
+## Build
+```sh
+./build.sh
 ```
+This will create the converter in the `debug-build` directory with debug symbols.
 
-This will generate the `ninja` binary and a `build.ninja` file you can now use
-to build Ninja with itself.
-
-If you have a GoogleTest source directory, you can build the tests
-by passing its path with `--gtest-source-dir=PATH` option, or the
-`GTEST_SOURCE_DIR` environment variable, e.g.:
-
-```
-./configure.py --bootstrap --gtest-source-dir=/path/to/googletest
-./ninja all     # build ninja_test and other auxiliary binaries
-./ninja_test`   # run the unit-test suite.
-```
-
-Use the CMake build below if you want to use a preinstalled binary
-version of the library.
-
-### CMake
-
-```
-cmake -Bbuild-cmake
-cmake --build build-cmake
+## Run
+```sh
+./debug-build/ninja
 ```
+Run the above in a directory where a `build.ninja` file is present
 
-The `ninja` binary will now be inside the `build-cmake` directory (you can
-choose any other name you like).
-
-To run the unit tests:
-
+## Testing
+```sh
+cd converter/testing/
+../../debug-build/ninja
 ```
-./build-cmake/ninja_test
-```
-
-## Generating documentation
-
-### Ninja Manual
-
-You must have `asciidoc` and `xsltproc` in your PATH, then do:
-
-```
-./configure.py
-ninja manual doc/manual.pdf
-```
-
-Which will generate `doc/manual.html`.
-
-To generate the PDF version of the manual, you must have `dblatext` in your PATH then do:
-
-```
-./configure.py    # only if you didn't do it previously.
-ninja doc/manual.pdf
-```
-
-Which will generate `doc/manual.pdf`.
-
-### Doxygen documentation
-
-If you have `doxygen` installed, you can build documentation extracted from C++
-declarations and comments to help you navigate the code. Note that Ninja is a standalone
-executable, not a library, so there is no public API, all details exposed here are
-internal.
-
-```
-./configure.py   # if needed
-ninja doxygen
-```
-
-Then open `doc/doxygen/html/index.html` in a browser to look at it.
+This will run the converter on the hello world example `build.ninja` file and produce `output.cc` as a result.

build.sh

@@ -0,0 +1,2 @@
+cmake -DCMAKE_BUILD_TYPE=Debug -B debug-build
+cmake --build debug-build --parallel --config Debug --target ninja

configure.py

@@ -539,6 +539,7 @@ def has_re2c() -> bool:
              'dyndep',
              'dyndep_parser',
              'edit_distance',
+             'elide_middle',
              'eval_env',
              'graph',
              'graphviz',
@@ -638,6 +639,7 @@ def has_re2c() -> bool:
         'disk_interface_test',
         'dyndep_parser_test',
         'edit_distance_test',
+        'elide_middle_test',
         'explanations_test',
         'graph_test',
         'json_test',
@@ -683,6 +685,7 @@ def has_re2c() -> bool:
 
 for name in ['build_log_perftest',
              'canon_perftest',
+             'elide_middle_perftest',
              'depfile_parser_perftest',
              'hash_collision_bench',
              'manifest_parser_perftest',

converter/archive/convert.py

@@ -0,0 +1,98 @@
+import argparse
+
+def parse_ninja_file(ninja_file_content):
+    rules = {}
+    builds = []
+    current_rule = None
+    default_target = None
+
+    lines = ninja_file_content.splitlines()
+
+    for line in lines:
+        line = line.strip()
+        if line.startswith("rule"):
+            current_rule = line.split()[1]
+            rules[current_rule] = {"command": None, "flags": "-O3"}
+        elif line.startswith("command ="):
+            if current_rule:
+                rules[current_rule]["command"] = line.split("=", 1)[1].strip()
+        elif line.startswith("flags ="):
+            if current_rule:
+                rules[current_rule]["flags"] = line.split("=", 1)[1].strip()
+        elif line.startswith("build"):
+            parts = line.split()
+            output, rule, inputs = parts[1], parts[2], parts[3:]
+            builds.append((output, rule, inputs))
+        elif line.startswith("default"):
+            default_target = line.split()[1]
+
+    return rules, builds, default_target
+
+def generate_manifest_cc(rules, builds, default_target):
+    cc_code = '#include "../manifest.h"\n\nusing namespace shadowdash;\n\nvoid manifest() {\n'
+    cc_code += f'  let(flags, "{rules["compile"]["flags"]}");\n\n'
+
+    for rule, details in rules.items():
+        cc_code += f'  auto {rule} = rule{{ {{\n'
+        command = details["command"].replace("$flags", '"flags"_v').replace("$in", "in").replace("$out", "out")
+        cc_code += f'      bind(command, {command}),  //\n'
+        cc_code += f'  }} }};\n\n'
+
+    for build in builds:
+        output, rule, inputs = build
+        inputs_str = ", ".join([f'str{{ "{inp}" }}' for inp in inputs])
+        if rule == "compile" and "flags" in rules["compile"] and rules["compile"]["flags"] != "-O3":
+            cc_code += f'  build(list{{ str{{ "{output}" }} }},   //\n'
+            cc_code += f'        {{}},                         //\n'
+            cc_code += f'        {rule},                    //\n'
+            cc_code += f'        list{{ {inputs_str} }},  //\n'
+            cc_code += f'        {{}},                         //\n'
+            cc_code += f'        {{}},                         //\n'
+            cc_code += f'        {{ bind(flags, "{rules["compile"]["flags"]}") }}      //\n'
+            cc_code += f'  );\n\n'
+        else:
+            cc_code += f'  build(list{{ str{{ "{output}" }} }},    //\n'
+            cc_code += f'        {{}},                        //\n'
+            cc_code += f'        {rule},                      //\n'
+            cc_code += f'        list{{ {inputs_str} }},  //\n'
+            cc_code += f'        {{}},                        //\n'
+            cc_code += f'        {{}},                        //\n'
+            cc_code += f'        {{}}                         //\n'
+            cc_code += f'  );\n\n'
+
+    cc_code += f'  build(list{{ str{{ "{default_target}" }} }},    //\n'
+    cc_code += f'        {{}},                        //\n'
+    cc_code += f'        link,                      //\n'
+    cc_code += f'        list{{ str{{ "{default_target}.o" }} }},  //\n'
+    cc_code += f'        {{}},                        //\n'
+    cc_code += f'        {{}},                        //\n'
+    cc_code += f'        {{}}                         //\n'
+    cc_code += f'  );\n'
+
+    cc_code += '}\n'
+    return cc_code
+
+def main():
+    # argument parser for input and output file names
+    parser = argparse.ArgumentParser(description="Convert a build.ninja file to a build.ninja.cc file.")
+    parser.add_argument('input_file', help="Path to the input build.ninja file")
+    parser.add_argument('output_file', help="Path to the output build.ninja.cc file")
+
+    args = parser.parse_args()
+
+    # read input file
+    with open(args.input_file, 'r') as f:
+        ninja_file_content = f.read()
+
+    # parse the ninja file
+    rules, builds, default_target = parse_ninja_file(ninja_file_content)
+
+    # generate the manifest.cc content
+    manifest_cc_content = generate_manifest_cc(rules, builds, default_target)
+
+    # write the output to the file
+    with open(args.output_file, 'w') as f:
+        f.write(manifest_cc_content)
+
+if __name__ == "__main__":
+    main()

converter/src/hooks.cpp

@@ -0,0 +1,21 @@
+
+void HandleRule(Rule* rule)
+{
+    // output string
+    std::string output = "auto " + rule.name_ + " = rule{{bind(command, \"g++\", \"flags\"_v, \"-c\", ";
+
+    // Iterate over the parsed_ vector in the "command" binding
+    for (const auto& entry : rule.bindings_["command"].parsed_) {
+        if (entry.second == RAW) {
+            output += "\"" + entry.first + "\", ";  // Add quotes for raw strings
+        } else if (entry.second == SPECIAL) {
+            output += entry.first + ", ";  // No quotes for special variables
+        }
+    }
+
+    // Finish the string
+    output += ")}};";
+
+    // Print the result
+    std::cout << output << std::endl;
+}

converter/src/main.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <string>
+#include <map>
+#include <vector>
+
+// Assuming you have these constants
+enum EvalStringType { RAW, SPECIAL };
+
+// Example structures based on your description
+struct EvalString {
+    std::string first;
+    EvalStringType second;
+};
+
+struct Binding {
+    std::vector<EvalString> parsed_;
+};
+
+struct Rule {
+    std::string name_;
+    std::map<std::string, Binding> bindings_;
+};
+
+int main() {
+    // Simulate your object
+    Rule rule;
+    rule.name_ = "compile";
+    rule.bindings_["command"].parsed_ = {
+        {"g++ -c ", RAW},
+        {"in", SPECIAL},
+        {" -o ", RAW},
+        {"out", SPECIAL},
+        {" ", RAW}
+    };
+
+    // Begin the output string
+    std::string output = "auto " + rule.name_ + " = rule{{bind(command, \"g++\", \"flags\"_v, \"-c\", ";
+
+    // Iterate over the parsed_ vector in the "command" binding
+    for (const auto& entry : rule.bindings_["command"].parsed_) {
+        if (entry.second == RAW) {
+            output += "\"" + entry.first + "\", ";  // Add quotes for raw strings
+        } else if (entry.second == SPECIAL) {
+            output += entry.first + ", ";  // No quotes for special variables
+        }
+    }
+
+    // Finish the string
+    output += ")}};";
+
+    // Print the result
+    std::cout << output << std::endl;
+
+    return 0;
+}