aboutsummaryrefslogtreecommitdiff
path: root/libjava/java/io/FileInputStream.java
blob: 9d0d0133b9cf76a102d9a21bd122b494d7a192c8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/* Copyright (C) 1998, 1999, 2001  Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */
 
package java.io;

/**
 * @author Warren Levy <warrenl@cygnus.com>
 * @date October 28, 1998.  
 */
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
 * "The Java Language Specification", ISBN 0-201-63451-1
 * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
 * Status:  Believed complete and correct.
 */
 
public class FileInputStream extends InputStream
{
  /* Contains the file descriptor for referencing the actual file. */
  private FileDescriptor fd;

  public FileInputStream(String name) throws FileNotFoundException
  {
    SecurityManager s = System.getSecurityManager();
    if (s != null)
      s.checkRead(name);
    fd = new FileDescriptor(name, FileDescriptor.READ);
  }

  public FileInputStream(File file) throws FileNotFoundException
  {
    this(file.getPath());
  }

  public FileInputStream(FileDescriptor fdObj)
  {
    SecurityManager s = System.getSecurityManager();
    if (s != null)
      s.checkRead(fdObj);
    fd = fdObj;
  }

  public int available() throws IOException
  {
    return fd.available();
  }

  public void close() throws IOException
  {
    if (fd.valid())
      fd.close();
  }

  protected void finalize() throws IOException
  {
    if (fd != null)
      fd.finalize();
  }

  public final FileDescriptor getFD() throws IOException
  {
    if (!fd.valid())
      throw new IOException();
    return fd;
  }

  public int read() throws IOException
  {
    return fd.read();
  }

  public int read(byte[] b) throws IOException
  {
    return fd.read(b, 0, b.length);
  }

  public int read(byte[] b, int off, int len) throws IOException
  {
    if (off < 0 || len < 0 || off + len > b.length)
      throw new ArrayIndexOutOfBoundsException();

    return fd.read(b, off, len);
  }

  public long skip(long n) throws IOException
  {
    return n <= 0 ? 0 : fd.seek(n, FileDescriptor.CUR, true);
  }
}
ummary='blob content' class='blob'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#!/usr/bin/env python3
# SPDX-License-Identifier: Apache-2.0
# Copyright 2021 The Meson development team

import subprocess
import coverage
import os
import sys
from pathlib import Path

root_path = Path(__file__).parent.parent.absolute()

# Python magic so we can import mesonlib
sys.path.append(root_path.as_posix())
from mesonbuild import mesonlib

def generate_coveragerc() -> Path:
    i_file = (root_path / 'data' / '.coveragerc.in')
    o_file = (root_path / '.coveragerc')
    raw = i_file.read_text(encoding='utf-8')
    raw = raw.replace('@ROOT@', root_path.as_posix())
    o_file.write_text(raw, encoding='utf-8')
    return o_file

def main() -> int:
    # Remove old run data
    out_dir = root_path / '.coverage'
    mesonlib.windows_proof_rmtree(out_dir.as_posix())
    out_dir.mkdir(parents=True, exist_ok=True)

    # Setup coverage
    python_path = (root_path / 'ci').as_posix()
    os.environ['PYTHONPATH'] = os.pathsep.join([python_path, os.environ.get('PYTHONPATH', '')])
    os.environ['COVERAGE_PROCESS_START'] = generate_coveragerc().as_posix()
    coverage.process_startup()

    # Run the actual command
    cmd = mesonlib.python_command + sys.argv[1:]
    return subprocess.run(cmd, env=os.environ.copy()).returncode

if __name__ == '__main__':
    raise SystemExit(main())