From 1b7a0ee0ee67f6919aff4c58d49720e7a318df05 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Tue, 8 Jun 2021 02:43:30 -0700 Subject: [PATCH] Add a rough outline of a command line driver. (#548) This is actually code that I wrote a long time ago but didn't get added to the repository, trying to tidy that up. This is the last code. Nothing much interesting here, just a skeleton of a CLI. But seemed better to add it than to not. --- driver/BUILD | 63 +++++ driver/carbon_test.carbon | 24 ++ driver/driver.cpp | 141 ++++++++++ driver/driver.h | 70 +++++ driver/driver_fuzzer.cpp | 82 ++++++ driver/driver_main.cpp | 21 ++ driver/driver_test.cpp | 245 ++++++++++++++++++ driver/flags.def | 19 ++ .../019dd4030b151d2c67da557bf3d56d96dc7839c1 | Bin 0 -> 21 bytes .../02c83534aab9233198863881aa7d82dde0a5b980 | Bin 0 -> 280 bytes .../059a104f98f5658171c48a4d6b0d39036f953264 | Bin 0 -> 1024 bytes .../0ab2969c765b7dfd5a132f93c87d60f700089d26 | Bin 0 -> 4 bytes .../11780e1967cb34483305ee0ce43df22b498db8de | Bin 0 -> 36 bytes .../140803cdfca738e7d23521f13ecf6d87d0bd8980 | Bin 0 -> 488 bytes .../1b65c7f425af22130c7c3aa117961873a194a8ef | Bin 0 -> 26 bytes .../2251142ebdcd99890424c932de502d094925ad98 | Bin 0 -> 4 bytes .../256dbb574b157de6b00c720c6e123de5d3129e56 | Bin 0 -> 8 bytes .../26305a3c41da25872752f99d86ba0cff5c96c15a | Bin 0 -> 136 bytes .../285ad940d4ba382b1ca2698edae0f48a132d3f4c | Bin 0 -> 8 bytes .../2d8c6aebe55a5df4c61804509d3ff1c14978c578 | Bin 0 -> 24 bytes .../2f99d3b7e96de13b21d1b33aa77d5d48fc6e6f88 | Bin 0 -> 72 bytes .../2fd2a7b121a56fdc1e623de01dc1678414adc5dc | Bin 0 -> 4 bytes .../300ba8e152fe095fcd1f88d18bc64d5b100059e6 | Bin 0 -> 12 bytes .../34c0284640cf11c78b5802ecaf21802ebc83df04 | Bin 0 -> 68 bytes .../3519a9e1095165b91c5d4ba9824d32227da30bd6 | Bin 0 -> 12 bytes .../39294db001ba643d5353c8f418f754c6352c8485 | Bin 0 -> 28 bytes .../3c4c33f72a9ff968e60adf7a2db5206d6375b7c5 | Bin 0 -> 24 bytes .../3c585604e87f855973731fea83e21fab9392d2fc | Bin 0 -> 4 bytes .../3da89ee273be13437e7ecf760f3fbd4dc0e8d1fe | Bin 0 -> 8 bytes .../3dbc1b67cab9a71bac41d7ee17fa31a8b32a9904 | 3 + .../4148ee13ed2c74d0f5ce52c46ebd0983c26beb64 | Bin 0 -> 132 bytes .../45f063671e63a4a29f2b05bdd3b6731568119e38 | Bin 0 -> 524 bytes .../4c6f81cf8a9546cd87d1fce006bbe64abd47697b | Bin 0 -> 72 bytes .../4e0f684219dcb4518aaf4166bd2b51c957ef36de | Bin 0 -> 4 bytes .../508abb20ddc995fe9e72b69216fd46c24c966358 | Bin 0 -> 64 bytes .../58607edfe3d6ae988025bc9062e244d4c47f54dc | Bin 0 -> 16 bytes .../58aaf472c4ed651739b9b6debf73437e4eaafb0e | Bin 0 -> 36 bytes .../596cf9d9a653583c4753d4f51b95e679b63f7c71 | Bin 0 -> 24 bytes .../5dab5e799f3875176eeaa35987db34271c1067a0 | Bin 0 -> 4 bytes .../64e1cd6e55c120c9f2fb329773f345ee6406b74a | Bin 0 -> 76 bytes .../67cba3df1acabd24c9b66e3c02b819f25f3fcf57 | Bin 0 -> 60 bytes .../6854bbf33c0126b61050dd5fc0ef0126a9701ff0 | Bin 0 -> 27 bytes .../6b03ca7a6835a17b1077f1b98f43c63efd3cac13 | Bin 0 -> 68 bytes .../6ba597db92a7d33adb74499c15e5034ee57cd41b | Bin 0 -> 32 bytes .../6cd45830db903347e26c3e114ba494052a4a42bd | Bin 0 -> 516 bytes .../6f3f7dcc0a69d64ed2d99bcee0c0fbb81f970fc6 | Bin 0 -> 28 bytes .../74a21fca37339bc7223b8963473dff771ae964f5 | Bin 0 -> 64 bytes .../78d5bd054d5f82b116ac00b834314d4e24f6c21b | Bin 0 -> 508 bytes .../79119613c827b0d5bea100613dcd8aa8765c31f6 | Bin 0 -> 40 bytes .../798bd7bd8e4d8d1835ffe6f02fbeb6319f4f106e | Bin 0 -> 56 bytes .../7bc4f9278deaa7046a5f512c89eac67ebf3ba0d3 | Bin 0 -> 40 bytes .../86179d08482c27dab51fe8a8ea5d8324ef2461e9 | Bin 0 -> 9 bytes .../8b0653417087d3d7fd049166a72cd7bcbc5f6dd1 | 3 + .../8cabec887fe80b7d9f8b28e989db65a6d72dd22b | Bin 0 -> 132 bytes .../8eda19d8bfbc4dbd6070bf626cd2f33160ff88a0 | Bin 0 -> 156 bytes .../9069ca78e7450a285173431b3e52c5c25299e473 | Bin 0 -> 4 bytes .../922b5a97efaa1a3ecba58234ad8d01f41d36d313 | Bin 0 -> 1004 bytes .../9d47be29ac84966acf09290f8a7df5ba0ac4ea4e | Bin 0 -> 16 bytes .../a2ae2a7db83b33dc95396607258f553114c9183c | Bin 0 -> 12 bytes .../a454ca483b4a66b83826d061be2859dd79ff0d6c | Bin 0 -> 4 bytes .../a5bbebbdf11c537a22a3a9dab4b83498ceb441ca | Bin 0 -> 8 bytes .../a69f09257d9cd8f5edd9a87b728ab3d75d4352c4 | Bin 0 -> 4 bytes .../a8502f9cfc7efd4ddb3cb771ae00364f60bc279f | Bin 0 -> 39 bytes .../adc83b19e793491b1c6ea0fd8b46cd9f32e592fc | 1 + .../aecfd3909eadc5707dd46249f6239cad4a2d8618 | Bin 0 -> 4 bytes .../af0fb9fda0e123b97ba7be099545a02b8c21a058 | Bin 0 -> 32 bytes .../af1ec8ae5cda07dc979bd68e45d67ffe0d7ffed6 | Bin 0 -> 1012 bytes .../b36251f56081e4735b65b1c9d3d765f25ce67a66 | Bin 0 -> 17 bytes .../b62c8e9630f2bb2106ce5717ecf7f10c1b89b958 | Bin 0 -> 48 bytes .../b74fd0148ec8333ad7ce831dd7caa6bc4eff73a9 | Bin 0 -> 76 bytes .../b82f012f0ede708c493207a1eeee577e3c0f884c | Bin 0 -> 668 bytes .../bb709bdd1d83c039d5c2f02313009030a4f73e0f | Bin 0 -> 44 bytes .../bc75eaba7c2f73ce991969295463f6af70bfbf1a | Bin 0 -> 120 bytes .../be0ef7b40ed46b91af0482ce0eb7ad38042b5659 | Bin 0 -> 328 bytes .../beacd06c224890fcf6d9b09b771e1248e241ab4b | Bin 0 -> 136 bytes .../c349a8a58eb9c57bf1c97e5af483db5144482772 | Bin 0 -> 48 bytes .../c673fa568bbd98569d347b44306c46b50cc2e53f | Bin 0 -> 20 bytes .../c949526372921c8c5a75ed9e1b198f44fb7a96a1 | Bin 0 -> 4 bytes .../cf294d20a4419644a7716bc1e1783a770c5e2e33 | Bin 0 -> 12 bytes .../cfa74701753e8c5eda1d7364b63b26b667c71bb2 | Bin 0 -> 104 bytes .../d25a8e16325922f85262deec08e77c04acf69f8e | Bin 0 -> 24 bytes .../d5ebc4110136110c161d48f2d8e53cd1b4edfc0d | Bin 0 -> 16 bytes .../d97e2e42e26d865d34f68bc92cf8bfe6a40f2eb4 | Bin 0 -> 140 bytes .../e3d8d13265fdbea01751381344b1a7466fb0cdfb | Bin 0 -> 20 bytes .../e4cd6da031338746e34eb86e8a931d3b589e3d50 | Bin 0 -> 60 bytes .../e8e9adab43ade785323869812e73201de7abf7ad | Bin 0 -> 68 bytes .../ea21645db01d3810168f14c8dfa601d54d7a52f5 | Bin 0 -> 16 bytes .../ed301991137b18831e72c6a6045fac64e5c010c9 | Bin 0 -> 1028 bytes .../efa312d99ad0a086577dfb243164f522aa921b86 | Bin 0 -> 20 bytes .../f488a972b82d572833fccb4600a74d8d4a33ff84 | Bin 0 -> 23 bytes .../f4d6728f4d7cb31739d3ed633a564e4f0015d7cf | Bin 0 -> 8 bytes .../fb80d614f998904a2fcee5f4ac25ce3e71787364 | Bin 0 -> 28 bytes .../fbd4c32be3552f308d7b77155fe35dab861cf45c | Bin 0 -> 19 bytes .../fd354923ab6a356b717147ef68e51581e81ec8c8 | Bin 0 -> 4 bytes .../fe0ff78dd1420db832b271cc868019e9945f5f79 | Bin 0 -> 248 bytes 95 files changed, 672 insertions(+) create mode 100644 driver/BUILD create mode 100644 driver/carbon_test.carbon create mode 100644 driver/driver.cpp create mode 100644 driver/driver.h create mode 100644 driver/driver_fuzzer.cpp create mode 100644 driver/driver_main.cpp create mode 100644 driver/driver_test.cpp create mode 100644 driver/flags.def create mode 100644 driver/fuzzer_corpus/019dd4030b151d2c67da557bf3d56d96dc7839c1 create mode 100644 driver/fuzzer_corpus/02c83534aab9233198863881aa7d82dde0a5b980 create mode 100644 driver/fuzzer_corpus/059a104f98f5658171c48a4d6b0d39036f953264 create mode 100644 driver/fuzzer_corpus/0ab2969c765b7dfd5a132f93c87d60f700089d26 create mode 100644 driver/fuzzer_corpus/11780e1967cb34483305ee0ce43df22b498db8de create mode 100644 driver/fuzzer_corpus/140803cdfca738e7d23521f13ecf6d87d0bd8980 create mode 100644 driver/fuzzer_corpus/1b65c7f425af22130c7c3aa117961873a194a8ef create mode 100644 driver/fuzzer_corpus/2251142ebdcd99890424c932de502d094925ad98 create mode 100644 driver/fuzzer_corpus/256dbb574b157de6b00c720c6e123de5d3129e56 create mode 100644 driver/fuzzer_corpus/26305a3c41da25872752f99d86ba0cff5c96c15a create mode 100644 driver/fuzzer_corpus/285ad940d4ba382b1ca2698edae0f48a132d3f4c create mode 100644 driver/fuzzer_corpus/2d8c6aebe55a5df4c61804509d3ff1c14978c578 create mode 100644 driver/fuzzer_corpus/2f99d3b7e96de13b21d1b33aa77d5d48fc6e6f88 create mode 100644 driver/fuzzer_corpus/2fd2a7b121a56fdc1e623de01dc1678414adc5dc create mode 100644 driver/fuzzer_corpus/300ba8e152fe095fcd1f88d18bc64d5b100059e6 create mode 100644 driver/fuzzer_corpus/34c0284640cf11c78b5802ecaf21802ebc83df04 create mode 100644 driver/fuzzer_corpus/3519a9e1095165b91c5d4ba9824d32227da30bd6 create mode 100644 driver/fuzzer_corpus/39294db001ba643d5353c8f418f754c6352c8485 create mode 100644 driver/fuzzer_corpus/3c4c33f72a9ff968e60adf7a2db5206d6375b7c5 create mode 100644 driver/fuzzer_corpus/3c585604e87f855973731fea83e21fab9392d2fc create mode 100644 driver/fuzzer_corpus/3da89ee273be13437e7ecf760f3fbd4dc0e8d1fe create mode 100644 driver/fuzzer_corpus/3dbc1b67cab9a71bac41d7ee17fa31a8b32a9904 create mode 100644 driver/fuzzer_corpus/4148ee13ed2c74d0f5ce52c46ebd0983c26beb64 create mode 100644 driver/fuzzer_corpus/45f063671e63a4a29f2b05bdd3b6731568119e38 create mode 100644 driver/fuzzer_corpus/4c6f81cf8a9546cd87d1fce006bbe64abd47697b create mode 100644 driver/fuzzer_corpus/4e0f684219dcb4518aaf4166bd2b51c957ef36de create mode 100644 driver/fuzzer_corpus/508abb20ddc995fe9e72b69216fd46c24c966358 create mode 100644 driver/fuzzer_corpus/58607edfe3d6ae988025bc9062e244d4c47f54dc create mode 100644 driver/fuzzer_corpus/58aaf472c4ed651739b9b6debf73437e4eaafb0e create mode 100644 driver/fuzzer_corpus/596cf9d9a653583c4753d4f51b95e679b63f7c71 create mode 100644 driver/fuzzer_corpus/5dab5e799f3875176eeaa35987db34271c1067a0 create mode 100644 driver/fuzzer_corpus/64e1cd6e55c120c9f2fb329773f345ee6406b74a create mode 100644 driver/fuzzer_corpus/67cba3df1acabd24c9b66e3c02b819f25f3fcf57 create mode 100644 driver/fuzzer_corpus/6854bbf33c0126b61050dd5fc0ef0126a9701ff0 create mode 100644 driver/fuzzer_corpus/6b03ca7a6835a17b1077f1b98f43c63efd3cac13 create mode 100644 driver/fuzzer_corpus/6ba597db92a7d33adb74499c15e5034ee57cd41b create mode 100644 driver/fuzzer_corpus/6cd45830db903347e26c3e114ba494052a4a42bd create mode 100644 driver/fuzzer_corpus/6f3f7dcc0a69d64ed2d99bcee0c0fbb81f970fc6 create mode 100644 driver/fuzzer_corpus/74a21fca37339bc7223b8963473dff771ae964f5 create mode 100644 driver/fuzzer_corpus/78d5bd054d5f82b116ac00b834314d4e24f6c21b create mode 100644 driver/fuzzer_corpus/79119613c827b0d5bea100613dcd8aa8765c31f6 create mode 100644 driver/fuzzer_corpus/798bd7bd8e4d8d1835ffe6f02fbeb6319f4f106e create mode 100644 driver/fuzzer_corpus/7bc4f9278deaa7046a5f512c89eac67ebf3ba0d3 create mode 100644 driver/fuzzer_corpus/86179d08482c27dab51fe8a8ea5d8324ef2461e9 create mode 100644 driver/fuzzer_corpus/8b0653417087d3d7fd049166a72cd7bcbc5f6dd1 create mode 100644 driver/fuzzer_corpus/8cabec887fe80b7d9f8b28e989db65a6d72dd22b create mode 100644 driver/fuzzer_corpus/8eda19d8bfbc4dbd6070bf626cd2f33160ff88a0 create mode 100644 driver/fuzzer_corpus/9069ca78e7450a285173431b3e52c5c25299e473 create mode 100644 driver/fuzzer_corpus/922b5a97efaa1a3ecba58234ad8d01f41d36d313 create mode 100644 driver/fuzzer_corpus/9d47be29ac84966acf09290f8a7df5ba0ac4ea4e create mode 100644 driver/fuzzer_corpus/a2ae2a7db83b33dc95396607258f553114c9183c create mode 100644 driver/fuzzer_corpus/a454ca483b4a66b83826d061be2859dd79ff0d6c create mode 100644 driver/fuzzer_corpus/a5bbebbdf11c537a22a3a9dab4b83498ceb441ca create mode 100644 driver/fuzzer_corpus/a69f09257d9cd8f5edd9a87b728ab3d75d4352c4 create mode 100644 driver/fuzzer_corpus/a8502f9cfc7efd4ddb3cb771ae00364f60bc279f create mode 100644 driver/fuzzer_corpus/adc83b19e793491b1c6ea0fd8b46cd9f32e592fc create mode 100644 driver/fuzzer_corpus/aecfd3909eadc5707dd46249f6239cad4a2d8618 create mode 100644 driver/fuzzer_corpus/af0fb9fda0e123b97ba7be099545a02b8c21a058 create mode 100644 driver/fuzzer_corpus/af1ec8ae5cda07dc979bd68e45d67ffe0d7ffed6 create mode 100644 driver/fuzzer_corpus/b36251f56081e4735b65b1c9d3d765f25ce67a66 create mode 100644 driver/fuzzer_corpus/b62c8e9630f2bb2106ce5717ecf7f10c1b89b958 create mode 100644 driver/fuzzer_corpus/b74fd0148ec8333ad7ce831dd7caa6bc4eff73a9 create mode 100644 driver/fuzzer_corpus/b82f012f0ede708c493207a1eeee577e3c0f884c create mode 100644 driver/fuzzer_corpus/bb709bdd1d83c039d5c2f02313009030a4f73e0f create mode 100644 driver/fuzzer_corpus/bc75eaba7c2f73ce991969295463f6af70bfbf1a create mode 100644 driver/fuzzer_corpus/be0ef7b40ed46b91af0482ce0eb7ad38042b5659 create mode 100644 driver/fuzzer_corpus/beacd06c224890fcf6d9b09b771e1248e241ab4b create mode 100644 driver/fuzzer_corpus/c349a8a58eb9c57bf1c97e5af483db5144482772 create mode 100644 driver/fuzzer_corpus/c673fa568bbd98569d347b44306c46b50cc2e53f create mode 100644 driver/fuzzer_corpus/c949526372921c8c5a75ed9e1b198f44fb7a96a1 create mode 100644 driver/fuzzer_corpus/cf294d20a4419644a7716bc1e1783a770c5e2e33 create mode 100644 driver/fuzzer_corpus/cfa74701753e8c5eda1d7364b63b26b667c71bb2 create mode 100644 driver/fuzzer_corpus/d25a8e16325922f85262deec08e77c04acf69f8e create mode 100644 driver/fuzzer_corpus/d5ebc4110136110c161d48f2d8e53cd1b4edfc0d create mode 100644 driver/fuzzer_corpus/d97e2e42e26d865d34f68bc92cf8bfe6a40f2eb4 create mode 100644 driver/fuzzer_corpus/e3d8d13265fdbea01751381344b1a7466fb0cdfb create mode 100644 driver/fuzzer_corpus/e4cd6da031338746e34eb86e8a931d3b589e3d50 create mode 100644 driver/fuzzer_corpus/e8e9adab43ade785323869812e73201de7abf7ad create mode 100644 driver/fuzzer_corpus/ea21645db01d3810168f14c8dfa601d54d7a52f5 create mode 100644 driver/fuzzer_corpus/ed301991137b18831e72c6a6045fac64e5c010c9 create mode 100644 driver/fuzzer_corpus/efa312d99ad0a086577dfb243164f522aa921b86 create mode 100644 driver/fuzzer_corpus/f488a972b82d572833fccb4600a74d8d4a33ff84 create mode 100644 driver/fuzzer_corpus/f4d6728f4d7cb31739d3ed633a564e4f0015d7cf create mode 100644 driver/fuzzer_corpus/fb80d614f998904a2fcee5f4ac25ce3e71787364 create mode 100644 driver/fuzzer_corpus/fbd4c32be3552f308d7b77155fe35dab861cf45c create mode 100644 driver/fuzzer_corpus/fd354923ab6a356b717147ef68e51581e81ec8c8 create mode 100644 driver/fuzzer_corpus/fe0ff78dd1420db832b271cc868019e9945f5f79 diff --git a/driver/BUILD b/driver/BUILD new file mode 100644 index 0000000000000..0bd2a5fd0d22d --- /dev/null +++ b/driver/BUILD @@ -0,0 +1,63 @@ +# Part of the Carbon Language project, under the Apache License v2.0 with LLVM +# Exceptions. See /LICENSE for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library", "cc_test") +load("//bazel/fuzzing:rules.bzl", "cc_fuzz_test") + +package(default_visibility = ["//visibility:public"]) + +cc_library( + name = "driver", + srcs = ["driver.cpp"], + hdrs = ["driver.h"], + textual_hdrs = ["flags.def"], + deps = [ + "//diagnostics:diagnostic_emitter", + "//lexer:tokenized_buffer", + "//source:source_buffer", + "@llvm-project//llvm:Support", + ], +) + +cc_test( + name = "driver_test", + srcs = ["driver_test.cpp"], + deps = [ + ":driver", + "//lexer:tokenized_buffer_test_helpers", + "@llvm-project//llvm:Support", + "@llvm-project//llvm:gmock", + "@llvm-project//llvm:gtest", + "@llvm-project//llvm:gtest_main", + ], +) + +cc_fuzz_test( + name = "driver_fuzzer", + srcs = ["driver_fuzzer.cpp"], + corpus = glob(["fuzzer_corpus/*"]), + deps = [ + ":driver", + "@llvm-project//llvm:Support", + ], +) + +cc_binary( + name = "carbon", + srcs = ["driver_main.cpp"], + deps = [ + ":driver", + "@llvm-project//llvm:Support", + ], +) + +# FIXME: No support for LLVM's lit-style command line & FileCheck tests. +# +#lit_test( +# name = "carbon_test.carbon", +# data = [ +# ":carbon", +# "@llvm-project//llvm:FileCheck", +# ], +#) diff --git a/driver/carbon_test.carbon b/driver/carbon_test.carbon new file mode 100644 index 0000000000000..893a07800cd5f --- /dev/null +++ b/driver/carbon_test.carbon @@ -0,0 +1,24 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// FIXME: We need to figure out how to integrate this style of integration +// testing with Bazel. +// +// RUN: driver/carbon dump-tokens %s | FileCheck %s --check-prefix=TOKENS + +fn run(String program) { + return True; +} + +// TOKENS: token: { index: 0, kind: 'FnKeyword', line: 4, column: 1, indent: 1, spelling: 'fn' } +// TOKENS: token: { index: 1, kind: 'Identifier', line: 4, column: 4, indent: 1, spelling: 'run', identifier: 0 } +// TOKENS: token: { index: 2, kind: 'OpenParen', line: 4, column: 7, indent: 1, spelling: '(', closing_token: 5 } +// TOKENS: token: { index: 3, kind: 'Identifier', line: 4, column: 8, indent: 1, spelling: 'String', identifier: 1 } +// TOKENS: token: { index: 4, kind: 'Identifier', line: 4, column: 15, indent: 1, spelling: 'program', identifier: 2 } +// TOKENS: token: { index: 5, kind: 'CloseParen', line: 4, column: 22, indent: 1, spelling: ')', opening_token: 2 } +// TOKENS: token: { index: 6, kind: 'OpenCurlyBrace', line: 4, column: 24, indent: 1, spelling: '{', closing_token: 10 } +// TOKENS: token: { index: 7, kind: 'ReturnKeyword', line: 5, column: 3, indent: 3, spelling: 'return' } +// TOKENS: token: { index: 8, kind: 'Identifier', line: 5, column: 10, indent: 3, spelling: 'True', identifier: 3 } +// TOKENS: token: { index: 9, kind: 'Semi', line: 5, column: 14, indent: 3, spelling: ';' } +// TOKENS: token: { index: 10, kind: 'CloseCurlyBrace', line: 6, column: 1, indent: 1, spelling: '}', opening_token: 6 } diff --git a/driver/driver.cpp b/driver/driver.cpp new file mode 100644 index 0000000000000..10ae482dac964 --- /dev/null +++ b/driver/driver.cpp @@ -0,0 +1,141 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include "driver/driver.h" + +#include "diagnostics/diagnostic_emitter.h" +#include "lexer/tokenized_buffer.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/StringSwitch.h" +#include "llvm/Support/Error.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/Format.h" +#include "source/source_buffer.h" + +namespace Carbon { + +namespace { + +enum class Subcommand { +#define CARBON_SUBCOMMAND(Name, ...) Name, +#include "driver/flags.def" + Unknown, +}; + +auto GetSubcommand(llvm::StringRef name) -> Subcommand { + return llvm::StringSwitch(name) +#define CARBON_SUBCOMMAND(Name, Spelling, ...) .Case(Spelling, Subcommand::Name) +#include "driver/flags.def" + .Default(Subcommand::Unknown); +} + +} // namespace + +auto Driver::RunFullCommand(llvm::ArrayRef args) -> bool { + if (args.empty()) { + error_stream << "ERROR: No subcommand specified.\n"; + return false; + } + + llvm::StringRef subcommand_text = args[0]; + llvm::SmallVector subcommand_args( + std::next(args.begin()), args.end()); + switch (GetSubcommand(subcommand_text)) { + case Subcommand::Unknown: + error_stream << "ERROR: Unknown subcommand '" << subcommand_text + << "'.\n"; + return false; + +#define CARBON_SUBCOMMAND(Name, ...) \ + case Subcommand::Name: \ + return Run##Name##Subcommand(subcommand_args); +#include "driver/flags.def" + } + llvm_unreachable("All subcommands handled!"); +} + +auto Driver::RunHelpSubcommand(llvm::ArrayRef args) -> bool { + // FIXME: We should support getting detailed help on a subcommand by looking + // for it as a positional parameter here. + if (!args.empty()) { + ReportExtraArgs("help", args); + return false; + } + + output_stream << "List of subcommands:\n\n"; + + constexpr llvm::StringLiteral SubcommandsAndHelp[][2] = { +#define CARBON_SUBCOMMAND(Name, Spelling, HelpText) {Spelling, HelpText}, +#include "driver/flags.def" + }; + + int max_subcommand_width = 0; + for (auto subcommand_and_help : SubcommandsAndHelp) { + max_subcommand_width = std::max( + max_subcommand_width, static_cast(subcommand_and_help[0].size())); + } + + for (auto subcommand_and_help : SubcommandsAndHelp) { + llvm::StringRef subcommand_text = subcommand_and_help[0]; + // FIXME: We should wrap this to the number of columns left after the + // subcommand on the terminal, and using a hanging indent. + llvm::StringRef help_text = subcommand_and_help[1]; + output_stream << " " + << llvm::left_justify(subcommand_text, max_subcommand_width) + << " - " << help_text << "\n"; + } + + output_stream << "\n"; + return true; +} + +auto Driver::RunDumpTokensSubcommand(llvm::ArrayRef args) + -> bool { + if (args.empty()) { + error_stream << "ERROR: No input file specified.\n"; + return false; + } + + llvm::StringRef input_file_name = args.front(); + args = args.drop_front(); + if (!args.empty()) { + ReportExtraArgs("dump-tokens", args); + return false; + } + + auto source = SourceBuffer::CreateFromFile(input_file_name); + if (!source) { + error_stream << "ERROR: Unable to open input source file: "; + llvm::handleAllErrors(source.takeError(), + [&](const llvm::ErrorInfoBase& ei) { + ei.log(error_stream); + error_stream << "\n"; + }); + return false; + } + auto tokenized_source = + TokenizedBuffer::Lex(*source, ConsoleDiagnosticConsumer()); + if (tokenized_source.HasErrors()) { + error_stream << "ERROR: Unable to tokenize source file '" << input_file_name + << "'!\n"; + return false; + } + tokenized_source.Print(output_stream); + return true; +} + +auto Driver::ReportExtraArgs(llvm::StringRef subcommand_text, + llvm::ArrayRef args) -> void { + error_stream << "ERROR: Unexpected additional arguments to the '" + << subcommand_text << "' subcommand:"; + for (auto arg : args) { + error_stream << " " << arg; + } + + error_stream << "\n"; +} + +} // namespace Carbon diff --git a/driver/driver.h b/driver/driver.h new file mode 100644 index 0000000000000..02de42a62637d --- /dev/null +++ b/driver/driver.h @@ -0,0 +1,70 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#ifndef DRIVER_DRIVER_H_ +#define DRIVER_DRIVER_H_ + +#include + +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/raw_ostream.h" + +namespace Carbon { + +// Command line interface driver. +// +// Provides simple API to parse and run command lines for Carbon. It is +// generally expected to be used to implement command line tools for working +// with the language. +class Driver { + public: + // Default constructed driver uses stderr for all error and informational + // output. + Driver() : output_stream(llvm::outs()), error_stream(llvm::errs()) {} + + // Constructs a driver with any error or informational output directed to a + // specified stream. + Driver(llvm::raw_ostream& output_stream, llvm::raw_ostream& error_stream) + : output_stream(output_stream), error_stream(error_stream) {} + + // Parses the given arguments into both a subcommand to select the operation + // to perform and any arguments to that subcommand. + // + // Returns true if the operation succeeds. If the operation fails, returns + // false and any information about the failure is printed to the registered + // error stream (stderr by default). + auto RunFullCommand(llvm::ArrayRef args) -> bool; + + // Subcommand that prints available help text to the error stream. + // + // Optionally one positional parameter may be provided to select a particular + // subcommand or detailed section of help to print. + // + // Returns true if appropriate help text was found and printed. If an invalid + // positional parameter (or flag) is provided, returns false. + auto RunHelpSubcommand(llvm::ArrayRef args) -> bool; + + // Subcommand that dumps the token information for the provided source file. + // + // Requires exactly one positional parameter to designate the source file to + // read. May be `-` to read from stdin. + // + // Returns true if the operation succeeds. If the operation fails, this + // returns false and any information about the failure is printed to the + // registered error stream (stderr by default). + auto RunDumpTokensSubcommand(llvm::ArrayRef args) -> bool; + + private: + auto ReportExtraArgs(llvm::StringRef subcommand_text, + llvm::ArrayRef args) -> void; + + llvm::raw_ostream& output_stream; + llvm::raw_ostream& error_stream; +}; + +} // namespace Carbon + +#endif // DRIVER_DRIVER_H_ diff --git a/driver/driver_fuzzer.cpp b/driver/driver_fuzzer.cpp new file mode 100644 index 0000000000000..443547bbaf15b --- /dev/null +++ b/driver/driver_fuzzer.cpp @@ -0,0 +1,82 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include +#include +#include + +#include "driver/driver.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/raw_ostream.h" + +namespace Carbon { + +static auto Read(const unsigned char*& data, size_t& size, int& output) + -> bool { + if (size < sizeof(output)) { + return false; + } + std::memcpy(&output, data, sizeof(output)); + size -= sizeof(output); + data += sizeof(output); + return true; +} + +extern "C" auto LLVMFuzzerTestOneInput(const unsigned char* data, size_t size) + -> int { + // First use the data to compute the number of arguments. Note that for + // scaling reasons we don't allow 2^31 arguments, even empty ones. Simply + // creating the vector of those won't work. We limit this to 2^20 arguments + // total. + int num_args; + if (!Read(data, size, num_args) || num_args < 0 || num_args > (1 << 20)) { + return 0; + } + + // Now use the data to compute the length of each argument. We don't want to + // exhaust all memory, so bound the search space to using 2^17 bytes of + // memory for the argument text itself. + size_t arg_length_sum = 0; + llvm::SmallVector arg_lengths(num_args); + for (int& arg_length : arg_lengths) { + if (!Read(data, size, arg_length) || arg_length < 0) { + return 0; + } + arg_length_sum += arg_length; + if (arg_length_sum > (1 << 17)) { + return 0; + } + } + + // Ensure we have enough data for all the arguments. + if (size < arg_length_sum) { + return 0; + } + + // Lastly, read the contents of each argument out of the data. + llvm::SmallVector args; + args.reserve(num_args); + for (int arg_length : arg_lengths) { + args.push_back( + llvm::StringRef(reinterpret_cast(data), arg_length)); + data += arg_length; + size -= arg_length; + } + + std::string error_text; + llvm::raw_string_ostream error_stream(error_text); + llvm::raw_null_ostream output_stream; + Driver d(output_stream, error_stream); + if (!d.RunFullCommand(args)) { + error_stream.flush(); + if (error_text.find("ERROR:") == std::string::npos) { + llvm::errs() << "No error message on a failure!\n"; + return 1; + } + } + return 0; +} +} // namespace Carbon diff --git a/driver/driver_main.cpp b/driver/driver_main.cpp new file mode 100644 index 0000000000000..587179ca138fa --- /dev/null +++ b/driver/driver_main.cpp @@ -0,0 +1,21 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include + +#include "driver/driver.h" +#include "llvm/ADT/Sequence.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" + +auto main(int argc, char** argv) -> int { + if (argc < 1) { + return EXIT_FAILURE; + } + + llvm::SmallVector args(argv + 1, argv + argc); + Carbon::Driver driver; + bool success = driver.RunFullCommand(args); + return success ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/driver/driver_test.cpp b/driver/driver_test.cpp new file mode 100644 index 0000000000000..172618d890ea9 --- /dev/null +++ b/driver/driver_test.cpp @@ -0,0 +1,245 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include "driver/driver.h" + +#include "gmock/gmock.h" +#include "gtest/gtest.h" +#include "lexer/tokenized_buffer_test_helpers.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/SourceMgr.h" +#include "llvm/Support/YAMLParser.h" + +namespace Carbon { +namespace { + +using Carbon::Testing::IsKeyValueScalars; +using ::testing::Eq; +using ::testing::HasSubstr; +using ::testing::NotNull; +using ::testing::StrEq; + +/// A raw_ostream that makes it easy to repeatedly check streamed output. +class RawTestOstream : public llvm::raw_ostream { + std::string buffer; + + void write_impl(const char* ptr, size_t size) override { + buffer.append(ptr, ptr + size); + } + + [[nodiscard]] auto current_pos() const -> uint64_t override { + return buffer.size(); + } + + public: + ~RawTestOstream() override { + flush(); + if (!buffer.empty()) { + ADD_FAILURE() << "Unchecked output:\n" << buffer; + } + } + + /// Flushes the stream and returns the contents so far, clearing the stream + /// back to empty. + auto TakeStr() -> std::string { + flush(); + std::string result = std::move(buffer); + buffer.clear(); + return result; + } +}; + +TEST(DriverTest, FullCommandErrors) { + RawTestOstream test_output_stream; + RawTestOstream test_error_stream; + Driver driver = Driver(test_output_stream, test_error_stream); + + EXPECT_FALSE(driver.RunFullCommand({})); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); + + EXPECT_FALSE(driver.RunFullCommand({"foo"})); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); + + EXPECT_FALSE(driver.RunFullCommand({"foo --bar --baz"})); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); +} + +TEST(DriverTest, Help) { + RawTestOstream test_output_stream; + RawTestOstream test_error_stream; + Driver driver = Driver(test_output_stream, test_error_stream); + + EXPECT_TRUE(driver.RunHelpSubcommand({})); + EXPECT_THAT(test_error_stream.TakeStr(), StrEq("")); + auto help_text = test_output_stream.TakeStr(); + + // Help text should mention each subcommand. +#define CARBON_SUBCOMMAND(Name, Spelling, ...) \ + EXPECT_THAT(help_text, HasSubstr(Spelling)); +#include "driver/flags.def" + + // Check that the subcommand dispatch works. + EXPECT_TRUE(driver.RunFullCommand({"help"})); + EXPECT_THAT(test_error_stream.TakeStr(), StrEq("")); + EXPECT_THAT(test_output_stream.TakeStr(), StrEq(help_text)); +} + +TEST(DriverTest, HelpErrors) { + RawTestOstream test_output_stream; + RawTestOstream test_error_stream; + Driver driver = Driver(test_output_stream, test_error_stream); + + EXPECT_FALSE(driver.RunHelpSubcommand({"foo"})); + EXPECT_THAT(test_output_stream.TakeStr(), StrEq("")); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); + + EXPECT_FALSE(driver.RunHelpSubcommand({"help"})); + EXPECT_THAT(test_output_stream.TakeStr(), StrEq("")); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); + + EXPECT_FALSE(driver.RunHelpSubcommand({"--xyz"})); + EXPECT_THAT(test_output_stream.TakeStr(), StrEq("")); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); +} + +auto CreateTestFile(llvm::StringRef text) -> std::string { + int fd = -1; + llvm::SmallString<1024> path; + auto ec = llvm::sys::fs::createTemporaryFile("test_file", ".txt", fd, path); + if (ec) { + llvm::report_fatal_error(llvm::Twine("Failed to create temporary file: ") + + ec.message()); + } + + llvm::raw_fd_ostream s(fd, /*shouldClose=*/true); + s << text; + s.close(); + + return path.str().str(); +} + +TEST(DriverTest, DumpTokens) { + RawTestOstream test_output_stream; + RawTestOstream test_error_stream; + Driver driver = Driver(test_output_stream, test_error_stream); + + auto test_file_path = CreateTestFile("Hello World"); + EXPECT_TRUE(driver.RunDumpTokensSubcommand({test_file_path})); + EXPECT_THAT(test_error_stream.TakeStr(), StrEq("")); + auto tokenized_text = test_output_stream.TakeStr(); + + // Parse the output into a YAML stream. This will print errors to stderr and + // is the most stable view of the textual dumping API. + llvm::SourceMgr sm; + llvm::yaml::Stream yaml_stream(tokenized_text, sm); + auto yaml_it = yaml_stream.begin(); + auto* root_node = llvm::dyn_cast(yaml_it->getRoot()); + ASSERT_THAT(root_node, NotNull()); + + // Walk the top-level mapping of tokens, dig out the sub-mapping of data for + // each taken, and then verify those entries. + auto mapping_it = llvm::cast(root_node)->begin(); + auto* token_node = llvm::dyn_cast(&*mapping_it); + ASSERT_THAT(token_node, NotNull()); + auto* token_key_node = + llvm::dyn_cast(token_node->getKey()); + ASSERT_THAT(token_key_node, NotNull()); + EXPECT_THAT(token_key_node->getRawValue(), StrEq("token")); + auto* token_value_node = + llvm::dyn_cast(token_node->getValue()); + ASSERT_THAT(token_value_node, NotNull()); + auto token_it = token_value_node->begin(); + EXPECT_THAT(&*token_it, IsKeyValueScalars("index", "0")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("kind", "Identifier")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("line", "1")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("column", "1")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("indent", "1")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("spelling", "Hello")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("identifier", "0")); + EXPECT_THAT(++token_it, Eq(token_value_node->end())); + + ++mapping_it; + token_node = llvm::dyn_cast(&*mapping_it); + ASSERT_THAT(token_node, NotNull()); + token_key_node = llvm::dyn_cast(token_node->getKey()); + ASSERT_THAT(token_key_node, NotNull()); + EXPECT_THAT(token_key_node->getRawValue(), StrEq("token")); + token_value_node = + llvm::dyn_cast(token_node->getValue()); + ASSERT_THAT(token_value_node, NotNull()); + token_it = token_value_node->begin(); + EXPECT_THAT(&*token_it, IsKeyValueScalars("index", "1")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("kind", "Identifier")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("line", "1")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("column", "7")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("indent", "1")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("spelling", "World")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("identifier", "1")); + EXPECT_THAT(++token_it, Eq(token_value_node->end())); + + ++mapping_it; + token_node = llvm::dyn_cast(&*mapping_it); + ASSERT_THAT(token_node, NotNull()); + token_key_node = llvm::dyn_cast(token_node->getKey()); + ASSERT_THAT(token_key_node, NotNull()); + EXPECT_THAT(token_key_node->getRawValue(), StrEq("token")); + token_value_node = + llvm::dyn_cast(token_node->getValue()); + ASSERT_THAT(token_value_node, NotNull()); + token_it = token_value_node->begin(); + EXPECT_THAT(&*token_it, IsKeyValueScalars("index", "2")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("kind", "EndOfFile")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("line", "1")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("column", "12")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("indent", "1")); + ++token_it; + EXPECT_THAT(&*token_it, IsKeyValueScalars("spelling", "")); + EXPECT_THAT(++token_it, Eq(token_value_node->end())); + + ASSERT_THAT(++mapping_it, Eq(root_node->end())); + ASSERT_THAT(++yaml_it, Eq(yaml_stream.end())); + + // Check that the subcommand dispatch works. + EXPECT_TRUE(driver.RunFullCommand({"dump-tokens", test_file_path})); + EXPECT_THAT(test_error_stream.TakeStr(), StrEq("")); + EXPECT_THAT(test_output_stream.TakeStr(), StrEq(tokenized_text)); +} + +TEST(DriverTest, DumpTokenErrors) { + RawTestOstream test_output_stream; + RawTestOstream test_error_stream; + Driver driver = Driver(test_output_stream, test_error_stream); + + EXPECT_FALSE(driver.RunDumpTokensSubcommand({})); + EXPECT_THAT(test_output_stream.TakeStr(), StrEq("")); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); + + EXPECT_FALSE(driver.RunDumpTokensSubcommand({"--xyz"})); + EXPECT_THAT(test_output_stream.TakeStr(), StrEq("")); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); + + EXPECT_FALSE(driver.RunDumpTokensSubcommand({"/not/a/real/file/name"})); + EXPECT_THAT(test_output_stream.TakeStr(), StrEq("")); + EXPECT_THAT(test_error_stream.TakeStr(), HasSubstr("ERROR")); +} + +} // namespace +} // namespace Carbon diff --git a/driver/flags.def b/driver/flags.def new file mode 100644 index 0000000000000..e4ac6b37defdf --- /dev/null +++ b/driver/flags.def @@ -0,0 +1,19 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +// Note: X-macro header. Do not use include guards. + +#ifndef CARBON_SUBCOMMAND +// FIXME: We should expand `HelpText` to be a short help name, a synopsis, and a +// long-form description. +#define CARBON_SUBCOMMAND(Name, Spelling, HelpText) +#endif + +CARBON_SUBCOMMAND(Help, "help", + "Display help information about the driver options.") +CARBON_SUBCOMMAND( + DumpTokens, "dump-tokens", + "Dumps the sequence of tokens lexed out of the input source file.") + +#undef CARBON_SUBCOMMAND diff --git a/driver/fuzzer_corpus/019dd4030b151d2c67da557bf3d56d96dc7839c1 b/driver/fuzzer_corpus/019dd4030b151d2c67da557bf3d56d96dc7839c1 new file mode 100644 index 0000000000000000000000000000000000000000..7f7a623b9775680fe453fe358a448b41b5f7d16e GIT binary patch literal 21 WcmZQ(U|?VYVn!eafsE9gg8u*qWCF1O literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/02c83534aab9233198863881aa7d82dde0a5b980 b/driver/fuzzer_corpus/02c83534aab9233198863881aa7d82dde0a5b980 new file mode 100644 index 0000000000000000000000000000000000000000..936a4ed8227532f2040928992d7b9da8893000a7 GIT binary patch literal 280 VcmZ=^U|?VY;!%JIfsE9g0svFr0rCI< literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/059a104f98f5658171c48a4d6b0d39036f953264 b/driver/fuzzer_corpus/059a104f98f5658171c48a4d6b0d39036f953264 new file mode 100644 index 0000000000000000000000000000000000000000..8429c145de3ec3e97263952a68d3154689879157 GIT binary patch literal 1024 Tcmey*FbYOPU^E0qY6t)T06YNz literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/0ab2969c765b7dfd5a132f93c87d60f700089d26 b/driver/fuzzer_corpus/0ab2969c765b7dfd5a132f93c87d60f700089d26 new file mode 100644 index 0000000000000000000000000000000000000000..be48ac08486d9c12e290a2d8b3843f41b04f300c GIT binary patch literal 4 LcmZP&U|;|M05kv* literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/11780e1967cb34483305ee0ce43df22b498db8de b/driver/fuzzer_corpus/11780e1967cb34483305ee0ce43df22b498db8de new file mode 100644 index 0000000000000000000000000000000000000000..6b2dfe0376880f0aea54cff587b25ff40a4bd683 GIT binary patch literal 36 Kcmd;JAPfKjL;wi@ literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/140803cdfca738e7d23521f13ecf6d87d0bd8980 b/driver/fuzzer_corpus/140803cdfca738e7d23521f13ecf6d87d0bd8980 new file mode 100644 index 0000000000000000000000000000000000000000..4bbc8a001e1f7a928121009203ab249570328849 GIT binary patch literal 488 NcmbSL%`4VpU;qFq-~_e+ literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/2251142ebdcd99890424c932de502d094925ad98 b/driver/fuzzer_corpus/2251142ebdcd99890424c932de502d094925ad98 new file mode 100644 index 0000000000000000000000000000000000000000..792f921748961368f1d9af229d1771c56abd06ae GIT binary patch literal 4 LcmZQpU|;|M0B`^# literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/256dbb574b157de6b00c720c6e123de5d3129e56 b/driver/fuzzer_corpus/256dbb574b157de6b00c720c6e123de5d3129e56 new file mode 100644 index 0000000000000000000000000000000000000000..da54b323b3c47563cf90b83afa17c08f4a93fed5 GIT binary patch literal 8 NcmZQ%U|SL%`46U03ebC@&Et; literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/2f99d3b7e96de13b21d1b33aa77d5d48fc6e6f88 b/driver/fuzzer_corpus/2f99d3b7e96de13b21d1b33aa77d5d48fc6e6f88 new file mode 100644 index 0000000000000000000000000000000000000000..c74d18fa093178ec8774c30771b1d3f4efa48323 GIT binary patch literal 72 LcmWe+pbh{41rPud literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/2fd2a7b121a56fdc1e623de01dc1678414adc5dc b/driver/fuzzer_corpus/2fd2a7b121a56fdc1e623de01dc1678414adc5dc new file mode 100644 index 0000000000000000000000000000000000000000..7e18a633820bf63478f2d80f9006b88475dbc4c8 GIT binary patch literal 4 Lcmb1L#J~Um0$u>X literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/300ba8e152fe095fcd1f88d18bc64d5b100059e6 b/driver/fuzzer_corpus/300ba8e152fe095fcd1f88d18bc64d5b100059e6 new file mode 100644 index 0000000000000000000000000000000000000000..930a18894f84a33c27b682592fbf9f663beec139 GIT binary patch literal 12 RcmZQ%U|?VY;*8Xs0ssV00j~f6 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/34c0284640cf11c78b5802ecaf21802ebc83df04 b/driver/fuzzer_corpus/34c0284640cf11c78b5802ecaf21802ebc83df04 new file mode 100644 index 0000000000000000000000000000000000000000..009f26039ae870a8dd444a645818f9f882d8d99d GIT binary patch literal 68 Tcmd;QU|?VYVsb%7YEA(F30DEV literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/3519a9e1095165b91c5d4ba9824d32227da30bd6 b/driver/fuzzer_corpus/3519a9e1095165b91c5d4ba9824d32227da30bd6 new file mode 100644 index 0000000000000000000000000000000000000000..7418edecc9cc20e5ddcbfa3225797bb870b737ad GIT binary patch literal 12 RcmZQ%U|?VY;^z!Z4gdrg0WSam literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/39294db001ba643d5353c8f418f754c6352c8485 b/driver/fuzzer_corpus/39294db001ba643d5353c8f418f754c6352c8485 new file mode 100644 index 0000000000000000000000000000000000000000..2ac9507641f2f173f9e4dedae6e100e653ce9101 GIT binary patch literal 28 KcmZQ$zzqNZ!~h2X literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/3c4c33f72a9ff968e60adf7a2db5206d6375b7c5 b/driver/fuzzer_corpus/3c4c33f72a9ff968e60adf7a2db5206d6375b7c5 new file mode 100644 index 0000000000000000000000000000000000000000..c9f721417f207d70e4e3c9893d5fbc4c9cce7462 GIT binary patch literal 24 TcmZQ!U|?VYVq}n!no|G(1m6L& literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/3c585604e87f855973731fea83e21fab9392d2fc b/driver/fuzzer_corpus/3c585604e87f855973731fea83e21fab9392d2fc new file mode 100644 index 0000000000000000000000000000000000000000..f66c9cf4c9672fa2832bce76f4082fd97b823506 GIT binary patch literal 4 LcmZQ%U|;|M00;mA literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/3da89ee273be13437e7ecf760f3fbd4dc0e8d1fe b/driver/fuzzer_corpus/3da89ee273be13437e7ecf760f3fbd4dc0e8d1fe new file mode 100644 index 0000000000000000000000000000000000000000..20d5cb86e6dff1f3684dc229a358a2ea697cecfb GIT binary patch literal 8 KcmZQ%fB*mh5C8%I literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/3dbc1b67cab9a71bac41d7ee17fa31a8b32a9904 b/driver/fuzzer_corpus/3dbc1b67cab9a71bac41d7ee17fa31a8b32a9904 new file mode 100644 index 0000000000000..9f950f8292e19 --- /dev/null +++ b/driver/fuzzer_corpus/3dbc1b67cab9a71bac41d7ee17fa31a8b32a9904 @@ -0,0 +1,3 @@ + + +'æ \ No newline at end of file diff --git a/driver/fuzzer_corpus/4148ee13ed2c74d0f5ce52c46ebd0983c26beb64 b/driver/fuzzer_corpus/4148ee13ed2c74d0f5ce52c46ebd0983c26beb64 new file mode 100644 index 0000000000000000000000000000000000000000..7b5833a76817049d6530af555b0fa4ece8ae9f22 GIT binary patch literal 132 LcmY#j7b%7 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/6ba597db92a7d33adb74499c15e5034ee57cd41b b/driver/fuzzer_corpus/6ba597db92a7d33adb74499c15e5034ee57cd41b new file mode 100644 index 0000000000000000000000000000000000000000..9ede1cf3e7277a59ae72eddede22394174f26e23 GIT binary patch literal 32 VcmZ3)z`&pg#3-PFfdPoX001F;0mJ|R literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/6cd45830db903347e26c3e114ba494052a4a42bd b/driver/fuzzer_corpus/6cd45830db903347e26c3e114ba494052a4a42bd new file mode 100644 index 0000000000000000000000000000000000000000..9ad15ea1bc83bc40ce349d57726cedf5056f58c0 GIT binary patch literal 516 ccmXqDWPpG=C_PxI!R|f^!;O~S6D8m_07&5h!2kdN literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/6f3f7dcc0a69d64ed2d99bcee0c0fbb81f970fc6 b/driver/fuzzer_corpus/6f3f7dcc0a69d64ed2d99bcee0c0fbb81f970fc6 new file mode 100644 index 0000000000000000000000000000000000000000..3afc7b3bf502a81d7024b8bc5df9e5d659270846 GIT binary patch literal 28 LcmZQ(V!#Oi0Hy#2 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/74a21fca37339bc7223b8963473dff771ae964f5 b/driver/fuzzer_corpus/74a21fca37339bc7223b8963473dff771ae964f5 new file mode 100644 index 0000000000000000000000000000000000000000..011cc4922a653937f708f9e13a0c587c7d015154 GIT binary patch literal 64 Tcmd;MU|?VYVsb!6YEA(F2*&}u literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/78d5bd054d5f82b116ac00b834314d4e24f6c21b b/driver/fuzzer_corpus/78d5bd054d5f82b116ac00b834314d4e24f6c21b new file mode 100644 index 0000000000000000000000000000000000000000..78fe71f069e94c5e5409b4a47ede308749c6c304 GIT binary patch literal 508 NcmbmVN literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/8b0653417087d3d7fd049166a72cd7bcbc5f6dd1 b/driver/fuzzer_corpus/8b0653417087d3d7fd049166a72cd7bcbc5f6dd1 new file mode 100644 index 0000000000000..85a5b5f87eecd --- /dev/null +++ b/driver/fuzzer_corpus/8b0653417087d3d7fd049166a72cd7bcbc5f6dd1 @@ -0,0 +1,3 @@ +½ + +* \ No newline at end of file diff --git a/driver/fuzzer_corpus/8cabec887fe80b7d9f8b28e989db65a6d72dd22b b/driver/fuzzer_corpus/8cabec887fe80b7d9f8b28e989db65a6d72dd22b new file mode 100644 index 0000000000000000000000000000000000000000..4adfcb26b230e2548ea2ae1544205736775c221a GIT binary patch literal 132 QcmZQ(Vn6^^1e2aD00n6P3jhEB literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/8eda19d8bfbc4dbd6070bf626cd2f33160ff88a0 b/driver/fuzzer_corpus/8eda19d8bfbc4dbd6070bf626cd2f33160ff88a0 new file mode 100644 index 0000000000000000000000000000000000000000..4263a14294302f2ec861e3a003fde8859c47a917 GIT binary patch literal 156 LcmY#m7`y-g7sLQ3 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/9069ca78e7450a285173431b3e52c5c25299e473 b/driver/fuzzer_corpus/9069ca78e7450a285173431b3e52c5c25299e473 new file mode 100644 index 0000000000000000000000000000000000000000..593f4708db84ac8fd0f5cc47c634f38c013fe9e4 GIT binary patch literal 4 LcmZQzU|;|M00aO5 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/922b5a97efaa1a3ecba58234ad8d01f41d36d313 b/driver/fuzzer_corpus/922b5a97efaa1a3ecba58234ad8d01f41d36d313 new file mode 100644 index 0000000000000000000000000000000000000000..ec4c8f804ebc46c2af755360f3f86dff6f15e448 GIT binary patch literal 1004 TcmeyxFbYOPU^E0qLI?l=*pUGH literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/9d47be29ac84966acf09290f8a7df5ba0ac4ea4e b/driver/fuzzer_corpus/9d47be29ac84966acf09290f8a7df5ba0ac4ea4e new file mode 100644 index 0000000000000000000000000000000000000000..fa8d41a004fdefd75e45b8dff4dab85cdb758aed GIT binary patch literal 16 Rcmd;LVqjqS55y4g9{>!(0t)~D literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/a2ae2a7db83b33dc95396607258f553114c9183c b/driver/fuzzer_corpus/a2ae2a7db83b33dc95396607258f553114c9183c new file mode 100644 index 0000000000000000000000000000000000000000..3ae168742fb512b29aeaf6283b3f2534804fb9be GIT binary patch literal 12 KcmZQ#KmY&$Bme^d literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/a454ca483b4a66b83826d061be2859dd79ff0d6c b/driver/fuzzer_corpus/a454ca483b4a66b83826d061be2859dd79ff0d6c new file mode 100644 index 0000000000000000000000000000000000000000..38424fc7a255c7fc7f84b4af38cd70f1062ee07b GIT binary patch literal 4 Lcmd;JU|;|M03-kj literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/a5bbebbdf11c537a22a3a9dab4b83498ceb441ca b/driver/fuzzer_corpus/a5bbebbdf11c537a22a3a9dab4b83498ceb441ca new file mode 100644 index 0000000000000000000000000000000000000000..d53367296f26651259946ae5c5efad1c33ac9129 GIT binary patch literal 8 Kcmd;NfB*mhPyh-5 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/a69f09257d9cd8f5edd9a87b728ab3d75d4352c4 b/driver/fuzzer_corpus/a69f09257d9cd8f5edd9a87b728ab3d75d4352c4 new file mode 100644 index 0000000000000000000000000000000000000000..ea5317ff97e3891214b95d0c71228e8ea9c27969 GIT binary patch literal 4 Lcmb1PU|;|M0CWHy literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/a8502f9cfc7efd4ddb3cb771ae00364f60bc279f b/driver/fuzzer_corpus/a8502f9cfc7efd4ddb3cb771ae00364f60bc279f new file mode 100644 index 0000000000000000000000000000000000000000..e490c68c1fe636ef6dcc5fc0d7f749ae93f84464 GIT binary patch literal 39 ocmZQ#U|`?|VgVpdDa|d=Ey>SL%`0Y5V)*~x{yz}tmH_!m0IYNj@c;k- literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/adc83b19e793491b1c6ea0fd8b46cd9f32e592fc b/driver/fuzzer_corpus/adc83b19e793491b1c6ea0fd8b46cd9f32e592fc new file mode 100644 index 0000000000000..8b137891791fe --- /dev/null +++ b/driver/fuzzer_corpus/adc83b19e793491b1c6ea0fd8b46cd9f32e592fc @@ -0,0 +1 @@ + diff --git a/driver/fuzzer_corpus/aecfd3909eadc5707dd46249f6239cad4a2d8618 b/driver/fuzzer_corpus/aecfd3909eadc5707dd46249f6239cad4a2d8618 new file mode 100644 index 0000000000000000000000000000000000000000..f4401bd700aa8a6cbdac594369792cd9b53f1ecd GIT binary patch literal 4 LcmWe&U||3N089WC literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/af0fb9fda0e123b97ba7be099545a02b8c21a058 b/driver/fuzzer_corpus/af0fb9fda0e123b97ba7be099545a02b8c21a058 new file mode 100644 index 0000000000000000000000000000000000000000..16531f743492c4c1324fc17590327f64d81d3229 GIT binary patch literal 32 TcmZQ$U|?VYVr(EIHKzao1!n=Y literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/af1ec8ae5cda07dc979bd68e45d67ffe0d7ffed6 b/driver/fuzzer_corpus/af1ec8ae5cda07dc979bd68e45d67ffe0d7ffed6 new file mode 100644 index 0000000000000000000000000000000000000000..5a279f9e926746cd24fafaba4cdd704fdc5faf29 GIT binary patch literal 1012 TcmeyvFbYOPU^E0qQV0M5=urUu literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/b36251f56081e4735b65b1c9d3d765f25ce67a66 b/driver/fuzzer_corpus/b36251f56081e4735b65b1c9d3d765f25ce67a66 new file mode 100644 index 0000000000000000000000000000000000000000..3570d98c622ad13d1d8e662f1e41a3f6d3f6d2f9 GIT binary patch literal 17 VcmZQ#U|?VYVn!g&NX;o=000Is0kHr8 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/b62c8e9630f2bb2106ce5717ecf7f10c1b89b958 b/driver/fuzzer_corpus/b62c8e9630f2bb2106ce5717ecf7f10c1b89b958 new file mode 100644 index 0000000000000000000000000000000000000000..93eeee06a5c6cb64d91038c6ca318d6f320b7c1b GIT binary patch literal 48 Tcmd;LU|?VYVq!o>YEA(F2G;?& literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/b74fd0148ec8333ad7ce831dd7caa6bc4eff73a9 b/driver/fuzzer_corpus/b74fd0148ec8333ad7ce831dd7caa6bc4eff73a9 new file mode 100644 index 0000000000000000000000000000000000000000..5d2e20acd7b41ae2084e713d4dc5c943965c5fa6 GIT binary patch literal 76 TcmWe+U|?VYVoE_qYEA(F3XcK5 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/b82f012f0ede708c493207a1eeee577e3c0f884c b/driver/fuzzer_corpus/b82f012f0ede708c493207a1eeee577e3c0f884c new file mode 100644 index 0000000000000000000000000000000000000000..734832caf06ece69244be30e3d1876f6bb5a21af GIT binary patch literal 668 QcmZ3+FbYOPU~q;20JGBorvLx| literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/bb709bdd1d83c039d5c2f02313009030a4f73e0f b/driver/fuzzer_corpus/bb709bdd1d83c039d5c2f02313009030a4f73e0f new file mode 100644 index 0000000000000000000000000000000000000000..9af3eceee2bb4ff18cfa2db042d4ce9294124177 GIT binary patch literal 44 Tcmd;NU|?VYVnQGzHKzao25$kk literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/bc75eaba7c2f73ce991969295463f6af70bfbf1a b/driver/fuzzer_corpus/bc75eaba7c2f73ce991969295463f6af70bfbf1a new file mode 100644 index 0000000000000000000000000000000000000000..ca023e5a1372d65222391caa9d2f3b22e1adbc2d GIT binary patch literal 120 Lcmb1T7#IKm4iEqy literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/be0ef7b40ed46b91af0482ce0eb7ad38042b5659 b/driver/fuzzer_corpus/be0ef7b40ed46b91af0482ce0eb7ad38042b5659 new file mode 100644 index 0000000000000000000000000000000000000000..0bfb825109190509ac8208f9e789c154e6e9b794 GIT binary patch literal 328 NcmWG!7zNY_0RU+b08#(| literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/beacd06c224890fcf6d9b09b771e1248e241ab4b b/driver/fuzzer_corpus/beacd06c224890fcf6d9b09b771e1248e241ab4b new file mode 100644 index 0000000000000000000000000000000000000000..e823cd1faf7770b756a3d3043741eb57d3ec69a2 GIT binary patch literal 136 LcmY#n7#siq5)c3) literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/c349a8a58eb9c57bf1c97e5af483db5144482772 b/driver/fuzzer_corpus/c349a8a58eb9c57bf1c97e5af483db5144482772 new file mode 100644 index 0000000000000000000000000000000000000000..219ef65ba59ed4571572907fc4d1e5525e6742bc GIT binary patch literal 48 Lcmd;PAPoQj0zd!^ literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/c673fa568bbd98569d347b44306c46b50cc2e53f b/driver/fuzzer_corpus/c673fa568bbd98569d347b44306c46b50cc2e53f new file mode 100644 index 0000000000000000000000000000000000000000..ec34b3bf5e32f287b9689cc9bcd472747d22945a GIT binary patch literal 20 TcmZQ(U|?VYVi?Fs%_#r?1g8P9 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/c949526372921c8c5a75ed9e1b198f44fb7a96a1 b/driver/fuzzer_corpus/c949526372921c8c5a75ed9e1b198f44fb7a96a1 new file mode 100644 index 0000000000000000000000000000000000000000..b320162ceab56732c39aa34b2e11df4f65fe136b GIT binary patch literal 4 LcmY#jVPF6N0FVGB literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/cf294d20a4419644a7716bc1e1783a770c5e2e33 b/driver/fuzzer_corpus/cf294d20a4419644a7716bc1e1783a770c5e2e33 new file mode 100644 index 0000000000000000000000000000000000000000..a48025a6131752bbc6f17ecad840bb2102ab0447 GIT binary patch literal 12 TcmZ=_U|^77Vqj3wV_*OP1q=YM literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/cfa74701753e8c5eda1d7364b63b26b667c71bb2 b/driver/fuzzer_corpus/cfa74701753e8c5eda1d7364b63b26b667c71bb2 new file mode 100644 index 0000000000000000000000000000000000000000..73fbf532b60c9b0d3e63377ba57d76048eff3b96 GIT binary patch literal 104 Lcmb1Spbr253XlLA literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/d25a8e16325922f85262deec08e77c04acf69f8e b/driver/fuzzer_corpus/d25a8e16325922f85262deec08e77c04acf69f8e new file mode 100644 index 0000000000000000000000000000000000000000..5d59266503d8cdf1f858d4fbd7214d1eba1eda77 GIT binary patch literal 24 ccmZQ#U|`?|Vn!fNDa|d=Ey>SL%`4Ui03cNawEzGB literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/d5ebc4110136110c161d48f2d8e53cd1b4edfc0d b/driver/fuzzer_corpus/d5ebc4110136110c161d48f2d8e53cd1b4edfc0d new file mode 100644 index 0000000000000000000000000000000000000000..cacd13f5ef132a62bc4b81f1951993dac9f1eca1 GIT binary patch literal 16 TcmZQ#U|?VYVi3qk%_#r?1a|?j literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/d97e2e42e26d865d34f68bc92cf8bfe6a40f2eb4 b/driver/fuzzer_corpus/d97e2e42e26d865d34f68bc92cf8bfe6a40f2eb4 new file mode 100644 index 0000000000000000000000000000000000000000..2d84c57f8999d10e18253afd5b229bd85e285848 GIT binary patch literal 140 LcmY#l7(4&~6C?m5 literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/e3d8d13265fdbea01751381344b1a7466fb0cdfb b/driver/fuzzer_corpus/e3d8d13265fdbea01751381344b1a7466fb0cdfb new file mode 100644 index 0000000000000000000000000000000000000000..398b577112717809bec0d6d4dc738354a86b37c6 GIT binary patch literal 20 KcmZQ!zytsQWB>&K literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/e4cd6da031338746e34eb86e8a931d3b589e3d50 b/driver/fuzzer_corpus/e4cd6da031338746e34eb86e8a931d3b589e3d50 new file mode 100644 index 0000000000000000000000000000000000000000..72f92059f54ca881dd923c869c2c8235075f9a5c GIT binary patch literal 60 Lcmd;MARhn#1B3t% literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/e8e9adab43ade785323869812e73201de7abf7ad b/driver/fuzzer_corpus/e8e9adab43ade785323869812e73201de7abf7ad new file mode 100644 index 0000000000000000000000000000000000000000..83e0de3b621ac5feabf10a85d832adc64d8cb691 GIT binary patch literal 68 LcmWe&pd0`I1cU$) literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/ea21645db01d3810168f14c8dfa601d54d7a52f5 b/driver/fuzzer_corpus/ea21645db01d3810168f14c8dfa601d54d7a52f5 new file mode 100644 index 0000000000000000000000000000000000000000..d887b783b953f60ead0a11539cab87338e845030 GIT binary patch literal 16 KcmZQ(Km`B*KmY^) literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/ed301991137b18831e72c6a6045fac64e5c010c9 b/driver/fuzzer_corpus/ed301991137b18831e72c6a6045fac64e5c010c9 new file mode 100644 index 0000000000000000000000000000000000000000..02d5396c02c20636c9291c998dd0b2ef3f73e9f5 GIT binary patch literal 1028 TcmZQzWEcgbAut*OBRB*A2nPTH literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/efa312d99ad0a086577dfb243164f522aa921b86 b/driver/fuzzer_corpus/efa312d99ad0a086577dfb243164f522aa921b86 new file mode 100644 index 0000000000000000000000000000000000000000..5b979f99d009a7dcd51d69d9fe11914c8bbf4dc9 GIT binary patch literal 20 ScmdO5fB literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/f488a972b82d572833fccb4600a74d8d4a33ff84 b/driver/fuzzer_corpus/f488a972b82d572833fccb4600a74d8d4a33ff84 new file mode 100644 index 0000000000000000000000000000000000000000..864ade5c98910e361a92e31cda03dc4532c770d0 GIT binary patch literal 23 acmZQ#U|`?|Vh~6v%`MO^$*07d{A literal 0 HcmV?d00001 diff --git a/driver/fuzzer_corpus/fe0ff78dd1420db832b271cc868019e9945f5f79 b/driver/fuzzer_corpus/fe0ff78dd1420db832b271cc868019e9945f5f79 new file mode 100644 index 0000000000000000000000000000000000000000..e9f4e01b7d902bdc4294b9999e520595e52b5f36 GIT binary patch literal 248 LcmcCz7?}V7JP-gr literal 0 HcmV?d00001