रन फ़ाइलें

load("@rules_cc//cc:cc_binary.bzl", "cc_binary")

cc_binary(
    name = "runfile",
    srcs = ["runfile.cc"],
    data = ["//examples:runfile.txt"],
    deps = ["@rules_cc//cc/runfiles"],
)
    

#include 
#include 
#include 
#include 

#include "rules_cc/cc/runfiles/runfiles.h"

using rules_cc::cc::runfiles::Runfiles;

inline constexpr std::string_view someFile = "examples/runfile.txt";

int main(int argc, char **argv) {
  std::string error;
  const auto runfiles = Runfiles::Create(argv[0], BAZEL_CURRENT_REPOSITORY, &error);
  if (runfiles == nullptr) {
    std::cerr << "Failed to create Runfiles object" << error << "\n";
    return 1;
  }

  std::string root = BAZEL_CURRENT_REPOSITORY;
  if (root == "") {
    root = "_main";
  }
  const std::string realPathToSomeFile = runfiles->Rlocation(std::filesystem::path(root) / someFile);

  std::cout << "The content of the runfile is:\n";
  std::ifstream fin(realPathToSomeFile);
  std::string line;
  while (std::getline(fin, line)) {
    std::cout << line << "\n";
  }

  return 0;
}
    

load("@rules_go//go:def.bzl", "go_binary")

go_binary(
    name = "runfile",
    srcs = ["runfile.go"],
    data = ["//examples:runfile.txt"],
    deps = ["@rules_go//go/runfiles:go_default_library"],
)
    

package main

import (
    "fmt"
    "log"
    "os"
    "path/filepath"

    "github.com/bazelbuild/rules_go/go/runfiles"
)

const (
    someFile = "examples/runfile.txt"
)

func main() {
    r, err := runfiles.New()
    if err != nil {
        log.Fatalf("Failed to create Runfiles object: %v", err)
    }

    root := runfiles.CallerRepository()
    if root == "" {
        root = "_main"
    }

    path, err := r.Rlocation(filepath.Join(root, someFile))
    if err != nil {
        log.Fatalf("Failed to find rlocation: %v", err)
    }

    fmt.Println("The content of my runfile is:")
    data, err := os.ReadFile(path)
    if err != nil {
        log.Fatalf("Failed to read file: %v", err)
    }
    fmt.Print(string(data))
}
    

load("@rules_python//python:defs.bzl", "py_binary")

py_binary(
    name = "runfile",
    srcs = ["runfile.py"],
    data = ["//examples:runfile.txt"],
    deps = ["@rules_python//python/runfiles"],
)
    

import pathlib

from python.runfiles import runfiles

SOME_FILE = pathlib.Path('examples/runfile.txt')

r = runfiles.Create()
root = r.CurrentRepository()
if root == "":
  root = "_main"
realPathToSomeFile = r.Rlocation(str(root / SOME_FILE))

print("The content of the runfile is:")
with open(realPathToSomeFile, 'r') as f:
    print(f.read())
    

load("@rules_shell//shell:sh_binary.bzl", "sh_binary")

sh_binary(
    name = "runfile",
    srcs = ["runfile.sh"],
    data = ["//examples:runfile.txt"],
    use_bash_launcher = True,
)
    

#!/bin/bash

SOME_FILE='examples/runfile.txt'

root="$(runfiles_current_repository)"
if [ -z "$root" ]; then
  root="_main"
fi
real_path_to_some_file="$(rlocation "${root}/${SOME_FILE}")"

echo "The content of the runfile is:"
cat "${real_path_to_some_file}"