Analizo
view release on metacpan or search on metacpan
t/features/metrics_history_db.feature
t/features/module_file_mapping.feature
t/features/step_definitions/analizo_steps.pl
t/features/tree_evolution.feature
t/features/void-argument.feature
t/features/wrapper.feature
t/samples/abstract_class/csharp/Dog.cs
t/samples/abstract_class/csharp/FourLeggedAnimal.cs
t/samples/abstract_class/csharp/Program.cs
t/samples/abstract_class/java/AbstractDao.java
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp
t/samples/android-framework/android-5.1.1_r38/LICENSE.TXT
t/samples/android-framework/android-5.1.1_r38/MCLinker.cpp
t/samples/animals/cpp/Makefile
t/samples/animals/cpp/animal.h
t/samples/animals/cpp/cat.cc
t/samples/animals/cpp/cat.h
t/samples/animals/cpp/dog.cc
t/samples/animals/cpp/dog.h
t/samples/animals/cpp/main.cc
t/samples/animals/cpp/mammal.h
t/samples/animals/csharp/Animal.cs
t/samples/animals/csharp/Cat.cs
t/features/doxyparse.feature view on Meta::CPAN
Feature: doxyparse extractor external tool
As a Analizo developer
I want to guarantee that doxyparse deal with any source code
To provide reliability for Analizo users
Scenario: don't die parsing MCLinker.cpp from android 5.1.1
Given I am in t/samples/android-framework/android-5.1.1_r38
When I run "analizo metrics ."
Then the exit status must be 0
Scenario: don't duplicate YAML keys parsing AudioTrackShared.cpp from android 5.1.1
Given I am in t/samples/android-framework/android-5.1.1_r38
When I run "analizo metrics ."
Then analizo must not emit a warning matching "YAML_LOAD_WARN_DUPLICATE_KEY"
Scenario: don't abort parsing mlpack 3.0.0
Given I am in t/samples/mlpack-3.0.0
When I run "analizo metrics ."
Then analizo must not emit a warning matching "Aborted"
And the exit status must be 0
Scenario: don't die parsing kdelibs warning about unknown escape character
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
- https://android.googlesource.com/
Original file was copied from the tag android-5.1.1_r38 from Android git repository
and it is located on the path below.
- media/libmedia/AudioTrackShared.cpp
Link to the original file on git repository:
- https://android.googlesource.com/platform/frameworks/av/+/refs/tags/android-5.1.1_r38/media/libmedia/AudioTrackShared.cpp
*/
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
audio_track_cblk_t::audio_track_cblk_t()
: mServer(0), mFutex(0), mMinimum(0),
mVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY), mSampleRate(0), mSendLevel(0), mFlags(0)
{
memset(&u, 0, sizeof(u));
}
// ---------------------------------------------------------------------------
Proxy::Proxy(audio_track_cblk_t* cblk, void *buffers, size_t frameCount, size_t frameSize,
bool isOut, bool clientInServer)
: mCblk(cblk), mBuffers(buffers), mFrameCount(frameCount), mFrameSize(frameSize),
mFrameCountP2(roundup(frameCount)), mIsOut(isOut), mClientInServer(clientInServer),
mIsShutdown(false), mUnreleased(0)
{
}
// ---------------------------------------------------------------------------
ClientProxy::ClientProxy(audio_track_cblk_t* cblk, void *buffers, size_t frameCount,
size_t frameSize, bool isOut, bool clientInServer)
: Proxy(cblk, buffers, frameCount, frameSize, isOut, clientInServer), mEpoch(0)
{
}
const struct timespec ClientProxy::kForever = {INT_MAX /*tv_sec*/, 0 /*tv_nsec*/};
const struct timespec ClientProxy::kNonBlocking = {0 /*tv_sec*/, 0 /*tv_nsec*/};
#define MEASURE_NS 10000000 // attempt to provide accurate timeouts if requested >= MEASURE_NS
// To facilitate quicker recovery from server failure, this value limits the timeout per each futex
// wait. However it does not protect infinite timeouts. If defined to be zero, there is no limit.
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
status = DEAD_OBJECT;
goto end;
}
// check for obtainBuffer interrupted by client
if (!ignoreInitialPendingInterrupt && (flags & CBLK_INTERRUPT)) {
ALOGV("obtainBuffer() interrupted by client");
status = -EINTR;
goto end;
}
ignoreInitialPendingInterrupt = false;
// compute number of frames available to write (AudioTrack) or read (AudioRecord)
int32_t front;
int32_t rear;
if (mIsOut) {
// The barrier following the read of mFront is probably redundant.
// We're about to perform a conditional branch based on 'filled',
// which will force the processor to observe the read of mFront
// prior to allowing data writes starting at mRaw.
// However, the processor may support speculative execution,
// and be unable to undo speculative writes into shared memory.
// The barrier will prevent such speculative execution.
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
end:
if (requested == NULL) {
requested = &kNonBlocking;
}
return status;
}
// ---------------------------------------------------------------------------
StaticAudioTrackClientProxy::StaticAudioTrackClientProxy(audio_track_cblk_t* cblk, void *buffers,
size_t frameCount, size_t frameSize)
: AudioTrackClientProxy(cblk, buffers, frameCount, frameSize),
mMutator(&cblk->u.mStatic.mSingleStateQueue), mBufferPosition(0)
{
}
void StaticAudioTrackClientProxy::flush()
{
LOG_ALWAYS_FATAL("static flush");
}
void StaticAudioTrackClientProxy::setLoop(size_t loopStart, size_t loopEnd, int loopCount)
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
bufferPosition = mFrameCount;
}
} else {
bufferPosition = mBufferPosition;
}
return bufferPosition;
}
// ---------------------------------------------------------------------------
ServerProxy::ServerProxy(audio_track_cblk_t* cblk, void *buffers, size_t frameCount,
size_t frameSize, bool isOut, bool clientInServer)
: Proxy(cblk, buffers, frameCount, frameSize, isOut, clientInServer),
mAvailToClient(0), mFlush(0)
{
}
status_t ServerProxy::obtainBuffer(Buffer* buffer, bool ackFlush)
{
LOG_ALWAYS_FATAL_IF(buffer == NULL || buffer->mFrameCount == 0);
if (mIsShutdown) {
goto no_init;
}
{
audio_track_cblk_t* cblk = mCblk;
// compute number of frames available to write (AudioTrack) or read (AudioRecord),
// or use previous cached value from framesReady(), with added barrier if it omits.
int32_t front;
int32_t rear;
// See notes on barriers at ClientProxy::obtainBuffer()
if (mIsOut) {
int32_t flush = cblk->u.mStreaming.mFlush;
rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear);
front = cblk->u.mStreaming.mFront;
if (flush != mFlush) {
// effectively obtain then release whatever is in the buffer
size_t mask = (mFrameCountP2 << 1) - 1;
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
}
}
buffer->mFrameCount = 0;
buffer->mRaw = NULL;
buffer->mNonContig = 0;
}
// ---------------------------------------------------------------------------
size_t AudioTrackServerProxy::framesReady()
{
LOG_ALWAYS_FATAL_IF(!mIsOut);
if (mIsShutdown) {
return 0;
}
audio_track_cblk_t* cblk = mCblk;
int32_t flush = cblk->u.mStreaming.mFlush;
if (flush != mFlush) {
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
int32_t rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear);
ssize_t filled = rear - cblk->u.mStreaming.mFront;
// pipe should not already be overfull
if (!(0 <= filled && (size_t) filled <= mFrameCount)) {
ALOGE("Shared memory control block is corrupt (filled=%zd); shutting down", filled);
mIsShutdown = true;
return 0;
}
// cache this value for later use by obtainBuffer(), with added barrier
// and racy if called by normal mixer thread
// ignores flush(), so framesReady() may report a larger mFrameCount than obtainBuffer()
return filled;
}
bool AudioTrackServerProxy::setStreamEndDone() {
audio_track_cblk_t* cblk = mCblk;
bool old =
(android_atomic_or(CBLK_STREAM_END_DONE, &cblk->mFlags) & CBLK_STREAM_END_DONE) != 0;
if (!old) {
(void) syscall(__NR_futex, &cblk->mFutex, mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE,
1);
}
return old;
}
void AudioTrackServerProxy::tallyUnderrunFrames(uint32_t frameCount)
{
audio_track_cblk_t* cblk = mCblk;
cblk->u.mStreaming.mUnderrunFrames += frameCount;
// FIXME also wake futex so that underrun is noticed more quickly
(void) android_atomic_or(CBLK_UNDERRUN, &cblk->mFlags);
}
// ---------------------------------------------------------------------------
StaticAudioTrackServerProxy::StaticAudioTrackServerProxy(audio_track_cblk_t* cblk, void *buffers,
size_t frameCount, size_t frameSize)
: AudioTrackServerProxy(cblk, buffers, frameCount, frameSize),
mObserver(&cblk->u.mStatic.mSingleStateQueue), mPosition(0),
mFramesReadySafe(frameCount), mFramesReady(frameCount),
mFramesReadyIsCalledByMultipleThreads(false)
{
mState.mLoopStart = 0;
mState.mLoopEnd = 0;
mState.mLoopCount = 0;
}
void StaticAudioTrackServerProxy::framesReadyIsCalledByMultipleThreads()
{
mFramesReadyIsCalledByMultipleThreads = true;
}
size_t StaticAudioTrackServerProxy::framesReady()
{
// Can't call pollPosition() from multiple threads.
if (!mFramesReadyIsCalledByMultipleThreads) {
(void) pollPosition();
}
return mFramesReadySafe;
}
ssize_t StaticAudioTrackServerProxy::pollPosition()
{
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
if (loopStart < loopEnd && loopEnd <= mFrameCount &&
loopEnd - loopStart >= MIN_LOOP) {
// If the current position is greater than the end of the loop
// we "wrap" to the loop start. This might cause an audible pop.
if (position >= loopEnd) {
mPosition = position = loopStart;
}
if (state.mLoopCount == -1) {
mFramesReady = INT64_MAX;
} else {
// mFramesReady is 64 bits to handle the effective number of frames
// that the static audio track contains, including loops.
// TODO: Later consider fixing overflow, but does not seem needed now
// as will not overflow if loopStart and loopEnd are Java "ints".
mFramesReady = int64_t(state.mLoopCount) * (loopEnd - loopStart)
+ mFrameCount - mPosition;
}
mState = state;
valid = true;
}
}
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
buffer->mFrameCount = avail;
} else {
avail = wanted;
}
buffer->mRaw = &((char *) mBuffers)[position * mFrameSize];
} else {
avail = 0;
buffer->mFrameCount = 0;
buffer->mRaw = NULL;
}
// As mFramesReady is the total remaining frames in the static audio track,
// it is always larger or equal to avail.
LOG_ALWAYS_FATAL_IF(mFramesReady < avail);
buffer->mNonContig = mFramesReady == INT64_MAX ? SIZE_MAX : clampToSize(mFramesReady - avail);
mUnreleased = avail;
return NO_ERROR;
}
void StaticAudioTrackServerProxy::releaseBuffer(Buffer* buffer)
{
size_t stepCount = buffer->mFrameCount;
t/samples/android-framework/android-5.1.1_r38/AudioTrackShared.cpp view on Meta::CPAN
if (setFlags != 0) {
(void) android_atomic_or(setFlags, &cblk->mFlags);
// this would be a good place to wake a futex
}
buffer->mFrameCount = 0;
buffer->mRaw = NULL;
buffer->mNonContig = 0;
}
void StaticAudioTrackServerProxy::tallyUnderrunFrames(uint32_t frameCount __unused)
{
// Unlike AudioTrackServerProxy::tallyUnderrunFrames() used for streaming tracks,
// we don't have a location to count underrun frames. The underrun frame counter
// only exists in AudioTrackSharedStreaming. Fortunately, underruns are not
// possible for static buffer tracks other than at end of buffer, so this is not a loss.
// FIXME also wake futex so that underrun is noticed more quickly
(void) android_atomic_or(CBLK_UNDERRUN, &mCblk->mFlags);
}
// ---------------------------------------------------------------------------
} // namespace android
t/samples/android-framework/android-5.1.1_r38/MCLinker.cpp view on Meta::CPAN
- https://android.googlesource.com/
Original file was copied from the tag android-5.1.1_r38 from Android git repository
and it is located on the path below.
- lib/CodeGen/MCLinker.cpp
Link to the original file on git repository:
- https://android.googlesource.com/platform/frameworks/compile/mclinker/+/refs/tags/android-5.1.1_r38/lib/CodeGen/MCLinker.cpp
LICENSE:
- https://android.googlesource.com/platform/frameworks/compile/mclinker/+/refs/tags/android-5.1.1_r38/LICENSE.TXT
*/
//===- MCLinker.cpp -------------------------------------------------------===//
//
// The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
( run in 1.045 second using v1.01-cache-2.11-cpan-df04353d9ac )