| import os | |
| import sys | |
| from pathlib import Path | |
| from scripts.generated_note import generated_note | |
| # Shared license body, copied next to this file by BUILD.bazel — see scripts/license_header.txt. | |
| _LICENSE_NOTICE = (Path(__file__).parent / "license_header.txt").read_text(encoding="utf-8").rstrip("\n") | |
| _LICENSE_BLOCK = "/*\n" + "\n".join(f" * {line}".rstrip() for line in _LICENSE_NOTICE.split("\n")) + "\n */" | |
| _copyright = f"""{_LICENSE_BLOCK} | |
| """ | |
| # One C-style block comment serves every output language (C++ and Java both accept it). | |
| def generated_note_block(label): | |
| raw = generated_note("", "javascript/private/gen_file.py", f"bazel build {label}") | |
| return "/*\n" + "\n".join(f" * {line}" for line in raw.split("\n")) + "\n */" | |
| def get_atom_name(name): | |
| # We had a todo here to convert camelCase and snake_case to BIG_SNAKE_CASE, but this code | |
| # will be removed when BiDi is the default, so we're not going to bother with that. | |
| name = os.path.basename(name) | |
| return name.upper() | |
| def write_atom_literal(out, name, contents, lang, utf8): | |
| # Escape the contents of the file so it can be stored as a literal. | |
| contents = contents.replace("\\", "\\\\") | |
| contents = contents.replace("\f", "\\f") | |
| contents = contents.replace("\n", "\\n") | |
| contents = contents.replace("\r", "\\r") | |
| contents = contents.replace("\t", "\\t") | |
| contents = contents.replace('"', '\\"') | |
| if "cc" == lang or "hh" == lang: | |
| if utf8: | |
| line_format = ' "{}",\n' | |
| else: | |
| line_format = ' L"{}",\n' | |
| elif "java" == lang: | |
| line_format = ' .append("{}")\n' | |
| else: | |
| raise RuntimeError(f"Unknown language: {lang} ") | |
| name = get_atom_name(name) | |
| if "cc" == lang or "hh" == lang: | |
| char_type = "char" if utf8 else "wchar_t" | |
| out.write(f"const {char_type}* const {name}[] = {{\n") | |
| elif "java" == lang: | |
| out.write(f" {name}(new StringBuilder()\n") | |
| else: | |
| raise RuntimeError(f"Unknown language: {lang} ") | |
| # Make the header file play nicely in a terminal: limit lines to 80 | |
| # characters, but make sure we don't cut off a line in the middle | |
| # of an escape sequence. | |
| while len(contents) > 70: | |
| diff = 70 | |
| while contents[diff - 1] == "\\": | |
| diff = diff - 1 | |
| line = contents[0:diff] | |
| contents = contents[diff:] | |
| out.write(line_format.format(line)) | |
| if len(contents) > 0: | |
| out.write(line_format.format(contents)) | |
| if "cc" == lang or "hh" == lang: | |
| out.write(" NULL\n};\n\n") | |
| elif "java" == lang: | |
| out.write(" .toString()),\n") | |
| def generate_header(file_name, out, js_map, just_declare, utf8, note): | |
| define_guard = "WEBDRIVER_{}".format(os.path.basename(file_name.upper()).replace(".", "_")) | |
| include_stddef = "" if utf8 else "\n#include <stddef.h> // For wchar_t." | |
| out.write( | |
| f"""{_copyright} | |
| {note} | |
| #ifndef {define_guard} | |
| #define {define_guard} | |
| {include_stddef} | |
| #include <string> // For std::(w)string. | |
| namespace webdriver {{ | |
| namespace atoms {{ | |
| """ | |
| ) | |
| string_type = "std::string" if utf8 else "std::wstring" | |
| char_type = "char" if utf8 else "wchar_t" | |
| for name, file in js_map.items(): | |
| if just_declare: | |
| out.write(f"extern const {char_type}* const {name.upper()}[];\n") | |
| else: | |
| contents = open(file).read() | |
| write_atom_literal(out, name, contents, "hh", utf8) | |
| out.write( | |
| f""" | |
| static inline {string_type} asString(const {char_type}* const atom[]) {{ | |
| {string_type} source; | |
| for (int i = 0; atom[i] != NULL; i++) {{ | |
| source += atom[i]; | |
| }} | |
| return source; | |
| }} | |
| }} // namespace atoms | |
| }} // namespace webdriver | |
| #endif // {define_guard} | |
| """ | |
| ) | |
| def generate_cc_source(out, js_map, utf8, note): | |
| out.write( | |
| f"""{_copyright} | |
| {note} | |
| #include <stddef.h> // For NULL. | |
| #include "atoms.h" | |
| namespace webdriver {{ | |
| namespace atoms {{ | |
| """ | |
| ) | |
| for name, file in js_map.items(): | |
| contents = open(file).read() | |
| write_atom_literal(out, name, contents, "cc", utf8) | |
| out.write(""" | |
| } // namespace atoms | |
| } // namespace webdriver | |
| """) | |
| def generate_java_source(file_name, out, preamble, js_map, note): | |
| if not file_name.endswith(".java"): | |
| raise RuntimeError("File name must end in .java") | |
| class_name = os.path.basename(file_name[:-5]) | |
| out.write(_copyright) | |
| out.write("\n") | |
| out.write(note) | |
| out.write("\n\n") | |
| out.write(preamble) | |
| out.write("") | |
| out.write( | |
| f""" | |
| public enum {class_name} {{ | |
| """ | |
| ) | |
| for name, file in js_map.items(): | |
| contents = open(file).read() | |
| write_atom_literal(out, name, contents, "java", True) | |
| out.write( | |
| f""" | |
| ; | |
| private final String value; | |
| public String getValue() {{ | |
| return value; | |
| }} | |
| public String toString() {{ | |
| return getValue(); | |
| }} | |
| {class_name}(String value) {{ | |
| this.value = value; | |
| }} | |
| }} | |
| """ | |
| ) | |
| def main(argv): | |
| lang = argv[1] | |
| file_name = argv[2] | |
| preamble = argv[3] | |
| utf8 = argv[4] == "true" | |
| note = generated_note_block(argv[5]) | |
| js_map = {} | |
| for i in range(6, len(argv), 2): | |
| js_map[argv[i]] = argv[i + 1] | |
| with open(file_name, "w") as out: | |
| if "cc" == lang: | |
| generate_cc_source(out, js_map, utf8, note) | |
| elif "hdecl" == lang: | |
| generate_header(file_name, out, js_map, True, utf8, note) | |
| elif "hh" == lang: | |
| generate_header(file_name, out, js_map, False, utf8, note) | |
| elif "java" == lang: | |
| generate_java_source(file_name, out, preamble, js_map, note) | |
| else: | |
| raise RuntimeError(f"Unknown lang: {lang}") | |
| if __name__ == "__main__": | |
| main(sys.argv) |