(and (not (and case_substr:"Path" case_substr:"File")) case_substr:"Stream") with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}
in 455.866595ms (queued: 1.758µs)
android.googlesource.com/platform/frameworks/ex:framesequence/jni/Stream.cpp:[master, ] lang:c++
32: Stream::Stream()
38: Stream::~Stream() {
143: jint JavaStream_OnLoad(JNIEnv* env) {
30: } gInputStreamClassInfo;
17: #define LOG_TAG "Stream"
19: #include "Stream.h"
42: size_t Stream::peek(void* buffer, size_t size) {
60: size_t Stream::read(void* buffer, size_t size) {
82: uint8_t* Stream::getRawBufferAddr() {
86: jobject Stream::getRawBuffer() {
90: int Stream::getRawBufferSize() {
94: uint8_t* MemoryStream::getRawBufferAddr() {
98: jobject MemoryStream::getRawBuffer() {
102: int MemoryStream::getRawBufferSize() {
110: size_t MemoryStream::doRead(void* buffer, size_t size) {
118: size_t FileStream::doRead(void* buffer, size_t size) {
122: size_t JavaInputStream::doRead(void* dstBuffer, size_t size) {
128: jint bytesRead = mEnv->CallIntMethod(mInputStream,
146: jclass inputStreamClazz = env->FindClass("java/io/InputStream");
129: gInputStreamClassInfo.read, mByteArray, 0, requested);
147: if (!inputStreamClazz) {
150: gInputStreamClassInfo.read = env->GetMethodID(inputStreamClazz, "read", "([BII)I");
151: gInputStreamClassInfo.reset = env->GetMethodID(inputStreamClazz, "reset", "()V");
152: if (!gInputStreamClassInfo.read || !gInputStreamClassInfo.reset) {
5: function Stream(options){
11: Stream.prototype.readable = true;
1: module.exports = Stream;
9: require("util").inherits(Stream, Parser);
3: var Parser = require("./WritableStream.js");
26: class Stream : public Print
21: #define Stream_h
2: Stream.h - base class for character-based streams.
20: #ifndef Stream_h
31: public interface Stream {
35: * which the solutions are returned depends on the implementations of {@code Stream} used.
37: Stream mplus(Stream s2);
44: Stream bind(Goal goal);
55: Stream rest();
159: var Stream = function () {}
249: return Stream.prototype.on.call(me, ev, handler)
167: function createStream (strict, opt) {
232: SAXStream.prototype.end = function (chunk) {
157: var Stream = require("stream").Stream
174: Stream.apply(this)
213: SAXStream.prototype = Object.create(Stream.prototype,
6: sax.SAXStream = SAXStream
7: sax.createStream = createStream
168: return new SAXStream(strict, opt)
171: function SAXStream (strict, opt) {
172: if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)
214: { constructor: { value: SAXStream } })
216: SAXStream.prototype.write = function (data) {
238: SAXStream.prototype.on = function (ev, handler) {
50: Stream(u32),
18: class Stream(db.Model):
31: stream = Stream.get_by_key_name(event)
37: stream = Stream.get_or_insert(event)
54: stream = Stream.get_or_insert(event)
21: type Stream struct {
29: func NewStream(e []Event) *Stream {
141: type StreamError struct {
33: s := &Stream{
58: func (s *Stream) Next() (*pathtree.PathVal, error) {
79: func (s *Stream) Close() {
91: s *Stream
108: func (c *Client) Subscribe(p pathtree.Path) (*Stream, error) {
71: return nil, StreamError{Msg: fmt.Sprintf("invalid Event type: %T", e)}
96: s: NewStream(e),
145: func (e StreamError) Error() string {
11: type Stream interface {
10: // Stream provides an iterator for the events being streamed from the client.
27: Subscribe(pathtree.Path) (Stream, error)
471: Stream
95: inStream bool
210: func readXrefStream(r *Reader, b *buffer) ([]xref, objptr, dict, error) {
1046: func decryptStream(key []byte, useAES bool, ptr objptr, rd io.Reader) io.Reader {
270: func readXrefStreamData(r *Reader, strm stream, table []xref, size int64) ([]xref, error) {
31: // Stream, for an opaque data stream and associated header dictionary.
252: if prev.Kind() != Stream {
494: return Stream
658: // If v.Kind() != Dict and v.Kind() != Stream, Key returns a null Value.
673: // If v.Kind() != Dict and v.Kind() != Stream, Keys returns nil.
726: if strm.Kind() != Stream {
749: if ext.Kind() != Stream {
795: // If v.Kind() != Stream, Reader returns a ReadCloser that
205: return readXrefStream(r, b)
333: table[x] = xref{ptr: objptr{uint32(x), 0}, inStream: true, stream: objptr{uint32(v2), 0}, offset: int64(v3)}
718: if xref.ptr != ptr || !xref.inStream && xref.offset == 0 {
722: if xref.inStream {
805: rd = decryptStream(v.r.key, v.r.useAES, x.ptr, rd)
963: c.XORKeyStream(u, u)
969: c.XORKeyStream(u, u)
978: c.XORKeyStream(u, u)
1040: c.XORKeyStream(data, data)
1059: rd = &cipher.StreamReader{c, rd}
230: table, err := readXrefStreamData(r, strm, table, size)
262: if table, err = readXrefStreamData(r, prev.data.(stream), table, psize); err != nil {
315: HH_INLINE void Stream(const Scalar<T>& v, T* const HH_RESTRICT to) {
16: nassh.Stream = function(fd, path) {
25: nassh.Stream.ERR_STREAM_CLOSED = 'Stream closed';
26: nassh.Stream.ERR_STREAM_OPENED = 'Stream opened';
27: nassh.Stream.ERR_FD_IN_USE = 'File descriptor in use';
28: nassh.Stream.ERR_NOT_IMPLEMENTED = 'Not implemented';
29: nassh.Stream.ERR_STREAM_CANT_READ = 'Stream has no read permission';
30: nassh.Stream.ERR_STREAM_CANT_WRITE = 'Stream has no write permission';
35: nassh.Stream.prototype.asyncOpen_ = function(path, onOpen) {
42: nassh.Stream.prototype.asyncRead = function(size, onRead) {
43: throw nassh.Stream.ERR_NOT_IMPLEMENTED;
49: nassh.Stream.prototype.asyncWrite = function(data, onSuccess) {
50: throw nassh.Stream.ERR_NOT_IMPLEMENTED;
56: nassh.Stream.prototype.close = function(reason) {
64: nassh.Stream.prototype.setIo = function(io) {
73: nassh.Stream.Random = function(fd) {
74: nassh.Stream.apply(this, [fd]);
77: nassh.Stream.Random.prototype = Object.create(nassh.Stream.prototype);
78: nassh.Stream.Random.constructor = nassh.Stream.Random;
80: nassh.Stream.Random.prototype.asyncOpen_ = function(path, onOpen) {
85: nassh.Stream.Random.prototype.asyncRead = function(size, onRead) {
87: throw nassh.Stream.ERR_STREAM_CLOSED;
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: return newStream(ƒ)
70: return newStream(ƒ)
96: return newStream(ƒ)
4: type Stream struct {
9: func (s *Stream) Wait() error {
13: func (s *Stream) Close() {
17: func (s *Stream) IsClosed() bool {
4: type Stream struct {
11: func (s *Stream) Wait() error {
19: func (s *Stream) Close() {
26: func (s *Stream) IsClosed() bool {
334: FILE *Stream;
472: void PerfReader::readDataStream() {
115: FILE *Stream = fdopen(P[0], "r");
125: return Stream;
274: auto Stream = ForkAndExec(Cmd);
279: ssize_t Len = getline(&Line, &LineLen, Stream);
315: fclose(Stream);
342: : Objdump(Objdump), Stream(nullptr), Line(NULL), LineLen(0) {}
344: if (Stream) {
345: fclose(Stream);
354: if (Stream) {
355: fclose(Stream);
367: Stream = ForkAndExec(Cmd);
381: ssize_t Len = getline(&Line, &LineLen, Stream);
415: void readDataStream();
776: P.readDataStream();
805: P.readDataStream();
124: Stream = 1 // Not currently supported in the Unity Plugin.
78: class Stream {
39: typedef OutputStream_ OutputStream;
51: typedef LeftStream_ LeftStream;
52: typedef RightStream_ RightStream;
54: typedef OutputStream_ OutputStream;
92: class StreamUtil {
35: template <typename Kernel_, typename OutputStream_>
42: OutputStream output_stream;
45: template <typename InType_, typename OutType_, typename LeftStream_,
46: typename RightStream_, typename Kernel_, typename OutputStream_>
56: typedef FusedKernelParams<Kernel, OutputStream> FusedKernel;
71: LeftStream left_stream;
72: RightStream right_stream;
77: typename StreamParams>
80: static void Pack(const InType* in, const StreamParams& params, InType* out);
82: static int UnpackedAdvance(const StreamParams& params);
84: static int PackedAdvance(const StreamParams& params);
86: static int UnpackedStride(const StreamParams& params);
88: static int PackedStride(const StreamParams& params);
91: template <typename InType, typename StreamType>
94: static const InType* Offset(const StreamType& params, const InType* source,
97: static int Scratch(const StreamType& params, int lanes);
101: typename OutputStream, int kernel_m, int kernel_n, int pack_size>
105: const FusedKernelParams<Kernel, OutputStream>& params,
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: return newStream(ƒ)
70: return newStream(ƒ)
96: return newStream(ƒ)
17: class Stream
19: Stream(Stream&);
20: Stream& operator=(const Stream&);
23: virtual ~Stream();
47: virtual void Write(const Stream& stream,
58: explicit Stream(Context&);
29: virtual int EndOfStream() = 0;
29: class Stream
41: # @private Create an empty Subscriber::Stream object.
266: Google::Pubsub::V1::StreamingPullRequest.new.tap do |req|
69: Stream string
348: func (m *EventMetrics) GetEventStream(name string) *EventStream {
347: // GetEventStream returns an EventStream instance.
351: return &EventStream{
33: Stream bool
59: func (w fakeResponseWrapper) Stream() (io.ReadCloser, error) {
45: Stream(F::Item),
10: pub struct FlattenStream<F>
17: impl<F> fmt::Debug for FlattenStream<F>
52: impl<F> Stream for FlattenStream<F>
3: use stream::Stream;
12: <F as Future>::Item: Stream<Error=F::Error>,
19: <F as Future>::Item: Stream<Error=F::Error> + fmt::Debug,
30: <F as Future>::Item: Stream<Error=F::Error>,
40: <F as Future>::Item: Stream<Error=F::Error>,
44: // future resolved to Stream
54: <F as Future>::Item: Stream<Error=F::Error>,
56: type Item = <F::Item as Stream>::Item;
57: type Error = <F::Item as Stream>::Error;
72: (State::Stream(stream), None)
79: State::Stream(ref mut s) => {
22: fmt.debug_struct("FlattenStream")
28: pub fn new<F>(f: F) -> FlattenStream<F>
32: FlattenStream {
592: CTM.Stream = function(data) {
571: CTM.InterleavedStream = function(data, count) {
597: CTM.Stream.prototype.TWO_POW_MINUS23 = Math.pow(2, -23);
599: CTM.Stream.prototype.TWO_POW_MINUS126 = Math.pow(2, -126);
601: CTM.Stream.prototype.readByte = function() {
605: CTM.Stream.prototype.readInt32 = function() {
612: CTM.Stream.prototype.readFloat32 = function() {
635: CTM.Stream.prototype.readString = function() {
643: CTM.Stream.prototype.readArrayInt32 = function(array) {
653: CTM.Stream.prototype.readArrayFloat32 = function(array) {
225: var interleaved = new CTM.InterleavedStream(indices, 3);
235: var interleaved = new CTM.InterleavedStream(vertices, 1);
243: var interleaved = new CTM.InterleavedStream(normals, 3);
257: var interleaved = new CTM.InterleavedStream(uvMaps[i].uv, 2);
271: var interleaved = new CTM.InterleavedStream(attrMaps[i].attr, 4);
300: var interleaved = new CTM.InterleavedStream(vertices, 3);
314: var interleaved = new CTM.InterleavedStream(gridIndices, 1);
326: var interleaved = new CTM.InterleavedStream(indices, 3);
336: var interleaved = new CTM.InterleavedStream(body.normals, 3);
356: var interleaved = new CTM.InterleavedStream(uvMaps[i].uv, 2);
374: var interleaved = new CTM.InterleavedStream(attrMaps[i].attr, 4);
578: CTM.InterleavedStream.prototype.writeByte = function(value) {
14: type Stream interface {
33: type BitStream struct {
57: type EdgeStream struct {
13: // Stream is the interface to define a generic stream
39: // Resolution implement Stream.
47: // Duration implement Stream.
68: // Resolution implement Stream.
76: // Duration implement Stream.
93: Parts []Stream // Each part must be a BitStream, EdgeStream or Program
97: // Resolution implement Stream.
124: // Duration implement Stream.
139: var _ Stream = &BitStream{}
140: var _ Stream = &EdgeStream{}
141: var _ Stream = &Program{}
29: // BitStream is a stream of bits to be written or read.
40: func (b *BitStream) Resolution() time.Duration {
48: func (b *BitStream) Duration() time.Duration {
52: // EdgeStream is a stream of edges to be written.
54: // This struct is more efficient than BitStream for repetitive pulses, like
69: func (e *EdgeStream) Resolution() time.Duration {
77: func (e *EdgeStream) Duration() time.Duration {
15: } Stream;
17: static int create_sink(Stream *st, AVFilterGraph *graph,
28: av_log(NULL, AV_LOG_ERROR, "Stream type not supported\n");
48: Stream *streams = NULL, *st;
12: AVStream *stream;
429: Stream(Arc<UnsafeCell<stream::Packet<T>>>),
576: let rx = Receiver::new(Flavor::Stream(a.clone()));
595: Flavor::Stream(ref p) => return unsafe {
605: let tmp = Sender::new(Flavor::Stream(new_inner));
628: Flavor::Stream(ref p) => {
662: Flavor::Stream(ref mut p) => unsafe { (*p.get()).drop_chan(); },
772: Flavor::Stream(ref p) => {
873: Flavor::Stream(ref p) => {
952: Flavor::Stream(ref p) => {
1018: Flavor::Stream(ref p) => {
1048: Flavor::Stream(ref p) => {
1074: Flavor::Stream(ref p) => unsafe {
1137: Flavor::Stream(ref mut p) => unsafe { (*p.get()).drop_port(); },
140: // * Streams - these channels are optimized for the non-shared use case. They
50: class Stream(object):
149: class Stream(StreamEngine.Stream):
218: class Stream(StreamEngine.Stream):
277: class Stream(StreamEngine.Stream):
49: class StreamEngine(object):
69: class StepStream(Stream):
163: class StepStream(Stream):
229: class StepStream(Stream):
281: class StepStream(Stream):
296: class StreamEngineInvariants(StreamEngine):
311: class StepStream(StreamEngine.StepStream):
367: class LogStream(StreamEngine.Stream):
435: class StepStream(StreamEngine.StepStream):
494: class StepLogStream(StreamEngine.Stream):
506: class AllowSubannotationsStepStream(StepStream):
132: class ProductStreamEngine(StreamEngine):
199: class MultiStreamEngine(StreamEngine):
276: class NoopStreamEngine(StreamEngine):
390: class AnnotatorStreamEngine(StreamEngine):
16: Stream is a virtual well-behaved stream (associated with an Engine) which you
40: stream (StreamEngine.Stream): The stream to output to.
172: return ProductStreamEngine.Stream(
242: return MultiStreamEngine.Stream(*log_streams)
283: return NoopStreamEngine.Stream()
12: StreamEngine will coordinate the multiplexing of streams. In the case of
103: """Creates a new StepStream in this engine.
110: is to implement an annotations parser that converts to StreamEngine calls;
133: """A StreamEngine that forms the non-commutative product of two other
134: StreamEngines.
136: Because StreamEngine has no observations (i.e. it is an F-Algebra), we can
186: return self.StepStream(
200: """A StreamEngine consisting of one or more inner StreamEngines.
202: A call to this StreamEngine will be distributed to the inner StreamEngines.
257: return self.StepStream(
269: assert isinstance(se, StreamEngine)
293: return self.StepStream()
297: """Checks that the users are using a StreamEngine hygenically.
299: Multiply with actually functional StreamEngines so you don't have to check
313: super(StreamEngineInvariants.StepStream, self).__init__()
335: ret = self._engine.LogStream(self, log_name)
387: return self.StepStream(self, step_config.name)
437: super(AnnotatorStreamEngine.StepStream, self).__init__()
462: return self._engine.StepLogStream(self, log_name)
524: stream = self.AllowSubannotationsStepStream(self, outstream,
527: stream = self.StepStream(self, outstream, step_config.name)
307: """Returns (ProductStreamEngine): A product applying invariants to "other".
309: return ProductStreamEngine(cls(), other)
399: super(AnnotatorStreamEngine, self).open()
404: super(AnnotatorStreamEngine, self).close()
24: function Stream() {
20: function newStreamID() {
29: Stream.prototype = {
49: module.exports.Stream = Stream;
26: this.id = newStreamID();
182: Stream string
62: func NegotiateOutputStreamSerializer(req *http.Request, ns runtime.NegotiatedSerializer) (runtime.SerializerInfo, error) {
159: func (emptyEndpointRestrictions) AllowsStreamSchema(s string) bool { return s == "watch" }
233: options.Stream = v
35: if info.StreamSerializer != nil {
64: if !ok || mediaType.Accepted.Serializer.StreamSerializer == nil {
230: if len(v) > 0 && (accepts.Serializer.StreamSerializer == nil || !endpoint.AllowsStreamSchema(v)) {
148: // AllowsStreamSchema should return true if the specified stream schema is
150: AllowsStreamSchema(schema string) bool
29: type Stream interface {
28: // A Stream represents a stream cipher.
30: // XORKeyStream XORs each byte in the given slice with a byte from the
32: XORKeyStream(dst, src []byte)
33: stream.Stream = function(options) {};
40: stream.Stream.prototype.pipe;
113: stream.ReadableStream = function() {};
118: stream.ReadableStream.prototype.readable;
173: stream.WritableStream = function() {};
178: stream.WritableStream.prototype.drain;
45: * @extends stream.Stream
104: * @param {stream.Stream} stream
134: * @extends stream.Stream
124: stream.ReadableStream.prototype.setEncoding;
129: stream.ReadableStream.prototype.destroy;
183: stream.WritableStream.prototype.writable;
190: stream.WritableStream.prototype.write;
198: stream.WritableStream.prototype.end;
203: stream.WritableStream.prototype.destroy;
208: stream.WritableStream.prototype.destroySoon;
191: BitstreamCursor Stream;
190: std::unique_ptr<BitstreamReader> StreamFile;
3416: std::error_code BitcodeReader::InitStream() {
3441: std::error_code BitcodeReader::InitLazyStream() {
192: std::unique_ptr<DataStreamer> LazyStreamer;
3422: std::error_code BitcodeReader::InitStreamFromBuffer() {
838: if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
850: BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
865: switch (Stream.readRecord(Entry.ID, Record)) {
896: if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
913: BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
931: switch (Stream.readRecord(Entry.ID, Record)) {
1105: if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0))
1115: BitstreamCursor StartOfTypeBlockCursor(Stream);
1126: unsigned Code = Stream.ReadCode();
1138: Stream = StartOfTypeBlockCursor;
1142: if (Stream.ReadBlockEnd())
1149: Stream.ReadSubBlockID();
1150: if (Stream.SkipBlock())
1156: Stream.ReadAbbrevRecord();
1163: switch (Stream.readRecord(Code, Record)) {
1294: if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0))
1302: unsigned Code = Stream.ReadCode();
1304: if (Stream.ReadBlockEnd())
1311: Stream.ReadSubBlockID();
1312: if (Stream.SkipBlock())
1318: Stream.ReadAbbrevRecord();
1324: switch (Stream.readRecord(Code, Record)) {
1345: if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
1353: unsigned Code = Stream.ReadCode();
1355: if (Stream.ReadBlockEnd())
1361: Stream.ReadSubBlockID();
1362: if (Stream.SkipBlock())
1368: Stream.ReadAbbrevRecord();
1374: switch (Stream.readRecord(Code, Record)) {
1407: if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
1414: unsigned Code = Stream.ReadCode();
1416: if (Stream.ReadBlockEnd())
1423: Stream.ReadSubBlockID();
1424: if (Stream.SkipBlock())
1430: Stream.ReadAbbrevRecord();
1437: Code = Stream.readRecord(Code, Record);
1449: Code = Stream.ReadCode();
1452: unsigned NextBitCode = Stream.readRecord(Code, Record);
1626: if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
1635: BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1657: unsigned BitCode = Stream.readRecord(Entry.ID, Record);
1961: if (Stream.ReadBlockEnd())
1988: uint64_t CurBit = Stream.GetCurrentBitNo();
1992: if (Stream.SkipBlock())
2028: Stream.JumpToBit(NextUnreadBit);
2029: else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
2037: while (!Stream.AtEndOfStream()) {
2038: unsigned Code = Stream.ReadCode();
2040: if (Stream.ReadBlockEnd())
2073: switch (Stream.ReadSubBlockID()) {
2075: if (Stream.SkipBlock())
2079: if (Stream.ReadBlockInfoBlock())
2132: NextUnreadBit = Stream.GetCurrentBitNo();
2142: Stream.ReadAbbrevRecord();
2147: switch (Stream.readRecord(Code, Record)) {
2347: if (Stream.Read(8) != 'B' ||
2348: Stream.Read(8) != 'C' ||
2349: Stream.Read(4) != 0x0 ||
2350: Stream.Read(4) != 0xC ||
2351: Stream.Read(4) != 0xE ||
2352: Stream.Read(4) != 0xD)
2358: if (Stream.AtEndOfStream())
2362: Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
2373: if (Stream.ReadBlockInfoBlock())
2387: if (Stream.SkipBlock())
2398: if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 &&
2399: Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a &&
2400: Stream.AtEndOfStream())
2409: if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
2417: BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
2431: switch (Stream.readRecord(Entry.ID, Record)) {
2459: if (Stream.Read(8) != 'B' ||
2460: Stream.Read(8) != 'C' ||
2461: Stream.Read(4) != 0x0 ||
2462: Stream.Read(4) != 0xC ||
2463: Stream.Read(4) != 0xE ||
2464: Stream.Read(4) != 0xD)
2470: BitstreamEntry Entry = Stream.advance();
2483: if (Stream.SkipBlock())
2488: Stream.skipRecord(Entry.ID);
2496: if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
2501: BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
2516: switch (Stream.readRecord(Entry.ID, Record)) {
2543: if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
2563: unsigned Code = Stream.ReadCode();
2565: if (Stream.ReadBlockEnd())
2571: switch (Stream.ReadSubBlockID()) {
2573: if (Stream.SkipBlock())
2598: Stream.ReadAbbrevRecord();
2605: unsigned BitCode = Stream.readRecord(Code, Record);
3332: Stream.JumpToBit(DFII->second);
3436: Stream.init(&*StreamFile);
3448: Stream.init(&*StreamFile);
354: std::error_code InitStream();
356: std::error_code InitLazyStream();
2343: if (std::error_code EC = InitStream())
2455: if (std::error_code EC = InitStream())
3418: return InitLazyStream();
3435: StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
3444: auto OwnedBytes = llvm::make_unique<StreamingMemoryObject>(
3446: StreamingMemoryObject &Bytes = *OwnedBytes;
3447: StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
355: std::error_code InitStreamFromBuffer();
395: TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr),
2131: if (LazyStreamer && SeenValueSymbolTable) {
2299: if (LazyStreamer)
2383: if (LazyStreamer)
3417: if (LazyStreamer)
3419: return InitStreamFromBuffer();
3445: std::move(LazyStreamer));
1751: WORD Stream;