text: //===- toyc.cpp - The Toy Compiler ----------------------------------------===//
  //
  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  // See https://llvm.org/LICENSE.txt for license information.
  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  //
  //===----------------------------------------------------------------------===//
  //
  // This file implements the entry point for the Toy compiler.
  //
  //===----------------------------------------------------------------------===//
  
  #include "toy/Dialect.h"
  #include "toy/MLIRGen.h"
  #include "toy/Parser.h"
  
  #include "mlir/IR/AsmState.h"
  #include "mlir/IR/BuiltinOps.h"
  #include "mlir/IR/MLIRContext.h"
  #include "mlir/IR/Verifier.h"
  #include "mlir/Parser.h"
  #include "mlir/Pass/Pass.h"
  #include "mlir/Pass/PassManager.h"
  #include "mlir/Transforms/Passes.h"
  
  #include "llvm/ADT/StringRef.h"
  #include "llvm/Support/CommandLine.h"
  #include "llvm/Support/ErrorOr.h"
  #include "llvm/Support/MemoryBuffer.h"
  #include "llvm/Support/SourceMgr.h"
  #include "llvm/Support/raw_ostream.h"
  
  using namespace toy;
  namespace cl = llvm::cl;
  
  static cl::opt<std::string> inputFilename(cl::Positional,
                                            cl::desc("<input toy file>"),
                                            cl::init("-"),
                                            cl::value_desc("filename"));
  
  namespace {
  enum InputType { Toy, MLIR };
  }
  static cl::opt<enum InputType> inputType(
      "x", cl::init(Toy), cl::desc("Decided the kind of output desired"),
      cl::values(clEnumValN(Toy, "toy", "load the input file as a Toy source.")),
      cl::values(clEnumValN(MLIR, "mlir",
                            "load the input file as an MLIR file")));
  
  namespace {
  enum Action { None, DumpAST, DumpMLIR };
  }
  static cl::opt<enum Action> emitAction(
      "emit", cl::desc("Select the kind of output desired"),
      cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")),
      cl::values(clEnumValN(DumpMLIR, "mlir", "output the MLIR dump")));
  
  static cl::opt<bool> enableOpt("opt", cl::desc("Enable optimizations"));
  
  /// Returns a Toy AST resulting from parsing the file or a nullptr on error.
  std::unique_ptr<toy::ModuleAST> parseInputFile(llvm::StringRef filename) {
    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
        llvm::MemoryBuffer::getFileOrSTDIN(filename);
    if (std::error_code ec = fileOrErr.getError()) {
      llvm::errs() << "Could not open input file: " << ec.message() << "\n";
      return nullptr;
    }
    auto buffer = fileOrErr.get()->getBuffer();
    LexerBuffer lexer(buffer.begin(), buffer.end(), std::string(filename));
    Parser parser(lexer);
    return parser.parseModule();
  }
  
  int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context,
               mlir::OwningModuleRef &module) {
    // Handle '.toy' input to the compiler.
    if (inputType != InputType::MLIR &&
        !llvm::StringRef(inputFilename).endswith(".mlir")) {
      auto moduleAST = parseInputFile(inputFilename);
      if (!moduleAST)
        return 6;
      module = mlirGen(context, *moduleAST);
      return !module ? 1 : 0;
    }
  
    // Otherwise, the input is '.mlir'.
    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
        llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
    if (std::error_code EC = fileOrErr.getError()) {
      llvm::errs() << "Could not open input file: " << EC.message() << "\n";
      return -1;
    }
  
    // Parse the input mlir.
    sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
    module = mlir::parseSourceFile(sourceMgr, &context);
    if (!module) {
      llvm::errs() << "Error can't load file " << inputFilename << "\n";
      return 3;
    }
    return 0;
  }
  
  int dumpMLIR() {
    mlir::MLIRContext context;
    // Load our Dialect in this MLIR Context.
    context.getOrLoadDialect<mlir::toy::ToyDialect>();
  
    mlir::OwningModuleRef module;
    llvm::SourceMgr sourceMgr;
    mlir::SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
    if (int error = loadMLIR(sourceMgr, context, module))
      return error;
  
    if (enableOpt) {
      mlir::PassManager pm(&context);
      // Apply any generic pass manager command line options and run the pipeline.
      applyPassManagerCLOptions(pm);
  
      // Add a run of the canonicalizer to optimize the mlir module.
      pm.addNestedPass<mlir::FuncOp>(mlir::createCanonicalizerPass());
      if (mlir::failed(pm.run(*module)))
        return 4;
    }
  
    module->dump();
    return 0;
  }
  
  int dumpAST() {
    if (inputType == InputType::MLIR) {
      llvm::errs() << "Can't dump a Toy AST when the input is MLIR\n";
      return 5;
    }
  
    auto moduleAST = parseInputFile(inputFilename);
    if (!moduleAST)
      return 1;
  
    dump(*moduleAST);
    return 0;
  }
  
  int main(int argc, char **argv) {
    // Register any command line options.
    mlir::registerAsmPrinterCLOptions();
    mlir::registerMLIRContextCLOptions();
    mlir::registerPassManagerCLOptions();
  
    cl::ParseCommandLineOptions(argc, argv, "toy compiler\n");
  
    switch (emitAction) {
    case Action::DumpAST:
      return dumpAST();
    case Action::DumpMLIR:
      return dumpMLIR();
    default:
      llvm::errs() << "No action specified (parsing only?), use -emit=<action>\n";
    }
  
    return 0;
  }
  