hexsha
stringlengths 40
40
| size
int64 22
2.4M
| ext
stringclasses 5
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 3
260
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
78
| max_stars_repo_licenses
listlengths 1
9
| max_stars_count
float64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 3
260
| max_issues_repo_name
stringlengths 5
109
| max_issues_repo_head_hexsha
stringlengths 40
78
| max_issues_repo_licenses
listlengths 1
9
| max_issues_count
float64 1
67k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 3
260
| max_forks_repo_name
stringlengths 5
109
| max_forks_repo_head_hexsha
stringlengths 40
78
| max_forks_repo_licenses
listlengths 1
9
| max_forks_count
float64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 22
2.4M
| avg_line_length
float64 5
169k
| max_line_length
int64 5
786k
| alphanum_fraction
float64 0.06
0.95
| matches
listlengths 1
11
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9f7125d9eb36b7d2cad9ed0e199900ba1f416772
| 1,603
|
h
|
C
|
app/open-nsynth/src/InstrumentScreen.h
|
lefty71/open-nsynth-super
|
8b844f980de80c3856a0990b24654f02c3983993
|
[
"Apache-2.0"
] | 2,296
|
2018-03-13T14:35:32.000Z
|
2022-03-31T15:07:32.000Z
|
app/open-nsynth/src/InstrumentScreen.h
|
Majoras-Other-Mask/open-nsynth-super
|
aa1138c0c1effb0cccd86c13362f040397091be9
|
[
"Apache-2.0"
] | 88
|
2018-03-13T18:03:40.000Z
|
2022-01-16T18:07:55.000Z
|
app/open-nsynth/src/InstrumentScreen.h
|
Majoras-Other-Mask/open-nsynth-super
|
aa1138c0c1effb0cccd86c13362f040397091be9
|
[
"Apache-2.0"
] | 267
|
2018-03-13T15:42:11.000Z
|
2022-02-22T19:36:39.000Z
|
/*
Copyright 2017 Google Inc. All Rights Reserved.
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
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#pragma once
#include "ofMain.h"
#include "BaseScreen.h"
// Displays an intrument selection screen.
class InstrumentScreen : public BaseScreen{
public:
// Keeps information on a single instrument.
struct Instrument{
std::string name;
std::string display;
std::string abbr;
};
InstrumentScreen();
// Changes the current selection by the given amount.
// The instrument list is circular - wraps in both directions.
void update(int amt);
void draw(float elapsed) override;
const Instrument &getCurrent() const;
// The collection of instrument options.
std::vector<Instrument> instruments;
// The font to use for displaying names.
ofTrueTypeFont font;
// A frame buffer object used during drawing.
ofFbo fbo;
// The index of the current selection.
int idx = 0;
// The direction to scroll in, determined by the update amount.
int direction = 1;
// The current y position.
float y = 0;
// The amount y is being changed, used for smooth scrolling.
float velocity = 0;
};
| 30.245283
| 72
| 0.738615
|
[
"object",
"vector"
] |
9f72aa34719f5eafe03175cbe7afe5ddd402a93b
| 5,233
|
h
|
C
|
src/xamp_base/include/base/threadpool.h
|
billlin0904/xamp2
|
c11ada6138a5c8427523543bb7035f2ac2cff8d5
|
[
"MIT"
] | 2
|
2020-02-09T04:55:36.000Z
|
2022-01-08T08:50:50.000Z
|
src/xamp_base/include/base/threadpool.h
|
billlin0904/xamp2
|
c11ada6138a5c8427523543bb7035f2ac2cff8d5
|
[
"MIT"
] | 1
|
2022-02-16T10:14:05.000Z
|
2022-02-16T10:14:05.000Z
|
src/xamp_base/include/base/threadpool.h
|
billlin0904/xamp2
|
c11ada6138a5c8427523543bb7035f2ac2cff8d5
|
[
"MIT"
] | 2
|
2019-09-23T15:21:27.000Z
|
2021-04-12T09:00:37.000Z
|
//=====================================================================================================================
// Copyright (c) 2018-2021 xamp project. All rights reserved.
// More license information, please see LICENSE file in module root folder.
//=====================================================================================================================
#pragma once
#include <future>
#include <atomic>
#include <vector>
#include <optional>
#include <type_traits>
#include <memory>
#include <base/base.h>
#include <base/align_ptr.h>
#include <base/bounded_queue.h>
#ifdef XAMP_ENABLE_THREAD_POOL_DEBUG
#include <base/logger.h>
#endif
namespace xamp::base {
class TaskWrapper {
public:
template <typename Func>
TaskWrapper(Func&& f)
: impl_(MakeAlign<ImplBase, ImplType<Func>>(std::forward<Func>(f))) {
}
XAMP_ALWAYS_INLINE void operator()(int32_t thread_index) {
impl_->Call(thread_index);
}
#if defined(_DEBUG)
XAMP_ALWAYS_INLINE long long ExecutedTime() const noexcept {
return impl_->ExecutedTime();
}
#endif
TaskWrapper() = default;
TaskWrapper(TaskWrapper&& other) noexcept
: impl_(std::move(other.impl_)) {
}
TaskWrapper& operator=(TaskWrapper&& other) noexcept {
impl_ = std::move(other.impl_);
return *this;
}
XAMP_DISABLE_COPY(TaskWrapper)
private:
struct XAMP_NO_VTABLE ImplBase {
virtual ~ImplBase() = default;
virtual void Call(int32_t thread_index) = 0;
#if defined(_DEBUG)
virtual long long ExecutedTime() const noexcept = 0;
#endif
};
AlignPtr<ImplBase> impl_;
template <typename Func>
struct ImplType final : ImplBase {
ImplType(Func&& f)
: f_(std::forward<Func>(f)) {
}
#if 0 // defined(XAMP_ENABLE_THREAD_POOL_DEBUG) && defined(_DEBUG)
virtual ~ImplType() noexcept override {
XAMP_LOG_DEBUG("ImplType was deleted.");
}
#endif
XAMP_ALWAYS_INLINE void Call(int32_t thread_index) override {
f_(thread_index);
}
#if defined(_DEBUG)
static std::chrono::time_point<std::chrono::steady_clock> Now() noexcept {
return std::chrono::steady_clock::now();
}
long long ExecutedTime() const noexcept override {
const auto end = Now();
return std::chrono::duration_cast<std::chrono::milliseconds>(end - start_time_).count();
}
const std::chrono::time_point<std::chrono::steady_clock> start_time_ = Now();
#endif
Func f_;
};
};
using Task = TaskWrapper;
class XAMP_BASE_API TaskScheduler final {
public:
explicit TaskScheduler(size_t max_thread, int32_t affinity);
XAMP_DISABLE_COPY(TaskScheduler)
~TaskScheduler() noexcept;
void SubmitJob(Task&& task);
void SetAffinityMask(int32_t core);
void Destroy() noexcept;
size_t GetActiveThreadCount() const noexcept;
size_t GetThreadCount() const noexcept;
private:
static void SetWorkerThreadName(size_t i);
std::optional<Task> TryPopPoolQueue();
std::optional<Task> TryPopLocalQueue(size_t index);
std::optional<Task> TrySteal(size_t i);
void AddThread(size_t i);
using TaskQueue = BoundedQueue<Task, FastMutex, FastMutexConditionVariable>;
using SharedTaskQueuePtr = AlignPtr<TaskQueue>;
static constexpr size_t K = 4;
static constexpr size_t kInitL1CacheLineSize = 64 * 1024;
static constexpr size_t kMaxL1CacheLineSize = 256 * 1024;
std::atomic<bool> is_stopped_;
std::atomic<size_t> active_thread_;
int32_t affinity_;
size_t index_;
size_t max_thread_;
TaskQueue pool_queue_;
std::vector<std::thread> threads_;
std::vector<SharedTaskQueuePtr> shared_queues_;
std::shared_ptr<spdlog::logger> logger_;
};
class XAMP_BASE_API ThreadPool final {
public:
static ThreadPool& StreamReaderThreadPool();
static ThreadPool& WASAPIThreadPool();
static constexpr uint32_t kMaxThread = 32;
explicit ThreadPool(uint32_t max_thread = std::thread::hardware_concurrency(), int32_t affinity = kDefaultAffinityCpuCore);
~ThreadPool();
XAMP_DISABLE_COPY(ThreadPool)
template <typename F, typename... Args>
decltype(auto) Spawn(F&& f, Args&&... args);
size_t GetActiveThreadCount() const noexcept;
size_t GetThreadCount() const noexcept;
void Stop();
void SetAffinityMask(int32_t core);
private:
TaskScheduler scheduler_;
};
template <typename F, typename ... Args>
decltype(auto) ThreadPool::Spawn(F &&f, Args&&... args) {
using ReturnType = std::invoke_result_t<F, int32_t, Args...>;
// MSVC packaged_task can't be constructed from a move-only lambda
// https://github.com/microsoft/STL/issues/321
using PackagedTaskType = std::packaged_task<ReturnType(int32_t)>;
// std::apply not support std::placeholders
auto task = MakeAlignedShared<PackagedTaskType>(std::bind(std::forward<F>(f),
std::placeholders::_1,
std::forward<Args>(args)...));
auto future = task->get_future();
scheduler_.SubmitJob([task](int32_t thread_index) mutable {
(*task)(thread_index);
});
return future.share();
}
}
| 26.563452
| 127
| 0.649341
|
[
"vector"
] |
9f7970df7c851ff25c88c74724999bf594f714ea
| 1,276
|
h
|
C
|
tinydb/page.h
|
psyomn/sprawl
|
c330e51efdaec3f4e73d3fb8d44fe88533b04f3b
|
[
"Apache-2.0"
] | null | null | null |
tinydb/page.h
|
psyomn/sprawl
|
c330e51efdaec3f4e73d3fb8d44fe88533b04f3b
|
[
"Apache-2.0"
] | null | null | null |
tinydb/page.h
|
psyomn/sprawl
|
c330e51efdaec3f4e73d3fb8d44fe88533b04f3b
|
[
"Apache-2.0"
] | null | null | null |
/*
Copyright 2021 Simon (psyomn) Symeonidis
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
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#pragma once
#include <cstdint>
#include <vector>
#include <cstddef>
namespace psy::tinydb {
class Page {
public:
Page() :
data_(std::vector<std::uint8_t>(default_page_size_)),
cursor_(0),
write_offset_(0) {}
~Page() {}
void Write() noexcept;
std::size_t GetPageSize() const noexcept { return data_.capacity(); }
static std::size_t GetDefaultPageSize() noexcept { return Page::default_page_size_; }
private:
// might be better to ask the OS what a better page size is
static const std::size_t default_page_size_ = 4096;
std::vector<std::uint8_t> data_;
std::size_t cursor_;
std::size_t write_offset_;
};
}
| 28.355556
| 89
| 0.704545
|
[
"vector"
] |
9f79cdcde794c176d88a06cf164a0634f02527bf
| 669
|
h
|
C
|
src/utils/BuildingPlacer.h
|
kubivan/sc2-bot
|
461d21d061c2dfa8f05a2f2da13b83cf232ef973
|
[
"MIT"
] | null | null | null |
src/utils/BuildingPlacer.h
|
kubivan/sc2-bot
|
461d21d061c2dfa8f05a2f2da13b83cf232ef973
|
[
"MIT"
] | null | null | null |
src/utils/BuildingPlacer.h
|
kubivan/sc2-bot
|
461d21d061c2dfa8f05a2f2da13b83cf232ef973
|
[
"MIT"
] | null | null | null |
#pragma once
#include <sc2api/sc2_common.h>
#include <sc2api/sc2_typeenums.h>
#include <unordered_map>
#include <map>
#include <vector>
class SC2;
enum class PlacementHint
{
Default = 0,
WallOff,
Safe,
Proxy
};
namespace sc2::utils
{
class Map;
class BuildingPlacer
{
public:
BuildingPlacer(SC2& sc2);
void init(const Map& map);
Point2D placeBuilding(UNIT_TYPEID building, PlacementHint hint) const;
private:
Point2D fallback(UNIT_TYPEID building) const;
using Size = std::pair<int, int>;
mutable std::unordered_map<PlacementHint, std::map<Size, std::vector<Point2D>>> m_slots;
SC2& m_sc2;
};
} //sc2::utils
| 15.204545
| 92
| 0.689088
|
[
"vector"
] |
9f81324cd0e3c256279e2147703f28a2e1736ce7
| 1,384
|
h
|
C
|
nx/include/switch/display/buffer_producer.h
|
HookedBehemoth/libnx
|
747751b72e2c87b006e1ad5b4982ac2c1134cfa1
|
[
"0BSD"
] | 1,114
|
2017-09-17T01:31:40.000Z
|
2022-03-28T15:55:25.000Z
|
nx/include/switch/display/buffer_producer.h
|
HookedBehemoth/libnx
|
747751b72e2c87b006e1ad5b4982ac2c1134cfa1
|
[
"0BSD"
] | 307
|
2017-09-17T02:42:12.000Z
|
2022-03-30T00:03:15.000Z
|
nx/include/switch/display/buffer_producer.h
|
HookedBehemoth/libnx
|
747751b72e2c87b006e1ad5b4982ac2c1134cfa1
|
[
"0BSD"
] | 270
|
2017-09-17T06:13:13.000Z
|
2022-03-24T11:07:35.000Z
|
#pragma once
#include "types.h"
#include "binder.h"
#include "../nvidia/fence.h"
typedef struct {
s32 left;
s32 top;
s32 right;
s32 bottom;
} BqRect;
typedef struct {
struct { s64 timestamp; } PACKED;
s32 isAutoTimestamp;
BqRect crop;
s32 scalingMode;
u32 transform; // See the NATIVE_WINDOW_TRANSFORM_* enums.
u32 stickyTransform;
u32 unk;
u32 swapInterval;
NvMultiFence fence;
} BqBufferInput;
typedef struct {
u32 width;
u32 height;
u32 transformHint;
u32 numPendingBuffers;
} BqBufferOutput;
typedef struct {
u32 width;
u32 height;
u32 stride;
u32 format;
u32 usage;
NativeHandle* native_handle;
} BqGraphicBuffer;
Result bqRequestBuffer(Binder *b, s32 bufferIdx, BqGraphicBuffer *buf);
Result bqDequeueBuffer(Binder *b, bool async, u32 width, u32 height, s32 format, u32 usage, s32 *buf, NvMultiFence *fence);
Result bqDetachBuffer(Binder *b, s32 slot);
Result bqQueueBuffer(Binder *b, s32 buf, const BqBufferInput *input, BqBufferOutput *output);
Result bqCancelBuffer(Binder *b, s32 buf, const NvMultiFence *fence);
Result bqQuery(Binder *b, s32 what, s32* value);
Result bqConnect(Binder *b, s32 api, bool producerControlledByApp, BqBufferOutput *output);
Result bqDisconnect(Binder *b, s32 api);
Result bqSetPreallocatedBuffer(Binder *b, s32 buf, const BqGraphicBuffer *input);
| 27.68
| 123
| 0.722543
|
[
"transform"
] |
9f82cf006342dc97dc2260685a92cecf55f6b5f5
| 1,733
|
h
|
C
|
src/PathGenerator.h
|
mdevana/test_autodrive
|
eb0ef172317309420c35fbff7c0ee4a5453f9b3b
|
[
"MIT"
] | 1
|
2022-03-31T01:27:29.000Z
|
2022-03-31T01:27:29.000Z
|
src/PathGenerator.h
|
mdevana/PathPlanning_for_Autonomous_HighwayDrive
|
eb0ef172317309420c35fbff7c0ee4a5453f9b3b
|
[
"MIT"
] | null | null | null |
src/PathGenerator.h
|
mdevana/PathPlanning_for_Autonomous_HighwayDrive
|
eb0ef172317309420c35fbff7c0ee4a5453f9b3b
|
[
"MIT"
] | null | null | null |
#ifndef PathGenerator_H
#define PathGenerator_H
#include <vector>
#include "WayPoint.h"
#include "MapPath.h"
#include <string>
#include "Vehicle.h"
using std::vector;
class PathGenerator {
public:
/**
* Constructor
*/
PathGenerator();
/**
* Destructor.
*/
virtual ~PathGenerator();
void Init(double,MapPath);
vector<double> get_x_vals();
vector<double> get_y_vals();
void set_localization_data(double x,double y, double s, double d,double yaw,double speed);
void set_previous_path_data(const vector<double> &x,const vector<double> &y, double prev_s, double prev_d);
void generate_simple_path();
void generate_circular_path();
void generate_map_path();
void Execute_lane_change_with_JMT();
void generate_map_path_with_traffic(vector<vector<double>> sensor_fusion);
void generate_map_path_with_transform();
double car_x;
double car_y;
double car_s;
double car_d;
double car_yaw;
double car_speed;
vector<double> previous_path_x;
vector<double> previous_path_y;
double end_s;
double end_d;
//MapPath Map_Highway;
private:
vector<double> next_x_vals;
vector<double> next_y_vals;
double dist_inc;
double current_path_length;
double simulator_time_step = 0.02;// in seconds
double max_velocity = 50 * 1.6 * 1000 / 3600; // 50 miles / hr to m/s
double ref_velocity = max_velocity;
MapPath highway_map;
std::map<int, Vehicle> vehicles_in_road;
enum lanecode { left = 2, middle = 6, right = 10 };
vector<double> JMT(vector<double> &start, vector<double> &end, double T);
void copy_unexecuted_path();
void make_traffic_predictions(vector<vector<double>> sensor_fusion);
};
#endif // PathGenerator_H
| 21.6625
| 109
| 0.715522
|
[
"vector"
] |
9f85146db9aaf32e61875e095f57e87ce6947227
| 1,192
|
h
|
C
|
engine/src/bard/core/Base.h
|
baard047/bard_engine
|
595d5e35faf2f59a84a4f70e952caa8ca322093b
|
[
"Apache-2.0"
] | null | null | null |
engine/src/bard/core/Base.h
|
baard047/bard_engine
|
595d5e35faf2f59a84a4f70e952caa8ca322093b
|
[
"Apache-2.0"
] | null | null | null |
engine/src/bard/core/Base.h
|
baard047/bard_engine
|
595d5e35faf2f59a84a4f70e952caa8ca322093b
|
[
"Apache-2.0"
] | null | null | null |
/*
* \file Base.h
* \copyright (C) 2020 Special Technological Center Ltd
* \author : Bardashevsky A.K.
* \date : 27.12.2020
* \time : 13:22
*/
#pragma once
////temp
#include <string>
#include <cstdint>
#include <functional>
#include <memory>
#include <vector>
#include <cassert>
////
#include "logging/Logger.h"
#include <bard/auxiliary/Profiler.h>
#ifdef BARD_ENABLE_ASSERTS
#include <csignal>
//NOTE: only for linux for now, simply breaks debug with no sigterm
#define BARD_CORE_ASSERT( condition, msg ) { if( !condition ){ CORE_LOG_ERROR( "Assertion failed: {0}", msg ); raise(SIGTRAP);} }
#define BARD_ASSERT( condition, msg ) { if( !condition ){ LOG_ERROR( "Assertion failed: {0}", msg ); raise(SIGTRAP);} }
#else
#define BARD_ASSERT(...)
#define BARD_CORE_ASSERT(...)
#endif
#define BARD_CONDITION_ERROR( condition, msg, breakCondition ) \
if( condition ) \
{ \
CORE_LOG_ERROR( "Critical failure: {0}", msg ); \
assert(false); \
breakCondition; \
}
| 29.8
| 129
| 0.561242
|
[
"vector"
] |
9f981759ab36ea4ab74af61fe4bc656bbcc2250f
| 884
|
c
|
C
|
lib/wizards/manta/hill/room5.c
|
vlehtola/questmud
|
8bc3099b5ad00a9e0261faeb6637c76b521b6dbe
|
[
"MIT"
] | null | null | null |
lib/wizards/manta/hill/room5.c
|
vlehtola/questmud
|
8bc3099b5ad00a9e0261faeb6637c76b521b6dbe
|
[
"MIT"
] | null | null | null |
lib/wizards/manta/hill/room5.c
|
vlehtola/questmud
|
8bc3099b5ad00a9e0261faeb6637c76b521b6dbe
|
[
"MIT"
] | null | null | null |
#include "room.h"
#undef EXTRA_RESET
#define EXTRA_RESET\
extra_reset();
object monster6,monster7,monster8;
extra_reset() {
if(!monster6) {
monster6 = clone_object("/wizards/manta/castle/dem1.c");
move_object(monster6, this_object());
}
if(!monster7) {
monster7 = clone_object("/wizards/manta/castle/dem1.c");
move_object(monster7, this_object());
}
if(!monster8) {
monster8 = clone_object("/wizards/manta/castle/dem1.c");
move_object(monster8, this_object());
}
}
FOUR_EXIT("/wizards/manta/hill/room9.c", "north",
"/wizards/manta/hill/room4.c", "east",
"/wizards/manta/hill/room8.c", "south",
"/wizards/manta/hill/room12.c", "west",
"A small path",
"This is small path leading to fortress cooking facilities.\n", 3)
| 27.625
| 77
| 0.591629
|
[
"object"
] |
9f98b505ae5b807923f5125883cbcfd4c1a66bd5
| 8,843
|
h
|
C
|
ParaViewCore/ServerManager/vtkSMSession.h
|
XiaoboFu/ParaViewGeo
|
0089927885fd67a3d70a22a28977a291bed3fcdd
|
[
"BSD-2-Clause",
"BSD-3-Clause"
] | 17
|
2015-02-17T00:30:26.000Z
|
2022-03-17T06:13:02.000Z
|
ParaViewCore/ServerManager/vtkSMSession.h
|
aashish24/paraview-climate-3.11.1
|
c8ea429f56c10059dfa4450238b8f5bac3208d3a
|
[
"BSD-3-Clause"
] | null | null | null |
ParaViewCore/ServerManager/vtkSMSession.h
|
aashish24/paraview-climate-3.11.1
|
c8ea429f56c10059dfa4450238b8f5bac3208d3a
|
[
"BSD-3-Clause"
] | 10
|
2015-08-31T18:20:17.000Z
|
2022-02-02T15:16:21.000Z
|
/*=========================================================================
Program: ParaView
Module: $RCSfile$
Copyright (c) Kitware, Inc.
All rights reserved.
See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// .NAME vtkSMSession
// .SECTION Description
// vtkSMSession is the default ParaView session. This class can be used as the
// session for non-client-server configurations eg. builtin mode or batch.
#ifndef __vtkSMSession_h
#define __vtkSMSession_h
#include "vtkPVSessionBase.h"
#include "vtkSmartPointer.h" // needed for vtkSmartPointer.
class vtkSMPluginManager;
class vtkSMUndoStackBuilder;
class vtkSMStateLocator;
class vtkProcessModuleAutoMPI;
class VTK_EXPORT vtkSMSession : public vtkPVSessionBase
{
public:
static vtkSMSession* New();
vtkTypeMacro(vtkSMSession, vtkPVSessionBase);
void PrintSelf(ostream& os, vtkIndent indent);
//---------------------------------------------------------------------------
// API for client-side components of a session.
//---------------------------------------------------------------------------
// Description:
// Return the URL that define where the session is connected to. URI has
// enough information to know the type of connection, server hosts and ports.
virtual const char* GetURI() { return "builtin:"; }
// Description:
// Returns the vtkSMPluginManager attached to this session.
vtkGetObjectMacro(PluginManager, vtkSMPluginManager);
// Description:
// Returns the number of processes on the given server/s. If more than 1
// server is identified, than it returns the maximum number of processes e.g.
// is servers = DATA_SERVER | RENDER_SERVER and there are 3 data-server nodes
// and 2 render-server nodes, then this method will return 3.
// Implementation provided simply returns the number of local processes.
virtual int GetNumberOfProcesses(vtkTypeUInt32 servers);
// Description:
// Provides a unique identifier across processes of that session. Default
// implementation simply uses a local variable to keep track of ids already
// assigned.
virtual vtkTypeUInt32 GetNextGlobalUniqueIdentifier()
{
this->LastGUID++;
return this->LastGUID;
}
enum RenderingMode
{
RENDERING_NOT_AVAILABLE = 0x00,
RENDERING_UNIFIED = 0x01,
RENDERING_SPLIT = 0x02
};
// Description:
// Convenient method to determine if the rendering is done in a pvrenderer
// or not.
// For built-in or pvserver you will get RENDERING_UNIFIED and for a setting
// with a pvrenderer you will get RENDERING_SPLIT.
// If the session is something else it should reply RENDERING_NOT_AVAILABLE.
virtual unsigned int GetRenderClientMode();
//---------------------------------------------------------------------------
// Undo/Redo related API.
//---------------------------------------------------------------------------
// Description:
// Allow the user to bind an UndoStackBuilder with the given session
virtual void SetUndoStackBuilder(vtkSMUndoStackBuilder*);
vtkGetObjectMacro(UndoStackBuilder, vtkSMUndoStackBuilder);
// Description:
// Flag used to disable state caching needed for undo/redo. This overcome the
// presence of undo stack builder in the session.
vtkBooleanMacro(StateManagement, bool);
vtkSetMacro(StateManagement, bool);
vtkGetMacro(StateManagement, bool);
// Description:
// Provide an access to the session state locator that can provide the last
// state of a given remote object that have been pushed.
// That locator will be filled by RemoteObject state only if
// StateManagement is set to true.
vtkGetObjectMacro(StateLocator, vtkSMStateLocator);
//---------------------------------------------------------------------------
// Superclass Implementations
//---------------------------------------------------------------------------
// Description:
// Builtin session is always alive.
virtual bool GetIsAlive() { return true; }
// Description:
// Returns a ServerFlags indicate the nature of the current processes. e.g. if
// the current processes acts as a data-server and a render-server, it returns
// DATA_SERVER | RENDER_SERVER.
// The implementation provided by this class returns
// vtkPVSession::CLIENT_AND_SERVERS suitable for builtin-mode.
virtual ServerFlags GetProcessRoles();
//BTX
// Description:
// Push the state message. Overridden to ensure that the information in the
// undo-redo state manager is updated.
virtual void PushState(vtkSMMessage* msg);
//ETX
//---------------------------------------------------------------------------
// Static methods to create and register sessions easily.
//---------------------------------------------------------------------------
// Description:
// These are static helper methods that help create standard ParaView
// sessions. They register the session with the process module and return the
// session id. Returns 0 on failure.
// This overload is used to create a built-in session.
static vtkIdType ConnectToSelf();
// Description:
// These are static helper methods that help create standard ParaView
// sessions. They register the session with the process module and return the
// session id. Returns 0 on failure.
// This overload is used to create a client-server session on client.
static vtkIdType ConnectToRemote(const char* hostname, int port);
// Description:
// Same as ConnectToRemote() except that it waits for a reverse connection.
// This is a blocking call. One can optionally provide a callback that can be
// called periodically while this call is blocked.
// The callback should return true, if the connection should continue waiting,
// else return false to abort the wait.
static vtkIdType ReverseConnectToRemote(int port)
{ return vtkSMSession::ReverseConnectToRemote(port, (bool (*)()) NULL); }
static vtkIdType ReverseConnectToRemote(int port, bool (*callback)());
// Description:
// These are static helper methods that help create standard ParaView
// sessions. They register the session with the process module and return the
// session id. Returns 0 on failure.
// This overload is used to create a client-dataserver-renderserver session on
// client.
static vtkIdType ConnectToRemote(const char* dshost, int dsport,
const char* rshost, int rsport);
// Description:
// Same as ConnectToRemote() except that it waits for a reverse connection.
// This is a blocking call. One can optionally provide a callback that can be
// called periodically while this call is blocked.
// The callback should return true, if the connection should continue waiting,
// else return false to abort the wait.
static vtkIdType ReverseConnectToRemote(int dsport, int rsport)
{ return vtkSMSession::ReverseConnectToRemote(dsport, rsport, NULL); }
static vtkIdType ReverseConnectToRemote(int dsport, int rsport, bool (*callback)());
// Description:
// This flag if set indicates that the current session
// module has automatically started "pvservers" as MPI processes as
// default pipeline.
vtkGetMacro(IsAutoMPI, bool);
//BTX
protected:
// Subclasses should set initialize_during_constructor to false so that
// this->Initialize() is not called in constructor but only after the session
// has been created/setup correctly.
vtkSMSession(bool initialize_during_constructor=true);
~vtkSMSession();
// Used by the Auto-MPI to prevent remote rendering, otherwise we should
// always allow it.
static vtkIdType ConnectToRemote(const char* hostname, int port,
bool allowRemoteRendering);
// Description:
// Initialize various internal classes after the session has been setup
// correctly.
virtual void Initialize();
// Description:
// This method has been externalized so classes that heritate from vtkSMSession
// and override PushState could easily keep track of the StateHistory and
// maintain the UndoRedo mecanisme.
void UpdateStateHistory(vtkSMMessage* msg);
vtkSMUndoStackBuilder* UndoStackBuilder;
vtkSMPluginManager* PluginManager;
vtkSMStateLocator* StateLocator;
bool StateManagement;
// GlobalID managed locally
vtkTypeUInt32 LastGUID;
bool IsAutoMPI;
private:
vtkSMSession(const vtkSMSession&); // Not implemented
void operator=(const vtkSMSession&); // Not implemented
// AutoMPI helper class
static vtkSmartPointer<vtkProcessModuleAutoMPI> AutoMPI;
//ETX
};
#endif
| 38.785088
| 86
| 0.683252
|
[
"render",
"object"
] |
9f9fdb34a79d57e1d9d0005da95c3e84557a0195
| 25,946
|
h
|
C
|
dep/openal-soft/include/AL/al.h
|
wesleyParriott/astera
|
53e09f78a522d89d1e05f8b1b0266ab843425ef7
|
[
"MIT"
] | null | null | null |
dep/openal-soft/include/AL/al.h
|
wesleyParriott/astera
|
53e09f78a522d89d1e05f8b1b0266ab843425ef7
|
[
"MIT"
] | null | null | null |
dep/openal-soft/include/AL/al.h
|
wesleyParriott/astera
|
53e09f78a522d89d1e05f8b1b0266ab843425ef7
|
[
"MIT"
] | 1
|
2021-07-05T17:48:40.000Z
|
2021-07-05T17:48:40.000Z
|
#ifndef AL_AL_H
#define AL_AL_H
#if defined(__cplusplus)
extern "C" {
#endif
#ifndef AL_API
#if defined(AL_LIBTYPE_STATIC)
#define AL_API
#elif defined(_WIN32)
#define AL_API __declspec(dllimport)
#else
#define AL_API extern
#endif
#endif
#if defined(_WIN32)
#define AL_APIENTRY __cdecl
#else
#define AL_APIENTRY
#endif
/** Deprecated macro. */
#define OPENAL
#define ALAPI AL_API
#define ALAPIENTRY AL_APIENTRY
#define AL_INVALID (-1)
#define AL_ILLEGAL_ENUM AL_INVALID_ENUM
#define AL_ILLEGAL_COMMAND AL_INVALID_OPERATION
/** Supported AL version. */
#define AL_VERSION_1_0
#define AL_VERSION_1_1
/** 8-bit boolean */
typedef char ALboolean;
/** character */
typedef char ALchar;
/** signed 8-bit 2's complement integer */
typedef signed char ALbyte;
/** unsigned 8-bit integer */
typedef unsigned char ALubyte;
/** signed 16-bit 2's complement integer */
typedef short ALshort;
/** unsigned 16-bit integer */
typedef unsigned short ALushort;
/** signed 32-bit 2's complement integer */
typedef int ALint;
/** unsigned 32-bit integer */
typedef unsigned int ALuint;
/** non-negative 32-bit binary integer size */
typedef int ALsizei;
/** enumerated 32-bit value */
typedef int ALenum;
/** 32-bit IEEE754 floating-point */
typedef float ALfloat;
/** 64-bit IEEE754 floating-point */
typedef double ALdouble;
/** void type (for opaque pointers only) */
typedef void ALvoid;
/* Enumerant values begin at column 50. No tabs. */
/** "no distance model" or "no buffer" */
#define AL_NONE 0
/** Boolean False. */
#define AL_FALSE 0
/** Boolean True. */
#define AL_TRUE 1
/**
* Relative source.
* Type: ALboolean
* Range: [AL_TRUE, AL_FALSE]
* Default: AL_FALSE
*
* Specifies if the Source has relative coordinates.
*/
#define AL_SOURCE_RELATIVE 0x202
/**
* Inner cone angle, in degrees.
* Type: ALint, ALfloat
* Range: [0 - 360]
* Default: 360
*
* The angle covered by the inner cone, where the source will not attenuate.
*/
#define AL_CONE_INNER_ANGLE 0x1001
/**
* Outer cone angle, in degrees.
* Range: [0 - 360]
* Default: 360
*
* The angle covered by the outer cone, where the source will be fully
* attenuated.
*/
#define AL_CONE_OUTER_ANGLE 0x1002
/**
* Source pitch.
* Type: ALfloat
* Range: [0.5 - 2.0]
* Default: 1.0
*
* A multiplier for the frequency (sample rate) of the source's buffer.
*/
#define AL_PITCH 0x1003
/**
* Source or listener position.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* The source or listener location in three dimensional space.
*
* OpenAL, like OpenGL, uses a right handed coordinate system, where in a
* frontal default view X (thumb) points right, Y points up (index finger), and
* Z points towards the viewer/camera (middle finger).
*
* To switch from a left handed coordinate system, flip the sign on the Z
* coordinate.
*/
#define AL_POSITION 0x1004
/**
* Source direction.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* Specifies the current direction in local space.
* A zero-length vector specifies an omni-directional source (cone is ignored).
*/
#define AL_DIRECTION 0x1005
/**
* Source or listener velocity.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* Specifies the current velocity in local space.
*/
#define AL_VELOCITY 0x1006
/**
* Source looping.
* Type: ALboolean
* Range: [AL_TRUE, AL_FALSE]
* Default: AL_FALSE
*
* Specifies whether source is looping.
*/
#define AL_LOOPING 0x1007
/**
* Source buffer.
* Type: ALuint
* Range: any valid Buffer.
*
* Specifies the buffer to provide sound samples.
*/
#define AL_BUFFER 0x1009
/**
* Source or listener gain.
* Type: ALfloat
* Range: [0.0 - ]
*
* A value of 1.0 means unattenuated. Each division by 2 equals an attenuation
* of about -6dB. Each multiplicaton by 2 equals an amplification of about
* +6dB.
*
* A value of 0.0 is meaningless with respect to a logarithmic scale; it is
* silent.
*/
#define AL_GAIN 0x100A
/**
* Minimum source gain.
* Type: ALfloat
* Range: [0.0 - 1.0]
*
* The minimum gain allowed for a source, after distance and cone attenation is
* applied (if applicable).
*/
#define AL_MIN_GAIN 0x100D
/**
* Maximum source gain.
* Type: ALfloat
* Range: [0.0 - 1.0]
*
* The maximum gain allowed for a source, after distance and cone attenation is
* applied (if applicable).
*/
#define AL_MAX_GAIN 0x100E
/**
* Listener orientation.
* Type: ALfloat[6]
* Default: {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}
*
* Effectively two three dimensional vectors. The first vector is the front (or
* "at") and the second is the top (or "up").
*
* Both vectors are in local space.
*/
#define AL_ORIENTATION 0x100F
/**
* Source state (query only).
* Type: ALint
* Range: [AL_INITIAL, AL_PLAYING, AL_PAUSED, AL_STOPPED]
*/
#define AL_SOURCE_STATE 0x1010
/** Source state value. */
#define AL_INITIAL 0x1011
#define AL_PLAYING 0x1012
#define AL_PAUSED 0x1013
#define AL_STOPPED 0x1014
/**
* Source Buffer Queue size (query only).
* Type: ALint
*
* The number of buffers queued using alSourceQueueBuffers, minus the buffers
* removed with alSourceUnqueueBuffers.
*/
#define AL_BUFFERS_QUEUED 0x1015
/**
* Source Buffer Queue processed count (query only).
* Type: ALint
*
* The number of queued buffers that have been fully processed, and can be
* removed with alSourceUnqueueBuffers.
*
* Looping sources will never fully process buffers because they will be set to
* play again for when the source loops.
*/
#define AL_BUFFERS_PROCESSED 0x1016
/**
* Source reference distance.
* Type: ALfloat
* Range: [0.0 - ]
* Default: 1.0
*
* The distance in units that no attenuation occurs.
*
* At 0.0, no distance attenuation ever occurs on non-linear attenuation models.
*/
#define AL_REFERENCE_DISTANCE 0x1020
/**
* Source rolloff factor.
* Type: ALfloat
* Range: [0.0 - ]
* Default: 1.0
*
* Multiplier to exaggerate or diminish distance attenuation.
*
* At 0.0, no distance attenuation ever occurs.
*/
#define AL_ROLLOFF_FACTOR 0x1021
/**
* Outer cone gain.
* Type: ALfloat
* Range: [0.0 - 1.0]
* Default: 0.0
*
* The gain attenuation applied when the listener is outside of the source's
* outer cone.
*/
#define AL_CONE_OUTER_GAIN 0x1022
/**
* Source maximum distance.
* Type: ALfloat
* Range: [0.0 - ]
* Default: +inf
*
* The distance above which the source is not attenuated any further with a
* clamped distance model, or where attenuation reaches 0.0 gain for linear
* distance models with a default rolloff factor.
*/
#define AL_MAX_DISTANCE 0x1023
/** Source buffer position, in seconds */
#define AL_SEC_OFFSET 0x1024
/** Source buffer position, in sample frames */
#define AL_SAMPLE_OFFSET 0x1025
/** Source buffer position, in bytes */
#define AL_BYTE_OFFSET 0x1026
/**
* Source type (query only).
* Type: ALint
* Range: [AL_STATIC, AL_STREAMING, AL_UNDETERMINED]
*
* A Source is Static if a Buffer has been attached using AL_BUFFER.
*
* A Source is Streaming if one or more Buffers have been attached using
* alSourceQueueBuffers.
*
* A Source is Undetermined when it has the NULL buffer attached using
* AL_BUFFER.
*/
#define AL_SOURCE_TYPE 0x1027
/** Source type value. */
#define AL_STATIC 0x1028
#define AL_STREAMING 0x1029
#define AL_UNDETERMINED 0x1030
/** Buffer format specifier. */
#define AL_FORMAT_MONO8 0x1100
#define AL_FORMAT_MONO16 0x1101
#define AL_FORMAT_STEREO8 0x1102
#define AL_FORMAT_STEREO16 0x1103
/** Buffer frequency (query only). */
#define AL_FREQUENCY 0x2001
/** Buffer bits per sample (query only). */
#define AL_BITS 0x2002
/** Buffer channel count (query only). */
#define AL_CHANNELS 0x2003
/** Buffer data size (query only). */
#define AL_SIZE 0x2004
/**
* Buffer state.
*
* Not for public use.
*/
#define AL_UNUSED 0x2010
#define AL_PENDING 0x2011
#define AL_PROCESSED 0x2012
/** No error. */
#define AL_NO_ERROR 0
/** Invalid name paramater passed to AL call. */
#define AL_INVALID_NAME 0xA001
/** Invalid enum parameter passed to AL call. */
#define AL_INVALID_ENUM 0xA002
/** Invalid value parameter passed to AL call. */
#define AL_INVALID_VALUE 0xA003
/** Illegal AL call. */
#define AL_INVALID_OPERATION 0xA004
/** Not enough memory. */
#define AL_OUT_OF_MEMORY 0xA005
/** Context string: Vendor ID. */
#define AL_VENDOR 0xB001
/** Context string: Version. */
#define AL_VERSION 0xB002
/** Context string: Renderer ID. */
#define AL_RENDERER 0xB003
/** Context string: Space-separated extension list. */
#define AL_EXTENSIONS 0xB004
/**
* Doppler scale.
* Type: ALfloat
* Range: [0.0 - ]
* Default: 1.0
*
* Scale for source and listener velocities.
*/
#define AL_DOPPLER_FACTOR 0xC000
AL_API void AL_APIENTRY alDopplerFactor(ALfloat value);
/**
* Doppler velocity (deprecated).
*
* A multiplier applied to the Speed of Sound.
*/
#define AL_DOPPLER_VELOCITY 0xC001
AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value);
/**
* Speed of Sound, in units per second.
* Type: ALfloat
* Range: [0.0001 - ]
* Default: 343.3
*
* The speed at which sound waves are assumed to travel, when calculating the
* doppler effect.
*/
#define AL_SPEED_OF_SOUND 0xC003
AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value);
/**
* Distance attenuation model.
* Type: ALint
* Range: [AL_NONE, AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED,
* AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED,
* AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED]
* Default: AL_INVERSE_DISTANCE_CLAMPED
*
* The model by which sources attenuate with distance.
*
* None - No distance attenuation.
* Inverse - Doubling the distance halves the source gain.
* Linear - Linear gain scaling between the reference and max distances.
* Exponent - Exponential gain dropoff.
*
* Clamped variations work like the non-clamped counterparts, except the
* distance calculated is clamped between the reference and max distances.
*/
#define AL_DISTANCE_MODEL 0xD000
AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel);
/** Distance model value. */
#define AL_INVERSE_DISTANCE 0xD001
#define AL_INVERSE_DISTANCE_CLAMPED 0xD002
#define AL_LINEAR_DISTANCE 0xD003
#define AL_LINEAR_DISTANCE_CLAMPED 0xD004
#define AL_EXPONENT_DISTANCE 0xD005
#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006
/** Renderer State management. */
AL_API void AL_APIENTRY alEnable(ALenum capability);
AL_API void AL_APIENTRY alDisable(ALenum capability);
AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability);
/** State retrieval. */
AL_API const ALchar* AL_APIENTRY alGetString(ALenum param);
AL_API void AL_APIENTRY alGetBooleanv(ALenum param, ALboolean* values);
AL_API void AL_APIENTRY alGetIntegerv(ALenum param, ALint* values);
AL_API void AL_APIENTRY alGetFloatv(ALenum param, ALfloat* values);
AL_API void AL_APIENTRY alGetDoublev(ALenum param, ALdouble* values);
AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum param);
AL_API ALint AL_APIENTRY alGetInteger(ALenum param);
AL_API ALfloat AL_APIENTRY alGetFloat(ALenum param);
AL_API ALdouble AL_APIENTRY alGetDouble(ALenum param);
/**
* Error retrieval.
*
* Obtain the first error generated in the AL context since the last check.
*/
AL_API ALenum AL_APIENTRY alGetError(void);
/**
* Extension support.
*
* Query for the presence of an extension, and obtain any appropriate function
* pointers and enum values.
*/
AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar* extname);
AL_API void* AL_APIENTRY alGetProcAddress(const ALchar* fname);
AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar* ename);
/** Set Listener parameters */
AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value);
AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1,
ALfloat value2, ALfloat value3);
AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat* values);
AL_API void AL_APIENTRY alListeneri(ALenum param, ALint value);
AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2,
ALint value3);
AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint* values);
/** Get Listener parameters */
AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat* value);
AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat* value1,
ALfloat* value2, ALfloat* value3);
AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat* values);
AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint* value);
AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint* value1,
ALint* value2, ALint* value3);
AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint* values);
/** Create Source objects. */
AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint* sources);
/** Delete Source objects. */
AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint* sources);
/** Verify a handle is a valid Source. */
AL_API ALboolean AL_APIENTRY alIsSource(ALuint source);
/** Set Source parameters. */
AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value);
AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1,
ALfloat value2, ALfloat value3);
AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param,
const ALfloat* values);
AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value);
AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1,
ALint value2, ALint value3);
AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param,
const ALint* values);
/** Get Source parameters. */
AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param,
ALfloat* value);
AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param,
ALfloat* value1, ALfloat* value2,
ALfloat* value3);
AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param,
ALfloat* values);
AL_API void AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint* value);
AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param,
ALint* value1, ALint* value2,
ALint* value3);
AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum param,
ALint* values);
/** Play, replay, or resume (if paused) a list of Sources */
AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint* sources);
/** Stop a list of Sources */
AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint* sources);
/** Rewind a list of Sources */
AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint* sources);
/** Pause a list of Sources */
AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint* sources);
/** Play, replay, or resume a Source */
AL_API void AL_APIENTRY alSourcePlay(ALuint source);
/** Stop a Source */
AL_API void AL_APIENTRY alSourceStop(ALuint source);
/** Rewind a Source (set playback postiton to beginning) */
AL_API void AL_APIENTRY alSourceRewind(ALuint source);
/** Pause a Source */
AL_API void AL_APIENTRY alSourcePause(ALuint source);
/** Queue buffers onto a source */
AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb,
const ALuint* buffers);
/** Unqueue processed buffers from a source */
AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb,
ALuint* buffers);
/** Create Buffer objects */
AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint* buffers);
/** Delete Buffer objects */
AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint* buffers);
/** Verify a handle is a valid Buffer */
AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer);
/** Specifies the data to be copied into a buffer */
AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format,
const ALvoid* data, ALsizei size,
ALsizei freq);
/** Set Buffer parameters, */
AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat value);
AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat value1,
ALfloat value2, ALfloat value3);
AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param,
const ALfloat* values);
AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value);
AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint value1,
ALint value2, ALint value3);
AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param,
const ALint* values);
/** Get Buffer parameters. */
AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param,
ALfloat* value);
AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param,
ALfloat* value1, ALfloat* value2,
ALfloat* value3);
AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param,
ALfloat* values);
AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint* value);
AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param,
ALint* value1, ALint* value2,
ALint* value3);
AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param,
ALint* values);
/** Pointer-to-function type, useful for dynamically getting AL entry points. */
typedef void(AL_APIENTRY* LPALENABLE)(ALenum capability);
typedef void(AL_APIENTRY* LPALDISABLE)(ALenum capability);
typedef ALboolean(AL_APIENTRY* LPALISENABLED)(ALenum capability);
typedef const ALchar*(AL_APIENTRY* LPALGETSTRING)(ALenum param);
typedef void(AL_APIENTRY* LPALGETBOOLEANV)(ALenum param, ALboolean* values);
typedef void(AL_APIENTRY* LPALGETINTEGERV)(ALenum param, ALint* values);
typedef void(AL_APIENTRY* LPALGETFLOATV)(ALenum param, ALfloat* values);
typedef void(AL_APIENTRY* LPALGETDOUBLEV)(ALenum param, ALdouble* values);
typedef ALboolean(AL_APIENTRY* LPALGETBOOLEAN)(ALenum param);
typedef ALint(AL_APIENTRY* LPALGETINTEGER)(ALenum param);
typedef ALfloat(AL_APIENTRY* LPALGETFLOAT)(ALenum param);
typedef ALdouble(AL_APIENTRY* LPALGETDOUBLE)(ALenum param);
typedef ALenum(AL_APIENTRY* LPALGETERROR)(void);
typedef ALboolean(AL_APIENTRY* LPALISEXTENSIONPRESENT)(const ALchar* extname);
typedef void*(AL_APIENTRY* LPALGETPROCADDRESS)(const ALchar* fname);
typedef ALenum(AL_APIENTRY* LPALGETENUMVALUE)(const ALchar* ename);
typedef void(AL_APIENTRY* LPALLISTENERF)(ALenum param, ALfloat value);
typedef void(AL_APIENTRY* LPALLISTENER3F)(ALenum param, ALfloat value1,
ALfloat value2, ALfloat value3);
typedef void(AL_APIENTRY* LPALLISTENERFV)(ALenum param, const ALfloat* values);
typedef void(AL_APIENTRY* LPALLISTENERI)(ALenum param, ALint value);
typedef void(AL_APIENTRY* LPALLISTENER3I)(ALenum param, ALint value1,
ALint value2, ALint value3);
typedef void(AL_APIENTRY* LPALLISTENERIV)(ALenum param, const ALint* values);
typedef void(AL_APIENTRY* LPALGETLISTENERF)(ALenum param, ALfloat* value);
typedef void(AL_APIENTRY* LPALGETLISTENER3F)(ALenum param, ALfloat* value1,
ALfloat* value2, ALfloat* value3);
typedef void(AL_APIENTRY* LPALGETLISTENERFV)(ALenum param, ALfloat* values);
typedef void(AL_APIENTRY* LPALGETLISTENERI)(ALenum param, ALint* value);
typedef void(AL_APIENTRY* LPALGETLISTENER3I)(ALenum param, ALint* value1,
ALint* value2, ALint* value3);
typedef void(AL_APIENTRY* LPALGETLISTENERIV)(ALenum param, ALint* values);
typedef void(AL_APIENTRY* LPALGENSOURCES)(ALsizei n, ALuint* sources);
typedef void(AL_APIENTRY* LPALDELETESOURCES)(ALsizei n, const ALuint* sources);
typedef ALboolean(AL_APIENTRY* LPALISSOURCE)(ALuint source);
typedef void(AL_APIENTRY* LPALSOURCEF)(ALuint source, ALenum param,
ALfloat value);
typedef void(AL_APIENTRY* LPALSOURCE3F)(ALuint source, ALenum param,
ALfloat value1, ALfloat value2,
ALfloat value3);
typedef void(AL_APIENTRY* LPALSOURCEFV)(ALuint source, ALenum param,
const ALfloat* values);
typedef void(AL_APIENTRY* LPALSOURCEI)(ALuint source, ALenum param,
ALint value);
typedef void(AL_APIENTRY* LPALSOURCE3I)(ALuint source, ALenum param,
ALint value1, ALint value2,
ALint value3);
typedef void(AL_APIENTRY* LPALSOURCEIV)(ALuint source, ALenum param,
const ALint* values);
typedef void(AL_APIENTRY* LPALGETSOURCEF)(ALuint source, ALenum param,
ALfloat* value);
typedef void(AL_APIENTRY* LPALGETSOURCE3F)(ALuint source, ALenum param,
ALfloat* value1, ALfloat* value2,
ALfloat* value3);
typedef void(AL_APIENTRY* LPALGETSOURCEFV)(ALuint source, ALenum param,
ALfloat* values);
typedef void(AL_APIENTRY* LPALGETSOURCEI)(ALuint source, ALenum param,
ALint* value);
typedef void(AL_APIENTRY* LPALGETSOURCE3I)(ALuint source, ALenum param,
ALint* value1, ALint* value2,
ALint* value3);
typedef void(AL_APIENTRY* LPALGETSOURCEIV)(ALuint source, ALenum param,
ALint* values);
typedef void(AL_APIENTRY* LPALSOURCEPLAYV)(ALsizei n, const ALuint* sources);
typedef void(AL_APIENTRY* LPALSOURCESTOPV)(ALsizei n, const ALuint* sources);
typedef void(AL_APIENTRY* LPALSOURCEREWINDV)(ALsizei n, const ALuint* sources);
typedef void(AL_APIENTRY* LPALSOURCEPAUSEV)(ALsizei n, const ALuint* sources);
typedef void(AL_APIENTRY* LPALSOURCEPLAY)(ALuint source);
typedef void(AL_APIENTRY* LPALSOURCESTOP)(ALuint source);
typedef void(AL_APIENTRY* LPALSOURCEREWIND)(ALuint source);
typedef void(AL_APIENTRY* LPALSOURCEPAUSE)(ALuint source);
typedef void(AL_APIENTRY* LPALSOURCEQUEUEBUFFERS)(ALuint source, ALsizei nb,
const ALuint* buffers);
typedef void(AL_APIENTRY* LPALSOURCEUNQUEUEBUFFERS)(ALuint source, ALsizei nb,
ALuint* buffers);
typedef void(AL_APIENTRY* LPALGENBUFFERS)(ALsizei n, ALuint* buffers);
typedef void(AL_APIENTRY* LPALDELETEBUFFERS)(ALsizei n, const ALuint* buffers);
typedef ALboolean(AL_APIENTRY* LPALISBUFFER)(ALuint buffer);
typedef void(AL_APIENTRY* LPALBUFFERDATA)(ALuint buffer, ALenum format,
const ALvoid* data, ALsizei size,
ALsizei freq);
typedef void(AL_APIENTRY* LPALBUFFERF)(ALuint buffer, ALenum param,
ALfloat value);
typedef void(AL_APIENTRY* LPALBUFFER3F)(ALuint buffer, ALenum param,
ALfloat value1, ALfloat value2,
ALfloat value3);
typedef void(AL_APIENTRY* LPALBUFFERFV)(ALuint buffer, ALenum param,
const ALfloat* values);
typedef void(AL_APIENTRY* LPALBUFFERI)(ALuint buffer, ALenum param,
ALint value);
typedef void(AL_APIENTRY* LPALBUFFER3I)(ALuint buffer, ALenum param,
ALint value1, ALint value2,
ALint value3);
typedef void(AL_APIENTRY* LPALBUFFERIV)(ALuint buffer, ALenum param,
const ALint* values);
typedef void(AL_APIENTRY* LPALGETBUFFERF)(ALuint buffer, ALenum param,
ALfloat* value);
typedef void(AL_APIENTRY* LPALGETBUFFER3F)(ALuint buffer, ALenum param,
ALfloat* value1, ALfloat* value2,
ALfloat* value3);
typedef void(AL_APIENTRY* LPALGETBUFFERFV)(ALuint buffer, ALenum param,
ALfloat* values);
typedef void(AL_APIENTRY* LPALGETBUFFERI)(ALuint buffer, ALenum param,
ALint* value);
typedef void(AL_APIENTRY* LPALGETBUFFER3I)(ALuint buffer, ALenum param,
ALint* value1, ALint* value2,
ALint* value3);
typedef void(AL_APIENTRY* LPALGETBUFFERIV)(ALuint buffer, ALenum param,
ALint* values);
typedef void(AL_APIENTRY* LPALDOPPLERFACTOR)(ALfloat value);
typedef void(AL_APIENTRY* LPALDOPPLERVELOCITY)(ALfloat value);
typedef void(AL_APIENTRY* LPALSPEEDOFSOUND)(ALfloat value);
typedef void(AL_APIENTRY* LPALDISTANCEMODEL)(ALenum distanceModel);
#if defined(__cplusplus)
} /* extern "C" */
#endif
#endif /* AL_AL_H */
| 36.23743
| 80
| 0.676058
|
[
"vector",
"model"
] |
9fa768877886cc0094be72fcd91506fafd8500d8
| 2,650
|
h
|
C
|
assignment-client/src/AgentScriptingInterface.h
|
kevinhouyang/hifi
|
cfb0d0aeb6d8961ec802909d4439d58383252e59
|
[
"Apache-2.0"
] | 3
|
2019-01-27T14:49:35.000Z
|
2020-01-15T18:49:11.000Z
|
assignment-client/src/AgentScriptingInterface.h
|
kevinhouyang/hifi
|
cfb0d0aeb6d8961ec802909d4439d58383252e59
|
[
"Apache-2.0"
] | null | null | null |
assignment-client/src/AgentScriptingInterface.h
|
kevinhouyang/hifi
|
cfb0d0aeb6d8961ec802909d4439d58383252e59
|
[
"Apache-2.0"
] | 2
|
2019-06-13T22:25:13.000Z
|
2022-01-31T15:17:55.000Z
|
//
// AgentScriptingInterface.h
// assignment-client/src
//
// Created by Thijs Wenker on 7/23/18.
// Copyright 2018 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#ifndef hifi_AgentScriptingInterface_h
#define hifi_AgentScriptingInterface_h
#include <QObject>
#include "Agent.h"
/**jsdoc
* @namespace Agent
*
* @hifi-assignment-client
*
* @property {boolean} isAvatar
* @property {boolean} isPlayingAvatarSound <em>Read-only.</em>
* @property {boolean} isListeningToAudioStream
* @property {boolean} isNoiseGateEnabled
* @property {number} lastReceivedAudioLoudness <em>Read-only.</em>
* @property {Uuid} sessionUUID <em>Read-only.</em>
*/
class AgentScriptingInterface : public QObject {
Q_OBJECT
Q_PROPERTY(bool isAvatar READ isAvatar WRITE setIsAvatar)
Q_PROPERTY(bool isPlayingAvatarSound READ isPlayingAvatarSound)
Q_PROPERTY(bool isListeningToAudioStream READ isListeningToAudioStream WRITE setIsListeningToAudioStream)
Q_PROPERTY(bool isNoiseGateEnabled READ isNoiseGateEnabled WRITE setIsNoiseGateEnabled)
Q_PROPERTY(float lastReceivedAudioLoudness READ getLastReceivedAudioLoudness)
Q_PROPERTY(QUuid sessionUUID READ getSessionUUID)
public:
AgentScriptingInterface(Agent* agent);
bool isPlayingAvatarSound() const { return _agent->isPlayingAvatarSound(); }
bool isListeningToAudioStream() const { return _agent->isListeningToAudioStream(); }
void setIsListeningToAudioStream(bool isListeningToAudioStream) const { _agent->setIsListeningToAudioStream(isListeningToAudioStream); }
bool isNoiseGateEnabled() const { return _agent->isNoiseGateEnabled(); }
void setIsNoiseGateEnabled(bool isNoiseGateEnabled) const { _agent->setIsNoiseGateEnabled(isNoiseGateEnabled); }
float getLastReceivedAudioLoudness() const { return _agent->getLastReceivedAudioLoudness(); }
QUuid getSessionUUID() const { return _agent->getSessionUUID(); }
public slots:
/**jsdoc
* @function Agent.setIsAvatar
* @param {boolean} isAvatar
*/
void setIsAvatar(bool isAvatar) const { _agent->setIsAvatar(isAvatar); }
/**jsdoc
* @function Agent.isAvatar
* @returns {boolean}
*/
bool isAvatar() const { return _agent->isAvatar(); }
/**jsdoc
* @function Agent.playAvatarSound
* @param {object} avatarSound
*/
void playAvatarSound(SharedSoundPointer avatarSound) const { _agent->playAvatarSound(avatarSound); }
private:
Agent* _agent;
};
#endif // hifi_AgentScriptingInterface_h
| 32.716049
| 140
| 0.752075
|
[
"object"
] |
9fad8bb0d39fd8a7c20374a1109d466a8d55534a
| 5,663
|
h
|
C
|
RedisCache/util.h
|
goodw21985/cpp_redis_cache
|
a4aa6bf001dcbcfaceafcfc3dd02ad1fb01db34f
|
[
"MIT"
] | null | null | null |
RedisCache/util.h
|
goodw21985/cpp_redis_cache
|
a4aa6bf001dcbcfaceafcfc3dd02ad1fb01db34f
|
[
"MIT"
] | null | null | null |
RedisCache/util.h
|
goodw21985/cpp_redis_cache
|
a4aa6bf001dcbcfaceafcfc3dd02ad1fb01db34f
|
[
"MIT"
] | null | null | null |
#pragma once
#include "stdafx.h"
#include <windows.h>
#include <vector>
#include <time.h>
#include <chrono>
#include <thread>
using namespace std;
namespace RedisCache
{
/*
* Cancelation Tokens are similar to critical sections that are used inside
* lambda functions where we need to support cancelation. If the lambda function
* is called after the function scope has been abandoned, the system will crash, so there
* needs to be a reliable way to notify the lambda that its inputs are no longer valid,
* and its outputs will be ignored.
*
* Synopsis of Cancelation Token classes:
*
* CancelationTokenPool pool();
* auto& token = pool.Get();
* methodWithLambda(..., [&token](reply& reply)
* {
* CANCELABLE(token);
* (do lambda work)
* });
*
* (Wait for results or timeout)
* token.Cancel();
* Synopsis of multiple lambdas called in method
*
* CancelationTokenPool pool();
* CancelationGroup group(pool);
* for(...)
* {
* auto& token = group.Get();
* methodWithLambda(..., [&token](reply& reply)
* {
* CANCELABLE(token);
* (do lambda work)
* });
*
* (Wait for results or timeout)
* group.Cancel();
*
* Synopsis of CritSec
*
* volatile long lock=0;
* {
* CritSec anyname(lock);
* (do work that can only allow one thread at a time here)
* }
*
* Synopsis of Random
*
* Random rand;
* rand.Seed(123455);
* printf("%d",rand.Next());
*
*/
#define SLEEP(x) std::this_thread::sleep_for(std::chrono::milliseconds(x));
// Spin lock critical section for performance
class CritSec
{
volatile unsigned int *lock;
public:
CritSec(volatile unsigned int &lockref)
: lock(&lockref)
{
while (1 == InterlockedCompareExchange(lock, 1, 0))
{
}
}
~CritSec()
{
*lock = 0;
}
};
// Spin lock critical section for performance
class CritSecSleep
{
volatile unsigned int *lock;
public:
CritSecSleep(volatile unsigned int &lockref)
: lock(&lockref)
{
int cnt = 0;
while (1 == InterlockedCompareExchange(lock, 1, 0))
{
if (cnt++ > 10000)
{
SLEEP(1);
cnt = 0;
}
}
}
~CritSecSleep()
{
*lock = 0;
}
};
// thread safe state machine state value for a lamdba function
// (reset) - lambda function has not run yet, but we would like it to. Or it has completed.
// (start) lambda function is running.
// (cancel) lambda function should not run, unless it has already started.
// The state progression is either: reset->start->reset->cancel (completed action)
// or reset->cancel (will never run).
class CancelationToken
{
private:
static const short reset = 0;
static const short start = 1;
static const short cancel = 2;
volatile short token;
public:
CancelationToken()
{
Reset();
}
void Reset()
{
token = reset;
}
void Cancel()
{
while (InterlockedCompareExchange16(&token, cancel, reset) != reset);
}
void Start()
{
while (InterlockedCompareExchange16(&token, start, reset) != reset) if (token == cancel) break;
}
bool IsCanceled()
{
return token == cancel;
}
};
class CancelationTokenPool
{
std::vector<CancelationToken> pool;
int size;
int next;
volatile unsigned int lambdaCancelationPoolCritSec = 0;
public:
CancelationTokenPool(int size0)
: pool(size0)
{
size = size0;
next = 0;
}
CancelationToken& Get()
{
CritSec critSec(lambdaCancelationPoolCritSec);
int i = next++;
if (next >= size) next = 0;
return pool[i];
}
};
#define CANCELABLESECTION(x) CancelableCriticalSection _ccs(x); \
if (x.IsCanceled()) return;
class CancelableCriticalSection
{
CancelationToken& token;
public:
CancelableCriticalSection(CancelationToken& t)
: token(t)
{
t.Start();
}
~CancelableCriticalSection()
{
token.Reset();
}
};
class CancelationGroup
{
vector<CancelationToken*> group;
CancelationTokenPool& pool;
public:
CancelationGroup(CancelationTokenPool& p)
: pool(p)
{}
CancelationToken& Get()
{
auto& token = pool.Get();
group.push_back(&token);
return token;
}
void Cancel()
{
for (auto* token : group)
{
token->Cancel();
}
}
};
class Random
{
unsigned int next;
public:
Random(unsigned int seed = 12345)
{
next = seed;
}
void Seed(unsigned int seed)
{
next = seed;
}
unsigned int Next()
{
next = (next * 49537 + 26557) ;
return next & RAND_MAX;
}
};
}
| 22.927126
| 107
| 0.503797
|
[
"vector"
] |
9fae279a227e2dbd4e553cb6be11fe7d1ef44f92
| 8,105
|
c
|
C
|
ds/security/authz/test/fundsrm/fundsrmp.c
|
npocmaka/Windows-Server-2003
|
5c6fe3db626b63a384230a1aa6b92ac416b0765f
|
[
"Unlicense"
] | 17
|
2020-11-13T13:42:52.000Z
|
2021-09-16T09:13:13.000Z
|
ds/security/authz/test/fundsrm/fundsrmp.c
|
sancho1952007/Windows-Server-2003
|
5c6fe3db626b63a384230a1aa6b92ac416b0765f
|
[
"Unlicense"
] | 2
|
2020-10-19T08:02:06.000Z
|
2020-10-19T08:23:18.000Z
|
ds/security/authz/test/fundsrm/fundsrmp.c
|
sancho1952007/Windows-Server-2003
|
5c6fe3db626b63a384230a1aa6b92ac416b0765f
|
[
"Unlicense"
] | 14
|
2020-11-14T09:43:20.000Z
|
2021-08-28T08:59:57.000Z
|
#include "pch.h"
#include "fundsrmp.h"
//
// The various SIDs, the easy way
//
DWORD BobGuid[] = {0x00000501, 0x05000000, 0x00000015, 0x17b85159, 0x255d7266, 0x0b3b6364, 0x00020001};
DWORD MarthaGuid[] = {0x00000501, 0x05000000, 0x00000015, 0x17b85159, 0x255d7266, 0x0b3b6364, 0x00020002};
DWORD JoeGuid[] = {0x00000501, 0x05000000, 0x00000015, 0x17b85159, 0x255d7266, 0x0b3b6364, 0x00020003};
DWORD VPGuid[] = {0x00000501, 0x05000000, 0x00000015, 0x17b85159, 0x255d7266, 0x0b3b6364, 0x00010001};
DWORD ManagerGuid[] = {0x00000501, 0x05000000, 0x00000015, 0x17b85159, 0x255d7266, 0x0b3b6364, 0x00010002};
DWORD EmployeeGuid[] = {0x00000501, 0x05000000, 0x00000015, 0x17b85159, 0x255d7266, 0x0b3b6364, 0x00010003};
DWORD EveryoneGuid[] = {0x101, 0x01000000, 0};
PSID BobSid = (PSID)BobGuid;
PSID MarthaSid= (PSID)MarthaGuid;
PSID JoeSid = (PSID)JoeGuid;
PSID VPSid = (PSID)VPGuid;
PSID ManagerSid = (PSID)ManagerGuid;
PSID EmployeeSid = (PSID)EmployeeGuid;
PSID EveryoneSid = (PSID)EveryoneGuid;
//
// Maximum spending approvals, in cents
//
DWORD MaxSpendingVP = 100000000;
DWORD MaxSpendingManager = 1000000;
DWORD MaxSpendingEmployee = 50000;
//
// The callback routines used with AuthZ
//
BOOL
FundsAccessCheck(
IN AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext,
IN PACE_HEADER pAce,
IN PVOID pArgs OPTIONAL,
IN OUT PBOOL pbAceApplicable
)
/*++
Routine Description
This is the callback access check. It is registered with a
resource manager. AuthzAccessCheck calls this function when it
encounters a callback type ACE, one of:
ACCESS_ALLOWED_CALLBACK_ACE_TYPE
ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE
ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE
This function determines if the given callback ACE applies to the
client context (which has already had dynamic groups computed) and
the optional arguments, in this case the request amount.
The list of groups which apply to the user is traversed. If a group
is found which allows the user the requested access, pbAceApplicable
is set to true and the function returns. If the end of the group list
is reached, pbAceApplicable is set to false and the function returns.
Arguments
hAuthzClientContext - handle to the AuthzClientContext.
pAce - pointer to the Ace header.
pArgs - optional arguments, in this case DWORD*, DWORD is the spending
request amount in cents
pbAceApplicable - returns true iff the ACE allows the client's request
Return value
Bool, true on success, false on error
Error checking
Sample code, no error checking
--*/
{
//
// First, look up the user's SID from the context
//
DWORD dwTokenGroupsSize = 0;
PVOID pvTokenGroupsBuf = NULL;
DWORD i;
PDWORD pAccessMask = NULL;
//
// The requested spending amount, in cents
//
DWORD dwRequestedSpending = ((PDWORD)pArgs)[0];
//
// By default, the ACE does not apply to the request
//
*pbAceApplicable = FALSE;
//
// The object's access mask (right after the ACE_HEADER)
// The access mask determines types of expenditures allowed
// from this fund
//
pAccessMask = (PDWORD) (pAce + sizeof(ACE_HEADER));
//
// Get needed buffer size
//
AuthzGetContextInformation(hAuthzClientContext,
AuthzContextInfoGroupsSids,
NULL,
0,
&dwTokenGroupsSize
);
pvTokenGroupsBuf = malloc(dwTokenGroupsSize);
//
// Get the actual TOKEN_GROUPS array
//
AuthzGetContextInformation(hAuthzClientContext,
AuthzContextInfoGroupsSids,
pvTokenGroupsBuf,
dwTokenGroupsSize,
&dwTokenGroupsSize
);
//
// Go through the groups until end is reached or a group applying to the
// request is found
//
for( i = 0;
i < ((PTOKEN_GROUPS)pvTokenGroupsBuf)->GroupCount
&& *pbAceApplicable != TRUE;
i++ )
{
//
// Again, this is the business logic.
// Each level of employee can approve different amounts.
//
//
// VP
//
if( dwRequestedSpending <= MaxSpendingVP &&
EqualSid(VPSid, ((PTOKEN_GROUPS)pvTokenGroupsBuf)->Groups[i].Sid) )
{
*pbAceApplicable = TRUE;
}
//
// Manager
//
if( dwRequestedSpending <= MaxSpendingManager &&
EqualSid(ManagerSid, ((PTOKEN_GROUPS)pvTokenGroupsBuf)->Groups[i].Sid) )
{
*pbAceApplicable = TRUE;
}
//
// Employee
//
if( dwRequestedSpending <= MaxSpendingEmployee &&
EqualSid(EmployeeSid, ((PTOKEN_GROUPS)pvTokenGroupsBuf)->Groups[i].Sid) )
{
*pbAceApplicable = TRUE;
}
}
return TRUE;
}
BOOL
FundsComputeDynamicGroups(
IN AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext,
IN PVOID Args,
OUT PSID_AND_ATTRIBUTES *pSidAttrArray,
OUT PDWORD pSidCount,
OUT PSID_AND_ATTRIBUTES *pRestrictedSidAttrArray,
OUT PDWORD pRestrictedSidCount
)
/*++
Routine Description
Resource manager callback to compute dynamic groups. This is used by the RM
to decide if the specified client context should be included in any RM defined groups.
In this example, the employees are hardcoded into their roles. However, this is the
place you would normally retrieve data from an external source to determine the
users' additional roles.
Arguments
hAuthzClientContext - handle to client context.
Args - optional parameter to pass information for evaluating group membership.
pSidAttrArray - computed group membership SIDs
pSidCount - count of SIDs
pRestrictedSidAttrArray - computed group membership restricted SIDs
pRestrictedSidCount - count of restricted SIDs
Return Value
Bool, true for success, false on failure.
Error checking
Sample code, no error checking
--*/
{
//
// First, look up the user's SID from the context
//
DWORD dwSidSize = 0;
PVOID pvSidBuf = NULL;
PSID psSidPtr = NULL;
//
// Get needed buffer size
//
AuthzGetContextInformation(hAuthzClientContext,
AuthzContextInfoUserSid,
NULL,
0,
&dwSidSize
);
pvSidBuf = malloc(dwSidSize);
//
// Get the actual SID (inside a TOKEN_USER structure)
//
AuthzGetContextInformation(hAuthzClientContext,
AuthzContextInfoUserSid,
pvSidBuf,
dwSidSize,
&dwSidSize
);
psSidPtr = ((PTOKEN_USER)pvSidBuf)->User.Sid;
//
// Allocate the memory for the returns, which will be deallocated by FreeDynamicGroups
// Only a single group will be returned, determining the employee type
//
*pSidCount = 1;
*pSidAttrArray = (PSID_AND_ATTRIBUTES)malloc( sizeof(SID_AND_ATTRIBUTES) );
//
// No restricted group sids
//
pRestrictedSidCount = 0;
*pRestrictedSidAttrArray = NULL;
(*pSidAttrArray)[0].Attributes = SE_GROUP_ENABLED;
//
// The hardcoded logic:
// Bob is a VP
// Martha is a Manager
// Joe is an Employee
//
if( EqualSid(psSidPtr, BobSid) )
{
(*pSidAttrArray)[0].Sid = VPSid;
}
else if( EqualSid(psSidPtr, MarthaSid) )
{
(*pSidAttrArray)[0].Sid = ManagerSid;
}
else if( EqualSid(psSidPtr, JoeSid) )
{
(*pSidAttrArray)[0].Sid = EmployeeSid;
}
free(pvSidBuf);
return TRUE;
}
VOID
FundsFreeDynamicGroups (
IN PSID_AND_ATTRIBUTES pSidAttrArray
)
/*++
Routine Description
Frees memory allocated for the dynamic group array.
Arguments
pSidAttrArray - array to free.
Return Value
None.
--*/
{
if (pSidAttrArray != NULL)
{
free(pSidAttrArray);
}
}
| 24.560606
| 109
| 0.645157
|
[
"object"
] |
9fbb7808e8f7c834c5e62bf9af4929075eb908b2
| 347
|
h
|
C
|
cpp/src/day-01/sonar.h
|
raphaelmeyer/advent-of-code-2021
|
bf6c03d3143e44e4568ce0fa5c694773b5b20972
|
[
"MIT"
] | null | null | null |
cpp/src/day-01/sonar.h
|
raphaelmeyer/advent-of-code-2021
|
bf6c03d3143e44e4568ce0fa5c694773b5b20972
|
[
"MIT"
] | null | null | null |
cpp/src/day-01/sonar.h
|
raphaelmeyer/advent-of-code-2021
|
bf6c03d3143e44e4568ce0fa5c694773b5b20972
|
[
"MIT"
] | null | null | null |
#pragma once
#include <filesystem>
#include <vector>
namespace sonar {
std::vector<unsigned> parse_file(std::filesystem::path file);
std::vector<unsigned> parse_input(std::istream &input);
unsigned count_increase(std::vector<unsigned> const &input);
std::vector<unsigned> window_sums(std::vector<unsigned> const &input);
} // namespace sonar
| 23.133333
| 70
| 0.757925
|
[
"vector"
] |
9fc261cbe7f067006d2ad7b9aa7ba8f5e188c104
| 97,452
|
h
|
C
|
lib/qemu/hw/i386/trace.h
|
dahlia-os/prickle-emulator
|
30b06dfb12eab53719300ab6eacd4372845a1404
|
[
"Apache-2.0"
] | 5
|
2019-11-27T17:26:05.000Z
|
2020-11-06T06:14:45.000Z
|
lib/qemu/hw/i386/trace.h
|
dahliaOS/prickle-emulator
|
30b06dfb12eab53719300ab6eacd4372845a1404
|
[
"Apache-2.0"
] | 2
|
2019-07-11T08:02:44.000Z
|
2019-07-16T09:39:32.000Z
|
lib/qemu/hw/i386/trace.h
|
dahlia-os/prickle-emulator
|
30b06dfb12eab53719300ab6eacd4372845a1404
|
[
"Apache-2.0"
] | 3
|
2019-07-10T22:35:05.000Z
|
2020-12-09T08:15:04.000Z
|
/* This file is autogenerated by tracetool, do not edit. */
#ifndef TRACE_HW_I386_GENERATED_TRACERS_H
#define TRACE_HW_I386_GENERATED_TRACERS_H
#include "qemu-common.h"
#include "trace/control.h"
extern TraceEvent _TRACE_X86_IOMMU_IEC_NOTIFY_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_CC_DOMAIN_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_CC_GLOBAL_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_CC_DEVICE_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_CC_DEVICES_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_IOTLB_GLOBAL_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_IOTLB_DOMAIN_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_IOTLB_PAGES_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_WAIT_SW_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_WAIT_IRQ_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_WAIT_WRITE_FAIL_EVENT;
extern TraceEvent _TRACE_VTD_INV_DESC_IEC_EVENT;
extern TraceEvent _TRACE_VTD_INV_QI_ENABLE_EVENT;
extern TraceEvent _TRACE_VTD_INV_QI_SETUP_EVENT;
extern TraceEvent _TRACE_VTD_INV_QI_HEAD_EVENT;
extern TraceEvent _TRACE_VTD_INV_QI_TAIL_EVENT;
extern TraceEvent _TRACE_VTD_INV_QI_FETCH_EVENT;
extern TraceEvent _TRACE_VTD_CONTEXT_CACHE_RESET_EVENT;
extern TraceEvent _TRACE_VTD_RE_NOT_PRESENT_EVENT;
extern TraceEvent _TRACE_VTD_CE_NOT_PRESENT_EVENT;
extern TraceEvent _TRACE_VTD_IOTLB_PAGE_HIT_EVENT;
extern TraceEvent _TRACE_VTD_IOTLB_PAGE_UPDATE_EVENT;
extern TraceEvent _TRACE_VTD_IOTLB_CC_HIT_EVENT;
extern TraceEvent _TRACE_VTD_IOTLB_CC_UPDATE_EVENT;
extern TraceEvent _TRACE_VTD_IOTLB_RESET_EVENT;
extern TraceEvent _TRACE_VTD_FAULT_DISABLED_EVENT;
extern TraceEvent _TRACE_VTD_REPLAY_CE_VALID_EVENT;
extern TraceEvent _TRACE_VTD_REPLAY_CE_INVALID_EVENT;
extern TraceEvent _TRACE_VTD_PAGE_WALK_LEVEL_EVENT;
extern TraceEvent _TRACE_VTD_PAGE_WALK_ONE_EVENT;
extern TraceEvent _TRACE_VTD_PAGE_WALK_ONE_SKIP_MAP_EVENT;
extern TraceEvent _TRACE_VTD_PAGE_WALK_ONE_SKIP_UNMAP_EVENT;
extern TraceEvent _TRACE_VTD_PAGE_WALK_SKIP_READ_EVENT;
extern TraceEvent _TRACE_VTD_PAGE_WALK_SKIP_RESERVE_EVENT;
extern TraceEvent _TRACE_VTD_SWITCH_ADDRESS_SPACE_EVENT;
extern TraceEvent _TRACE_VTD_AS_UNMAP_WHOLE_EVENT;
extern TraceEvent _TRACE_VTD_TRANSLATE_PT_EVENT;
extern TraceEvent _TRACE_VTD_PT_ENABLE_FAST_PATH_EVENT;
extern TraceEvent _TRACE_VTD_IRQ_GENERATE_EVENT;
extern TraceEvent _TRACE_VTD_REG_READ_EVENT;
extern TraceEvent _TRACE_VTD_REG_WRITE_EVENT;
extern TraceEvent _TRACE_VTD_REG_DMAR_ROOT_EVENT;
extern TraceEvent _TRACE_VTD_REG_IR_ROOT_EVENT;
extern TraceEvent _TRACE_VTD_REG_WRITE_GCMD_EVENT;
extern TraceEvent _TRACE_VTD_REG_WRITE_FECTL_EVENT;
extern TraceEvent _TRACE_VTD_REG_WRITE_IECTL_EVENT;
extern TraceEvent _TRACE_VTD_REG_ICS_CLEAR_IP_EVENT;
extern TraceEvent _TRACE_VTD_DMAR_TRANSLATE_EVENT;
extern TraceEvent _TRACE_VTD_DMAR_ENABLE_EVENT;
extern TraceEvent _TRACE_VTD_DMAR_FAULT_EVENT;
extern TraceEvent _TRACE_VTD_IR_ENABLE_EVENT;
extern TraceEvent _TRACE_VTD_IR_IRTE_GET_EVENT;
extern TraceEvent _TRACE_VTD_IR_REMAP_EVENT;
extern TraceEvent _TRACE_VTD_IR_REMAP_TYPE_EVENT;
extern TraceEvent _TRACE_VTD_IR_REMAP_MSI_EVENT;
extern TraceEvent _TRACE_VTD_IR_REMAP_MSI_REQ_EVENT;
extern TraceEvent _TRACE_VTD_FSTS_PPF_EVENT;
extern TraceEvent _TRACE_VTD_FSTS_CLEAR_IP_EVENT;
extern TraceEvent _TRACE_VTD_FRR_NEW_EVENT;
extern TraceEvent _TRACE_VTD_WARN_INVALID_QI_TAIL_EVENT;
extern TraceEvent _TRACE_VTD_WARN_IR_VECTOR_EVENT;
extern TraceEvent _TRACE_VTD_WARN_IR_TRIGGER_EVENT;
extern TraceEvent _TRACE_AMDVI_EVNTLOG_FAIL_EVENT;
extern TraceEvent _TRACE_AMDVI_CACHE_UPDATE_EVENT;
extern TraceEvent _TRACE_AMDVI_COMPLETION_WAIT_FAIL_EVENT;
extern TraceEvent _TRACE_AMDVI_MMIO_WRITE_EVENT;
extern TraceEvent _TRACE_AMDVI_MMIO_READ_EVENT;
extern TraceEvent _TRACE_AMDVI_MMIO_READ_INVALID_EVENT;
extern TraceEvent _TRACE_AMDVI_COMMAND_ERROR_EVENT;
extern TraceEvent _TRACE_AMDVI_COMMAND_READ_FAIL_EVENT;
extern TraceEvent _TRACE_AMDVI_COMMAND_EXEC_EVENT;
extern TraceEvent _TRACE_AMDVI_UNHANDLED_COMMAND_EVENT;
extern TraceEvent _TRACE_AMDVI_INTR_INVAL_EVENT;
extern TraceEvent _TRACE_AMDVI_IOTLB_INVAL_EVENT;
extern TraceEvent _TRACE_AMDVI_PREFETCH_PAGES_EVENT;
extern TraceEvent _TRACE_AMDVI_PAGES_INVAL_EVENT;
extern TraceEvent _TRACE_AMDVI_ALL_INVAL_EVENT;
extern TraceEvent _TRACE_AMDVI_PPR_EXEC_EVENT;
extern TraceEvent _TRACE_AMDVI_DEVTAB_INVAL_EVENT;
extern TraceEvent _TRACE_AMDVI_COMPLETION_WAIT_EVENT;
extern TraceEvent _TRACE_AMDVI_CONTROL_STATUS_EVENT;
extern TraceEvent _TRACE_AMDVI_IOTLB_RESET_EVENT;
extern TraceEvent _TRACE_AMDVI_DTE_GET_FAIL_EVENT;
extern TraceEvent _TRACE_AMDVI_INVALID_DTE_EVENT;
extern TraceEvent _TRACE_AMDVI_GET_PTE_HWERROR_EVENT;
extern TraceEvent _TRACE_AMDVI_MODE_INVALID_EVENT;
extern TraceEvent _TRACE_AMDVI_PAGE_FAULT_EVENT;
extern TraceEvent _TRACE_AMDVI_IOTLB_HIT_EVENT;
extern TraceEvent _TRACE_AMDVI_TRANSLATION_RESULT_EVENT;
extern TraceEvent _TRACE_AMDVI_MEM_IR_WRITE_REQ_EVENT;
extern TraceEvent _TRACE_AMDVI_MEM_IR_WRITE_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_REMAP_MSI_REQ_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_REMAP_MSI_EVENT;
extern TraceEvent _TRACE_AMDVI_ERR_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_IRTE_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_IRTE_VAL_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_ERR_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_INTCTL_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_TARGET_ABORT_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_DELIVERY_MODE_EVENT;
extern TraceEvent _TRACE_AMDVI_IR_IRTE_GA_VAL_EVENT;
extern TraceEvent _TRACE_VMPORT_REGISTER_EVENT;
extern TraceEvent _TRACE_VMPORT_COMMAND_EVENT;
extern uint16_t _TRACE_X86_IOMMU_IEC_NOTIFY_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_CC_DOMAIN_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_CC_GLOBAL_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_CC_DEVICE_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_CC_DEVICES_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_IOTLB_GLOBAL_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_IOTLB_DOMAIN_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_IOTLB_PAGES_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_WAIT_SW_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_WAIT_IRQ_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_WAIT_WRITE_FAIL_DSTATE;
extern uint16_t _TRACE_VTD_INV_DESC_IEC_DSTATE;
extern uint16_t _TRACE_VTD_INV_QI_ENABLE_DSTATE;
extern uint16_t _TRACE_VTD_INV_QI_SETUP_DSTATE;
extern uint16_t _TRACE_VTD_INV_QI_HEAD_DSTATE;
extern uint16_t _TRACE_VTD_INV_QI_TAIL_DSTATE;
extern uint16_t _TRACE_VTD_INV_QI_FETCH_DSTATE;
extern uint16_t _TRACE_VTD_CONTEXT_CACHE_RESET_DSTATE;
extern uint16_t _TRACE_VTD_RE_NOT_PRESENT_DSTATE;
extern uint16_t _TRACE_VTD_CE_NOT_PRESENT_DSTATE;
extern uint16_t _TRACE_VTD_IOTLB_PAGE_HIT_DSTATE;
extern uint16_t _TRACE_VTD_IOTLB_PAGE_UPDATE_DSTATE;
extern uint16_t _TRACE_VTD_IOTLB_CC_HIT_DSTATE;
extern uint16_t _TRACE_VTD_IOTLB_CC_UPDATE_DSTATE;
extern uint16_t _TRACE_VTD_IOTLB_RESET_DSTATE;
extern uint16_t _TRACE_VTD_FAULT_DISABLED_DSTATE;
extern uint16_t _TRACE_VTD_REPLAY_CE_VALID_DSTATE;
extern uint16_t _TRACE_VTD_REPLAY_CE_INVALID_DSTATE;
extern uint16_t _TRACE_VTD_PAGE_WALK_LEVEL_DSTATE;
extern uint16_t _TRACE_VTD_PAGE_WALK_ONE_DSTATE;
extern uint16_t _TRACE_VTD_PAGE_WALK_ONE_SKIP_MAP_DSTATE;
extern uint16_t _TRACE_VTD_PAGE_WALK_ONE_SKIP_UNMAP_DSTATE;
extern uint16_t _TRACE_VTD_PAGE_WALK_SKIP_READ_DSTATE;
extern uint16_t _TRACE_VTD_PAGE_WALK_SKIP_RESERVE_DSTATE;
extern uint16_t _TRACE_VTD_SWITCH_ADDRESS_SPACE_DSTATE;
extern uint16_t _TRACE_VTD_AS_UNMAP_WHOLE_DSTATE;
extern uint16_t _TRACE_VTD_TRANSLATE_PT_DSTATE;
extern uint16_t _TRACE_VTD_PT_ENABLE_FAST_PATH_DSTATE;
extern uint16_t _TRACE_VTD_IRQ_GENERATE_DSTATE;
extern uint16_t _TRACE_VTD_REG_READ_DSTATE;
extern uint16_t _TRACE_VTD_REG_WRITE_DSTATE;
extern uint16_t _TRACE_VTD_REG_DMAR_ROOT_DSTATE;
extern uint16_t _TRACE_VTD_REG_IR_ROOT_DSTATE;
extern uint16_t _TRACE_VTD_REG_WRITE_GCMD_DSTATE;
extern uint16_t _TRACE_VTD_REG_WRITE_FECTL_DSTATE;
extern uint16_t _TRACE_VTD_REG_WRITE_IECTL_DSTATE;
extern uint16_t _TRACE_VTD_REG_ICS_CLEAR_IP_DSTATE;
extern uint16_t _TRACE_VTD_DMAR_TRANSLATE_DSTATE;
extern uint16_t _TRACE_VTD_DMAR_ENABLE_DSTATE;
extern uint16_t _TRACE_VTD_DMAR_FAULT_DSTATE;
extern uint16_t _TRACE_VTD_IR_ENABLE_DSTATE;
extern uint16_t _TRACE_VTD_IR_IRTE_GET_DSTATE;
extern uint16_t _TRACE_VTD_IR_REMAP_DSTATE;
extern uint16_t _TRACE_VTD_IR_REMAP_TYPE_DSTATE;
extern uint16_t _TRACE_VTD_IR_REMAP_MSI_DSTATE;
extern uint16_t _TRACE_VTD_IR_REMAP_MSI_REQ_DSTATE;
extern uint16_t _TRACE_VTD_FSTS_PPF_DSTATE;
extern uint16_t _TRACE_VTD_FSTS_CLEAR_IP_DSTATE;
extern uint16_t _TRACE_VTD_FRR_NEW_DSTATE;
extern uint16_t _TRACE_VTD_WARN_INVALID_QI_TAIL_DSTATE;
extern uint16_t _TRACE_VTD_WARN_IR_VECTOR_DSTATE;
extern uint16_t _TRACE_VTD_WARN_IR_TRIGGER_DSTATE;
extern uint16_t _TRACE_AMDVI_EVNTLOG_FAIL_DSTATE;
extern uint16_t _TRACE_AMDVI_CACHE_UPDATE_DSTATE;
extern uint16_t _TRACE_AMDVI_COMPLETION_WAIT_FAIL_DSTATE;
extern uint16_t _TRACE_AMDVI_MMIO_WRITE_DSTATE;
extern uint16_t _TRACE_AMDVI_MMIO_READ_DSTATE;
extern uint16_t _TRACE_AMDVI_MMIO_READ_INVALID_DSTATE;
extern uint16_t _TRACE_AMDVI_COMMAND_ERROR_DSTATE;
extern uint16_t _TRACE_AMDVI_COMMAND_READ_FAIL_DSTATE;
extern uint16_t _TRACE_AMDVI_COMMAND_EXEC_DSTATE;
extern uint16_t _TRACE_AMDVI_UNHANDLED_COMMAND_DSTATE;
extern uint16_t _TRACE_AMDVI_INTR_INVAL_DSTATE;
extern uint16_t _TRACE_AMDVI_IOTLB_INVAL_DSTATE;
extern uint16_t _TRACE_AMDVI_PREFETCH_PAGES_DSTATE;
extern uint16_t _TRACE_AMDVI_PAGES_INVAL_DSTATE;
extern uint16_t _TRACE_AMDVI_ALL_INVAL_DSTATE;
extern uint16_t _TRACE_AMDVI_PPR_EXEC_DSTATE;
extern uint16_t _TRACE_AMDVI_DEVTAB_INVAL_DSTATE;
extern uint16_t _TRACE_AMDVI_COMPLETION_WAIT_DSTATE;
extern uint16_t _TRACE_AMDVI_CONTROL_STATUS_DSTATE;
extern uint16_t _TRACE_AMDVI_IOTLB_RESET_DSTATE;
extern uint16_t _TRACE_AMDVI_DTE_GET_FAIL_DSTATE;
extern uint16_t _TRACE_AMDVI_INVALID_DTE_DSTATE;
extern uint16_t _TRACE_AMDVI_GET_PTE_HWERROR_DSTATE;
extern uint16_t _TRACE_AMDVI_MODE_INVALID_DSTATE;
extern uint16_t _TRACE_AMDVI_PAGE_FAULT_DSTATE;
extern uint16_t _TRACE_AMDVI_IOTLB_HIT_DSTATE;
extern uint16_t _TRACE_AMDVI_TRANSLATION_RESULT_DSTATE;
extern uint16_t _TRACE_AMDVI_MEM_IR_WRITE_REQ_DSTATE;
extern uint16_t _TRACE_AMDVI_MEM_IR_WRITE_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_REMAP_MSI_REQ_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_REMAP_MSI_DSTATE;
extern uint16_t _TRACE_AMDVI_ERR_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_IRTE_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_IRTE_VAL_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_ERR_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_INTCTL_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_TARGET_ABORT_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_DELIVERY_MODE_DSTATE;
extern uint16_t _TRACE_AMDVI_IR_IRTE_GA_VAL_DSTATE;
extern uint16_t _TRACE_VMPORT_REGISTER_DSTATE;
extern uint16_t _TRACE_VMPORT_COMMAND_DSTATE;
#define TRACE_X86_IOMMU_IEC_NOTIFY_ENABLED 1
#define TRACE_VTD_INV_DESC_ENABLED 1
#define TRACE_VTD_INV_DESC_CC_DOMAIN_ENABLED 1
#define TRACE_VTD_INV_DESC_CC_GLOBAL_ENABLED 1
#define TRACE_VTD_INV_DESC_CC_DEVICE_ENABLED 1
#define TRACE_VTD_INV_DESC_CC_DEVICES_ENABLED 1
#define TRACE_VTD_INV_DESC_IOTLB_GLOBAL_ENABLED 1
#define TRACE_VTD_INV_DESC_IOTLB_DOMAIN_ENABLED 1
#define TRACE_VTD_INV_DESC_IOTLB_PAGES_ENABLED 1
#define TRACE_VTD_INV_DESC_WAIT_SW_ENABLED 1
#define TRACE_VTD_INV_DESC_WAIT_IRQ_ENABLED 1
#define TRACE_VTD_INV_DESC_WAIT_WRITE_FAIL_ENABLED 1
#define TRACE_VTD_INV_DESC_IEC_ENABLED 1
#define TRACE_VTD_INV_QI_ENABLE_ENABLED 1
#define TRACE_VTD_INV_QI_SETUP_ENABLED 1
#define TRACE_VTD_INV_QI_HEAD_ENABLED 1
#define TRACE_VTD_INV_QI_TAIL_ENABLED 1
#define TRACE_VTD_INV_QI_FETCH_ENABLED 1
#define TRACE_VTD_CONTEXT_CACHE_RESET_ENABLED 1
#define TRACE_VTD_RE_NOT_PRESENT_ENABLED 1
#define TRACE_VTD_CE_NOT_PRESENT_ENABLED 1
#define TRACE_VTD_IOTLB_PAGE_HIT_ENABLED 1
#define TRACE_VTD_IOTLB_PAGE_UPDATE_ENABLED 1
#define TRACE_VTD_IOTLB_CC_HIT_ENABLED 1
#define TRACE_VTD_IOTLB_CC_UPDATE_ENABLED 1
#define TRACE_VTD_IOTLB_RESET_ENABLED 1
#define TRACE_VTD_FAULT_DISABLED_ENABLED 1
#define TRACE_VTD_REPLAY_CE_VALID_ENABLED 1
#define TRACE_VTD_REPLAY_CE_INVALID_ENABLED 1
#define TRACE_VTD_PAGE_WALK_LEVEL_ENABLED 1
#define TRACE_VTD_PAGE_WALK_ONE_ENABLED 1
#define TRACE_VTD_PAGE_WALK_ONE_SKIP_MAP_ENABLED 1
#define TRACE_VTD_PAGE_WALK_ONE_SKIP_UNMAP_ENABLED 1
#define TRACE_VTD_PAGE_WALK_SKIP_READ_ENABLED 1
#define TRACE_VTD_PAGE_WALK_SKIP_RESERVE_ENABLED 1
#define TRACE_VTD_SWITCH_ADDRESS_SPACE_ENABLED 1
#define TRACE_VTD_AS_UNMAP_WHOLE_ENABLED 1
#define TRACE_VTD_TRANSLATE_PT_ENABLED 1
#define TRACE_VTD_PT_ENABLE_FAST_PATH_ENABLED 1
#define TRACE_VTD_IRQ_GENERATE_ENABLED 1
#define TRACE_VTD_REG_READ_ENABLED 1
#define TRACE_VTD_REG_WRITE_ENABLED 1
#define TRACE_VTD_REG_DMAR_ROOT_ENABLED 1
#define TRACE_VTD_REG_IR_ROOT_ENABLED 1
#define TRACE_VTD_REG_WRITE_GCMD_ENABLED 1
#define TRACE_VTD_REG_WRITE_FECTL_ENABLED 1
#define TRACE_VTD_REG_WRITE_IECTL_ENABLED 1
#define TRACE_VTD_REG_ICS_CLEAR_IP_ENABLED 1
#define TRACE_VTD_DMAR_TRANSLATE_ENABLED 1
#define TRACE_VTD_DMAR_ENABLE_ENABLED 1
#define TRACE_VTD_DMAR_FAULT_ENABLED 1
#define TRACE_VTD_IR_ENABLE_ENABLED 1
#define TRACE_VTD_IR_IRTE_GET_ENABLED 1
#define TRACE_VTD_IR_REMAP_ENABLED 1
#define TRACE_VTD_IR_REMAP_TYPE_ENABLED 1
#define TRACE_VTD_IR_REMAP_MSI_ENABLED 1
#define TRACE_VTD_IR_REMAP_MSI_REQ_ENABLED 1
#define TRACE_VTD_FSTS_PPF_ENABLED 1
#define TRACE_VTD_FSTS_CLEAR_IP_ENABLED 1
#define TRACE_VTD_FRR_NEW_ENABLED 1
#define TRACE_VTD_WARN_INVALID_QI_TAIL_ENABLED 1
#define TRACE_VTD_WARN_IR_VECTOR_ENABLED 1
#define TRACE_VTD_WARN_IR_TRIGGER_ENABLED 1
#define TRACE_AMDVI_EVNTLOG_FAIL_ENABLED 1
#define TRACE_AMDVI_CACHE_UPDATE_ENABLED 1
#define TRACE_AMDVI_COMPLETION_WAIT_FAIL_ENABLED 1
#define TRACE_AMDVI_MMIO_WRITE_ENABLED 1
#define TRACE_AMDVI_MMIO_READ_ENABLED 1
#define TRACE_AMDVI_MMIO_READ_INVALID_ENABLED 1
#define TRACE_AMDVI_COMMAND_ERROR_ENABLED 1
#define TRACE_AMDVI_COMMAND_READ_FAIL_ENABLED 1
#define TRACE_AMDVI_COMMAND_EXEC_ENABLED 1
#define TRACE_AMDVI_UNHANDLED_COMMAND_ENABLED 1
#define TRACE_AMDVI_INTR_INVAL_ENABLED 1
#define TRACE_AMDVI_IOTLB_INVAL_ENABLED 1
#define TRACE_AMDVI_PREFETCH_PAGES_ENABLED 1
#define TRACE_AMDVI_PAGES_INVAL_ENABLED 1
#define TRACE_AMDVI_ALL_INVAL_ENABLED 1
#define TRACE_AMDVI_PPR_EXEC_ENABLED 1
#define TRACE_AMDVI_DEVTAB_INVAL_ENABLED 1
#define TRACE_AMDVI_COMPLETION_WAIT_ENABLED 1
#define TRACE_AMDVI_CONTROL_STATUS_ENABLED 1
#define TRACE_AMDVI_IOTLB_RESET_ENABLED 1
#define TRACE_AMDVI_DTE_GET_FAIL_ENABLED 1
#define TRACE_AMDVI_INVALID_DTE_ENABLED 1
#define TRACE_AMDVI_GET_PTE_HWERROR_ENABLED 1
#define TRACE_AMDVI_MODE_INVALID_ENABLED 1
#define TRACE_AMDVI_PAGE_FAULT_ENABLED 1
#define TRACE_AMDVI_IOTLB_HIT_ENABLED 1
#define TRACE_AMDVI_TRANSLATION_RESULT_ENABLED 1
#define TRACE_AMDVI_MEM_IR_WRITE_REQ_ENABLED 1
#define TRACE_AMDVI_MEM_IR_WRITE_ENABLED 1
#define TRACE_AMDVI_IR_REMAP_MSI_REQ_ENABLED 1
#define TRACE_AMDVI_IR_REMAP_MSI_ENABLED 1
#define TRACE_AMDVI_ERR_ENABLED 1
#define TRACE_AMDVI_IR_IRTE_ENABLED 1
#define TRACE_AMDVI_IR_IRTE_VAL_ENABLED 1
#define TRACE_AMDVI_IR_ERR_ENABLED 1
#define TRACE_AMDVI_IR_INTCTL_ENABLED 1
#define TRACE_AMDVI_IR_TARGET_ABORT_ENABLED 1
#define TRACE_AMDVI_IR_DELIVERY_MODE_ENABLED 1
#define TRACE_AMDVI_IR_IRTE_GA_VAL_ENABLED 1
#define TRACE_VMPORT_REGISTER_ENABLED 1
#define TRACE_VMPORT_COMMAND_ENABLED 1
#include "qemu/log-for-trace.h"
#define TRACE_X86_IOMMU_IEC_NOTIFY_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_X86_IOMMU_IEC_NOTIFY) || \
false)
static inline void _nocheck__trace_x86_iommu_iec_notify(bool global, uint32_t index, uint32_t mask)
{
if (trace_event_get_state(TRACE_X86_IOMMU_IEC_NOTIFY) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:x86_iommu_iec_notify " "Notify IEC invalidation: global=%d index=%" PRIu32 " mask=%" PRIu32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, global, index, mask);
}
}
static inline void trace_x86_iommu_iec_notify(bool global, uint32_t index, uint32_t mask)
{
if (true) {
_nocheck__trace_x86_iommu_iec_notify(global, index, mask);
}
}
#define TRACE_VTD_INV_DESC_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC) || \
false)
static inline void _nocheck__trace_vtd_inv_desc(const char * type, uint64_t hi, uint64_t lo)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc " "invalidate desc type %s high 0x%"PRIx64" low 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, type, hi, lo);
}
}
static inline void trace_vtd_inv_desc(const char * type, uint64_t hi, uint64_t lo)
{
if (true) {
_nocheck__trace_vtd_inv_desc(type, hi, lo);
}
}
#define TRACE_VTD_INV_DESC_CC_DOMAIN_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_CC_DOMAIN) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_cc_domain(uint16_t domain)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_CC_DOMAIN) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_domain " "context invalidate domain 0x%"PRIx16 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, domain);
}
}
static inline void trace_vtd_inv_desc_cc_domain(uint16_t domain)
{
if (true) {
_nocheck__trace_vtd_inv_desc_cc_domain(domain);
}
}
#define TRACE_VTD_INV_DESC_CC_GLOBAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_CC_GLOBAL) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_cc_global(void)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_CC_GLOBAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_global " "context invalidate globally" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_vtd_inv_desc_cc_global(void)
{
if (true) {
_nocheck__trace_vtd_inv_desc_cc_global();
}
}
#define TRACE_VTD_INV_DESC_CC_DEVICE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_CC_DEVICE) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_cc_device(uint8_t bus, uint8_t dev, uint8_t fn)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_CC_DEVICE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_device " "context invalidate device %02"PRIx8":%02"PRIx8".%02"PRIx8 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, dev, fn);
}
}
static inline void trace_vtd_inv_desc_cc_device(uint8_t bus, uint8_t dev, uint8_t fn)
{
if (true) {
_nocheck__trace_vtd_inv_desc_cc_device(bus, dev, fn);
}
}
#define TRACE_VTD_INV_DESC_CC_DEVICES_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_CC_DEVICES) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_cc_devices(uint16_t sid, uint16_t fmask)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_CC_DEVICES) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_devices " "context invalidate devices sid 0x%"PRIx16" fmask 0x%"PRIx16 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, sid, fmask);
}
}
static inline void trace_vtd_inv_desc_cc_devices(uint16_t sid, uint16_t fmask)
{
if (true) {
_nocheck__trace_vtd_inv_desc_cc_devices(sid, fmask);
}
}
#define TRACE_VTD_INV_DESC_IOTLB_GLOBAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_IOTLB_GLOBAL) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_iotlb_global(void)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_IOTLB_GLOBAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_global " "iotlb invalidate global" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_vtd_inv_desc_iotlb_global(void)
{
if (true) {
_nocheck__trace_vtd_inv_desc_iotlb_global();
}
}
#define TRACE_VTD_INV_DESC_IOTLB_DOMAIN_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_IOTLB_DOMAIN) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_iotlb_domain(uint16_t domain)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_IOTLB_DOMAIN) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_domain " "iotlb invalidate whole domain 0x%"PRIx16 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, domain);
}
}
static inline void trace_vtd_inv_desc_iotlb_domain(uint16_t domain)
{
if (true) {
_nocheck__trace_vtd_inv_desc_iotlb_domain(domain);
}
}
#define TRACE_VTD_INV_DESC_IOTLB_PAGES_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_IOTLB_PAGES) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_iotlb_pages(uint16_t domain, uint64_t addr, uint8_t mask)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_IOTLB_PAGES) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_pages " "iotlb invalidate domain 0x%"PRIx16" addr 0x%"PRIx64" mask 0x%"PRIx8 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, domain, addr, mask);
}
}
static inline void trace_vtd_inv_desc_iotlb_pages(uint16_t domain, uint64_t addr, uint8_t mask)
{
if (true) {
_nocheck__trace_vtd_inv_desc_iotlb_pages(domain, addr, mask);
}
}
#define TRACE_VTD_INV_DESC_WAIT_SW_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_WAIT_SW) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_wait_sw(uint64_t addr, uint32_t data)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_WAIT_SW) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_sw " "wait invalidate status write addr 0x%"PRIx64" data 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, data);
}
}
static inline void trace_vtd_inv_desc_wait_sw(uint64_t addr, uint32_t data)
{
if (true) {
_nocheck__trace_vtd_inv_desc_wait_sw(addr, data);
}
}
#define TRACE_VTD_INV_DESC_WAIT_IRQ_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_WAIT_IRQ) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_wait_irq(const char * msg)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_WAIT_IRQ) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_irq " "%s" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, msg);
}
}
static inline void trace_vtd_inv_desc_wait_irq(const char * msg)
{
if (true) {
_nocheck__trace_vtd_inv_desc_wait_irq(msg);
}
}
#define TRACE_VTD_INV_DESC_WAIT_WRITE_FAIL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_WAIT_WRITE_FAIL) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_wait_write_fail(uint64_t hi, uint64_t lo)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_WAIT_WRITE_FAIL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_write_fail " "write fail for wait desc hi 0x%"PRIx64" lo 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, hi, lo);
}
}
static inline void trace_vtd_inv_desc_wait_write_fail(uint64_t hi, uint64_t lo)
{
if (true) {
_nocheck__trace_vtd_inv_desc_wait_write_fail(hi, lo);
}
}
#define TRACE_VTD_INV_DESC_IEC_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_DESC_IEC) || \
false)
static inline void _nocheck__trace_vtd_inv_desc_iec(uint32_t granularity, uint32_t index, uint32_t mask)
{
if (trace_event_get_state(TRACE_VTD_INV_DESC_IEC) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_desc_iec " "granularity 0x%"PRIx32" index 0x%"PRIx32" mask 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, granularity, index, mask);
}
}
static inline void trace_vtd_inv_desc_iec(uint32_t granularity, uint32_t index, uint32_t mask)
{
if (true) {
_nocheck__trace_vtd_inv_desc_iec(granularity, index, mask);
}
}
#define TRACE_VTD_INV_QI_ENABLE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_QI_ENABLE) || \
false)
static inline void _nocheck__trace_vtd_inv_qi_enable(bool enable)
{
if (trace_event_get_state(TRACE_VTD_INV_QI_ENABLE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_qi_enable " "enabled %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, enable);
}
}
static inline void trace_vtd_inv_qi_enable(bool enable)
{
if (true) {
_nocheck__trace_vtd_inv_qi_enable(enable);
}
}
#define TRACE_VTD_INV_QI_SETUP_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_QI_SETUP) || \
false)
static inline void _nocheck__trace_vtd_inv_qi_setup(uint64_t addr, int size)
{
if (trace_event_get_state(TRACE_VTD_INV_QI_SETUP) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_qi_setup " "addr 0x%"PRIx64" size %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, size);
}
}
static inline void trace_vtd_inv_qi_setup(uint64_t addr, int size)
{
if (true) {
_nocheck__trace_vtd_inv_qi_setup(addr, size);
}
}
#define TRACE_VTD_INV_QI_HEAD_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_QI_HEAD) || \
false)
static inline void _nocheck__trace_vtd_inv_qi_head(uint16_t head)
{
if (trace_event_get_state(TRACE_VTD_INV_QI_HEAD) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_qi_head " "read head %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, head);
}
}
static inline void trace_vtd_inv_qi_head(uint16_t head)
{
if (true) {
_nocheck__trace_vtd_inv_qi_head(head);
}
}
#define TRACE_VTD_INV_QI_TAIL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_QI_TAIL) || \
false)
static inline void _nocheck__trace_vtd_inv_qi_tail(uint16_t head)
{
if (trace_event_get_state(TRACE_VTD_INV_QI_TAIL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_qi_tail " "write tail %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, head);
}
}
static inline void trace_vtd_inv_qi_tail(uint16_t head)
{
if (true) {
_nocheck__trace_vtd_inv_qi_tail(head);
}
}
#define TRACE_VTD_INV_QI_FETCH_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_INV_QI_FETCH) || \
false)
static inline void _nocheck__trace_vtd_inv_qi_fetch(void)
{
if (trace_event_get_state(TRACE_VTD_INV_QI_FETCH) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_inv_qi_fetch " "" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_vtd_inv_qi_fetch(void)
{
if (true) {
_nocheck__trace_vtd_inv_qi_fetch();
}
}
#define TRACE_VTD_CONTEXT_CACHE_RESET_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_CONTEXT_CACHE_RESET) || \
false)
static inline void _nocheck__trace_vtd_context_cache_reset(void)
{
if (trace_event_get_state(TRACE_VTD_CONTEXT_CACHE_RESET) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_context_cache_reset " "" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_vtd_context_cache_reset(void)
{
if (true) {
_nocheck__trace_vtd_context_cache_reset();
}
}
#define TRACE_VTD_RE_NOT_PRESENT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_RE_NOT_PRESENT) || \
false)
static inline void _nocheck__trace_vtd_re_not_present(uint8_t bus)
{
if (trace_event_get_state(TRACE_VTD_RE_NOT_PRESENT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_re_not_present " "Root entry bus %"PRIu8" not present" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus);
}
}
static inline void trace_vtd_re_not_present(uint8_t bus)
{
if (true) {
_nocheck__trace_vtd_re_not_present(bus);
}
}
#define TRACE_VTD_CE_NOT_PRESENT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_CE_NOT_PRESENT) || \
false)
static inline void _nocheck__trace_vtd_ce_not_present(uint8_t bus, uint8_t devfn)
{
if (trace_event_get_state(TRACE_VTD_CE_NOT_PRESENT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_ce_not_present " "Context entry bus %"PRIu8" devfn %"PRIu8" not present" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, devfn);
}
}
static inline void trace_vtd_ce_not_present(uint8_t bus, uint8_t devfn)
{
if (true) {
_nocheck__trace_vtd_ce_not_present(bus, devfn);
}
}
#define TRACE_VTD_IOTLB_PAGE_HIT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IOTLB_PAGE_HIT) || \
false)
static inline void _nocheck__trace_vtd_iotlb_page_hit(uint16_t sid, uint64_t addr, uint64_t slpte, uint16_t domain)
{
if (trace_event_get_state(TRACE_VTD_IOTLB_PAGE_HIT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_iotlb_page_hit " "IOTLB page hit sid 0x%"PRIx16" iova 0x%"PRIx64" slpte 0x%"PRIx64" domain 0x%"PRIx16 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, sid, addr, slpte, domain);
}
}
static inline void trace_vtd_iotlb_page_hit(uint16_t sid, uint64_t addr, uint64_t slpte, uint16_t domain)
{
if (true) {
_nocheck__trace_vtd_iotlb_page_hit(sid, addr, slpte, domain);
}
}
#define TRACE_VTD_IOTLB_PAGE_UPDATE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IOTLB_PAGE_UPDATE) || \
false)
static inline void _nocheck__trace_vtd_iotlb_page_update(uint16_t sid, uint64_t addr, uint64_t slpte, uint16_t domain)
{
if (trace_event_get_state(TRACE_VTD_IOTLB_PAGE_UPDATE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_iotlb_page_update " "IOTLB page update sid 0x%"PRIx16" iova 0x%"PRIx64" slpte 0x%"PRIx64" domain 0x%"PRIx16 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, sid, addr, slpte, domain);
}
}
static inline void trace_vtd_iotlb_page_update(uint16_t sid, uint64_t addr, uint64_t slpte, uint16_t domain)
{
if (true) {
_nocheck__trace_vtd_iotlb_page_update(sid, addr, slpte, domain);
}
}
#define TRACE_VTD_IOTLB_CC_HIT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IOTLB_CC_HIT) || \
false)
static inline void _nocheck__trace_vtd_iotlb_cc_hit(uint8_t bus, uint8_t devfn, uint64_t high, uint64_t low, uint32_t gen)
{
if (trace_event_get_state(TRACE_VTD_IOTLB_CC_HIT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_iotlb_cc_hit " "IOTLB context hit bus 0x%"PRIx8" devfn 0x%"PRIx8" high 0x%"PRIx64" low 0x%"PRIx64" gen %"PRIu32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, devfn, high, low, gen);
}
}
static inline void trace_vtd_iotlb_cc_hit(uint8_t bus, uint8_t devfn, uint64_t high, uint64_t low, uint32_t gen)
{
if (true) {
_nocheck__trace_vtd_iotlb_cc_hit(bus, devfn, high, low, gen);
}
}
#define TRACE_VTD_IOTLB_CC_UPDATE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IOTLB_CC_UPDATE) || \
false)
static inline void _nocheck__trace_vtd_iotlb_cc_update(uint8_t bus, uint8_t devfn, uint64_t high, uint64_t low, uint32_t gen1, uint32_t gen2)
{
if (trace_event_get_state(TRACE_VTD_IOTLB_CC_UPDATE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_iotlb_cc_update " "IOTLB context update bus 0x%"PRIx8" devfn 0x%"PRIx8" high 0x%"PRIx64" low 0x%"PRIx64" gen %"PRIu32" -> gen %"PRIu32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, devfn, high, low, gen1, gen2);
}
}
static inline void trace_vtd_iotlb_cc_update(uint8_t bus, uint8_t devfn, uint64_t high, uint64_t low, uint32_t gen1, uint32_t gen2)
{
if (true) {
_nocheck__trace_vtd_iotlb_cc_update(bus, devfn, high, low, gen1, gen2);
}
}
#define TRACE_VTD_IOTLB_RESET_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IOTLB_RESET) || \
false)
static inline void _nocheck__trace_vtd_iotlb_reset(const char * reason)
{
if (trace_event_get_state(TRACE_VTD_IOTLB_RESET) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_iotlb_reset " "IOTLB reset (reason: %s)" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, reason);
}
}
static inline void trace_vtd_iotlb_reset(const char * reason)
{
if (true) {
_nocheck__trace_vtd_iotlb_reset(reason);
}
}
#define TRACE_VTD_FAULT_DISABLED_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_FAULT_DISABLED) || \
false)
static inline void _nocheck__trace_vtd_fault_disabled(void)
{
if (trace_event_get_state(TRACE_VTD_FAULT_DISABLED) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_fault_disabled " "Fault processing disabled for context entry" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_vtd_fault_disabled(void)
{
if (true) {
_nocheck__trace_vtd_fault_disabled();
}
}
#define TRACE_VTD_REPLAY_CE_VALID_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REPLAY_CE_VALID) || \
false)
static inline void _nocheck__trace_vtd_replay_ce_valid(const char * mode, uint8_t bus, uint8_t dev, uint8_t fn, uint16_t domain, uint64_t hi, uint64_t lo)
{
if (trace_event_get_state(TRACE_VTD_REPLAY_CE_VALID) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_replay_ce_valid " "%s: replay valid context device %02"PRIx8":%02"PRIx8".%02"PRIx8" domain 0x%"PRIx16" hi 0x%"PRIx64" lo 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, mode, bus, dev, fn, domain, hi, lo);
}
}
static inline void trace_vtd_replay_ce_valid(const char * mode, uint8_t bus, uint8_t dev, uint8_t fn, uint16_t domain, uint64_t hi, uint64_t lo)
{
if (true) {
_nocheck__trace_vtd_replay_ce_valid(mode, bus, dev, fn, domain, hi, lo);
}
}
#define TRACE_VTD_REPLAY_CE_INVALID_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REPLAY_CE_INVALID) || \
false)
static inline void _nocheck__trace_vtd_replay_ce_invalid(uint8_t bus, uint8_t dev, uint8_t fn)
{
if (trace_event_get_state(TRACE_VTD_REPLAY_CE_INVALID) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_replay_ce_invalid " "replay invalid context device %02"PRIx8":%02"PRIx8".%02"PRIx8 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, dev, fn);
}
}
static inline void trace_vtd_replay_ce_invalid(uint8_t bus, uint8_t dev, uint8_t fn)
{
if (true) {
_nocheck__trace_vtd_replay_ce_invalid(bus, dev, fn);
}
}
#define TRACE_VTD_PAGE_WALK_LEVEL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_PAGE_WALK_LEVEL) || \
false)
static inline void _nocheck__trace_vtd_page_walk_level(uint64_t addr, uint32_t level, uint64_t start, uint64_t end)
{
if (trace_event_get_state(TRACE_VTD_PAGE_WALK_LEVEL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_page_walk_level " "walk (base=0x%"PRIx64", level=%"PRIu32") iova range 0x%"PRIx64" - 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, level, start, end);
}
}
static inline void trace_vtd_page_walk_level(uint64_t addr, uint32_t level, uint64_t start, uint64_t end)
{
if (true) {
_nocheck__trace_vtd_page_walk_level(addr, level, start, end);
}
}
#define TRACE_VTD_PAGE_WALK_ONE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_PAGE_WALK_ONE) || \
false)
static inline void _nocheck__trace_vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm)
{
if (trace_event_get_state(TRACE_VTD_PAGE_WALK_ONE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_page_walk_one " "domain 0x%"PRIu16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, domain, iova, gpa, mask, perm);
}
}
static inline void trace_vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm)
{
if (true) {
_nocheck__trace_vtd_page_walk_one(domain, iova, gpa, mask, perm);
}
}
#define TRACE_VTD_PAGE_WALK_ONE_SKIP_MAP_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_PAGE_WALK_ONE_SKIP_MAP) || \
false)
static inline void _nocheck__trace_vtd_page_walk_one_skip_map(uint64_t iova, uint64_t mask, uint64_t translated)
{
if (trace_event_get_state(TRACE_VTD_PAGE_WALK_ONE_SKIP_MAP) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_page_walk_one_skip_map " "iova 0x%"PRIx64" mask 0x%"PRIx64" translated 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, iova, mask, translated);
}
}
static inline void trace_vtd_page_walk_one_skip_map(uint64_t iova, uint64_t mask, uint64_t translated)
{
if (true) {
_nocheck__trace_vtd_page_walk_one_skip_map(iova, mask, translated);
}
}
#define TRACE_VTD_PAGE_WALK_ONE_SKIP_UNMAP_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_PAGE_WALK_ONE_SKIP_UNMAP) || \
false)
static inline void _nocheck__trace_vtd_page_walk_one_skip_unmap(uint64_t iova, uint64_t mask)
{
if (trace_event_get_state(TRACE_VTD_PAGE_WALK_ONE_SKIP_UNMAP) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_page_walk_one_skip_unmap " "iova 0x%"PRIx64" mask 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, iova, mask);
}
}
static inline void trace_vtd_page_walk_one_skip_unmap(uint64_t iova, uint64_t mask)
{
if (true) {
_nocheck__trace_vtd_page_walk_one_skip_unmap(iova, mask);
}
}
#define TRACE_VTD_PAGE_WALK_SKIP_READ_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_PAGE_WALK_SKIP_READ) || \
false)
static inline void _nocheck__trace_vtd_page_walk_skip_read(uint64_t iova, uint64_t next)
{
if (trace_event_get_state(TRACE_VTD_PAGE_WALK_SKIP_READ) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_page_walk_skip_read " "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to unable to read" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, iova, next);
}
}
static inline void trace_vtd_page_walk_skip_read(uint64_t iova, uint64_t next)
{
if (true) {
_nocheck__trace_vtd_page_walk_skip_read(iova, next);
}
}
#define TRACE_VTD_PAGE_WALK_SKIP_RESERVE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_PAGE_WALK_SKIP_RESERVE) || \
false)
static inline void _nocheck__trace_vtd_page_walk_skip_reserve(uint64_t iova, uint64_t next)
{
if (trace_event_get_state(TRACE_VTD_PAGE_WALK_SKIP_RESERVE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_page_walk_skip_reserve " "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to rsrv set" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, iova, next);
}
}
static inline void trace_vtd_page_walk_skip_reserve(uint64_t iova, uint64_t next)
{
if (true) {
_nocheck__trace_vtd_page_walk_skip_reserve(iova, next);
}
}
#define TRACE_VTD_SWITCH_ADDRESS_SPACE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_SWITCH_ADDRESS_SPACE) || \
false)
static inline void _nocheck__trace_vtd_switch_address_space(uint8_t bus, uint8_t slot, uint8_t fn, bool on)
{
if (trace_event_get_state(TRACE_VTD_SWITCH_ADDRESS_SPACE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_switch_address_space " "Device %02x:%02x.%x switching address space (iommu enabled=%d)" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, slot, fn, on);
}
}
static inline void trace_vtd_switch_address_space(uint8_t bus, uint8_t slot, uint8_t fn, bool on)
{
if (true) {
_nocheck__trace_vtd_switch_address_space(bus, slot, fn, on);
}
}
#define TRACE_VTD_AS_UNMAP_WHOLE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_AS_UNMAP_WHOLE) || \
false)
static inline void _nocheck__trace_vtd_as_unmap_whole(uint8_t bus, uint8_t slot, uint8_t fn, uint64_t iova, uint64_t size)
{
if (trace_event_get_state(TRACE_VTD_AS_UNMAP_WHOLE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_as_unmap_whole " "Device %02x:%02x.%x start 0x%"PRIx64" size 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, slot, fn, iova, size);
}
}
static inline void trace_vtd_as_unmap_whole(uint8_t bus, uint8_t slot, uint8_t fn, uint64_t iova, uint64_t size)
{
if (true) {
_nocheck__trace_vtd_as_unmap_whole(bus, slot, fn, iova, size);
}
}
#define TRACE_VTD_TRANSLATE_PT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_TRANSLATE_PT) || \
false)
static inline void _nocheck__trace_vtd_translate_pt(uint16_t sid, uint64_t addr)
{
if (trace_event_get_state(TRACE_VTD_TRANSLATE_PT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_translate_pt " "source id 0x%"PRIu16", iova 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, sid, addr);
}
}
static inline void trace_vtd_translate_pt(uint16_t sid, uint64_t addr)
{
if (true) {
_nocheck__trace_vtd_translate_pt(sid, addr);
}
}
#define TRACE_VTD_PT_ENABLE_FAST_PATH_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_PT_ENABLE_FAST_PATH) || \
false)
static inline void _nocheck__trace_vtd_pt_enable_fast_path(uint16_t sid, bool success)
{
if (trace_event_get_state(TRACE_VTD_PT_ENABLE_FAST_PATH) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_pt_enable_fast_path " "sid 0x%"PRIu16" %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, sid, success);
}
}
static inline void trace_vtd_pt_enable_fast_path(uint16_t sid, bool success)
{
if (true) {
_nocheck__trace_vtd_pt_enable_fast_path(sid, success);
}
}
#define TRACE_VTD_IRQ_GENERATE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IRQ_GENERATE) || \
false)
static inline void _nocheck__trace_vtd_irq_generate(uint64_t addr, uint64_t data)
{
if (trace_event_get_state(TRACE_VTD_IRQ_GENERATE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_irq_generate " "addr 0x%"PRIx64" data 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, data);
}
}
static inline void trace_vtd_irq_generate(uint64_t addr, uint64_t data)
{
if (true) {
_nocheck__trace_vtd_irq_generate(addr, data);
}
}
#define TRACE_VTD_REG_READ_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REG_READ) || \
false)
static inline void _nocheck__trace_vtd_reg_read(uint64_t addr, uint64_t size)
{
if (trace_event_get_state(TRACE_VTD_REG_READ) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_reg_read " "addr 0x%"PRIx64" size 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, size);
}
}
static inline void trace_vtd_reg_read(uint64_t addr, uint64_t size)
{
if (true) {
_nocheck__trace_vtd_reg_read(addr, size);
}
}
#define TRACE_VTD_REG_WRITE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REG_WRITE) || \
false)
static inline void _nocheck__trace_vtd_reg_write(uint64_t addr, uint64_t size, uint64_t val)
{
if (trace_event_get_state(TRACE_VTD_REG_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_reg_write " "addr 0x%"PRIx64" size 0x%"PRIx64" value 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, size, val);
}
}
static inline void trace_vtd_reg_write(uint64_t addr, uint64_t size, uint64_t val)
{
if (true) {
_nocheck__trace_vtd_reg_write(addr, size, val);
}
}
#define TRACE_VTD_REG_DMAR_ROOT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REG_DMAR_ROOT) || \
false)
static inline void _nocheck__trace_vtd_reg_dmar_root(uint64_t addr, bool scalable)
{
if (trace_event_get_state(TRACE_VTD_REG_DMAR_ROOT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_reg_dmar_root " "addr 0x%"PRIx64" scalable %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, scalable);
}
}
static inline void trace_vtd_reg_dmar_root(uint64_t addr, bool scalable)
{
if (true) {
_nocheck__trace_vtd_reg_dmar_root(addr, scalable);
}
}
#define TRACE_VTD_REG_IR_ROOT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REG_IR_ROOT) || \
false)
static inline void _nocheck__trace_vtd_reg_ir_root(uint64_t addr, uint32_t size)
{
if (trace_event_get_state(TRACE_VTD_REG_IR_ROOT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_reg_ir_root " "addr 0x%"PRIx64" size 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, size);
}
}
static inline void trace_vtd_reg_ir_root(uint64_t addr, uint32_t size)
{
if (true) {
_nocheck__trace_vtd_reg_ir_root(addr, size);
}
}
#define TRACE_VTD_REG_WRITE_GCMD_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REG_WRITE_GCMD) || \
false)
static inline void _nocheck__trace_vtd_reg_write_gcmd(uint32_t status, uint32_t val)
{
if (trace_event_get_state(TRACE_VTD_REG_WRITE_GCMD) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_reg_write_gcmd " "status 0x%"PRIx32" value 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, status, val);
}
}
static inline void trace_vtd_reg_write_gcmd(uint32_t status, uint32_t val)
{
if (true) {
_nocheck__trace_vtd_reg_write_gcmd(status, val);
}
}
#define TRACE_VTD_REG_WRITE_FECTL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REG_WRITE_FECTL) || \
false)
static inline void _nocheck__trace_vtd_reg_write_fectl(uint32_t value)
{
if (trace_event_get_state(TRACE_VTD_REG_WRITE_FECTL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_reg_write_fectl " "value 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, value);
}
}
static inline void trace_vtd_reg_write_fectl(uint32_t value)
{
if (true) {
_nocheck__trace_vtd_reg_write_fectl(value);
}
}
#define TRACE_VTD_REG_WRITE_IECTL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REG_WRITE_IECTL) || \
false)
static inline void _nocheck__trace_vtd_reg_write_iectl(uint32_t value)
{
if (trace_event_get_state(TRACE_VTD_REG_WRITE_IECTL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_reg_write_iectl " "value 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, value);
}
}
static inline void trace_vtd_reg_write_iectl(uint32_t value)
{
if (true) {
_nocheck__trace_vtd_reg_write_iectl(value);
}
}
#define TRACE_VTD_REG_ICS_CLEAR_IP_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_REG_ICS_CLEAR_IP) || \
false)
static inline void _nocheck__trace_vtd_reg_ics_clear_ip(void)
{
if (trace_event_get_state(TRACE_VTD_REG_ICS_CLEAR_IP) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_reg_ics_clear_ip " "" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_vtd_reg_ics_clear_ip(void)
{
if (true) {
_nocheck__trace_vtd_reg_ics_clear_ip();
}
}
#define TRACE_VTD_DMAR_TRANSLATE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_DMAR_TRANSLATE) || \
false)
static inline void _nocheck__trace_vtd_dmar_translate(uint8_t bus, uint8_t slot, uint8_t func, uint64_t iova, uint64_t gpa, uint64_t mask)
{
if (trace_event_get_state(TRACE_VTD_DMAR_TRANSLATE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_dmar_translate " "dev %02x:%02x.%02x iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, slot, func, iova, gpa, mask);
}
}
static inline void trace_vtd_dmar_translate(uint8_t bus, uint8_t slot, uint8_t func, uint64_t iova, uint64_t gpa, uint64_t mask)
{
if (true) {
_nocheck__trace_vtd_dmar_translate(bus, slot, func, iova, gpa, mask);
}
}
#define TRACE_VTD_DMAR_ENABLE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_DMAR_ENABLE) || \
false)
static inline void _nocheck__trace_vtd_dmar_enable(bool en)
{
if (trace_event_get_state(TRACE_VTD_DMAR_ENABLE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_dmar_enable " "enable %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, en);
}
}
static inline void trace_vtd_dmar_enable(bool en)
{
if (true) {
_nocheck__trace_vtd_dmar_enable(en);
}
}
#define TRACE_VTD_DMAR_FAULT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_DMAR_FAULT) || \
false)
static inline void _nocheck__trace_vtd_dmar_fault(uint16_t sid, int fault, uint64_t addr, bool is_write)
{
if (trace_event_get_state(TRACE_VTD_DMAR_FAULT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_dmar_fault " "sid 0x%"PRIx16" fault %d addr 0x%"PRIx64" write %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, sid, fault, addr, is_write);
}
}
static inline void trace_vtd_dmar_fault(uint16_t sid, int fault, uint64_t addr, bool is_write)
{
if (true) {
_nocheck__trace_vtd_dmar_fault(sid, fault, addr, is_write);
}
}
#define TRACE_VTD_IR_ENABLE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IR_ENABLE) || \
false)
static inline void _nocheck__trace_vtd_ir_enable(bool en)
{
if (trace_event_get_state(TRACE_VTD_IR_ENABLE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_ir_enable " "enable %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, en);
}
}
static inline void trace_vtd_ir_enable(bool en)
{
if (true) {
_nocheck__trace_vtd_ir_enable(en);
}
}
#define TRACE_VTD_IR_IRTE_GET_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IR_IRTE_GET) || \
false)
static inline void _nocheck__trace_vtd_ir_irte_get(int index, uint64_t lo, uint64_t hi)
{
if (trace_event_get_state(TRACE_VTD_IR_IRTE_GET) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_ir_irte_get " "index %d low 0x%"PRIx64" high 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, index, lo, hi);
}
}
static inline void trace_vtd_ir_irte_get(int index, uint64_t lo, uint64_t hi)
{
if (true) {
_nocheck__trace_vtd_ir_irte_get(index, lo, hi);
}
}
#define TRACE_VTD_IR_REMAP_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IR_REMAP) || \
false)
static inline void _nocheck__trace_vtd_ir_remap(int index, int tri, int vec, int deliver, uint32_t dest, int dest_mode)
{
if (trace_event_get_state(TRACE_VTD_IR_REMAP) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_ir_remap " "index %d trigger %d vector %d deliver %d dest 0x%"PRIx32" mode %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, index, tri, vec, deliver, dest, dest_mode);
}
}
static inline void trace_vtd_ir_remap(int index, int tri, int vec, int deliver, uint32_t dest, int dest_mode)
{
if (true) {
_nocheck__trace_vtd_ir_remap(index, tri, vec, deliver, dest, dest_mode);
}
}
#define TRACE_VTD_IR_REMAP_TYPE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IR_REMAP_TYPE) || \
false)
static inline void _nocheck__trace_vtd_ir_remap_type(const char * type)
{
if (trace_event_get_state(TRACE_VTD_IR_REMAP_TYPE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_ir_remap_type " "%s" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, type);
}
}
static inline void trace_vtd_ir_remap_type(const char * type)
{
if (true) {
_nocheck__trace_vtd_ir_remap_type(type);
}
}
#define TRACE_VTD_IR_REMAP_MSI_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IR_REMAP_MSI) || \
false)
static inline void _nocheck__trace_vtd_ir_remap_msi(uint64_t addr, uint64_t data, uint64_t addr2, uint64_t data2)
{
if (trace_event_get_state(TRACE_VTD_IR_REMAP_MSI) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_ir_remap_msi " "(addr 0x%"PRIx64", data 0x%"PRIx64") -> (addr 0x%"PRIx64", data 0x%"PRIx64")" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, data, addr2, data2);
}
}
static inline void trace_vtd_ir_remap_msi(uint64_t addr, uint64_t data, uint64_t addr2, uint64_t data2)
{
if (true) {
_nocheck__trace_vtd_ir_remap_msi(addr, data, addr2, data2);
}
}
#define TRACE_VTD_IR_REMAP_MSI_REQ_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_IR_REMAP_MSI_REQ) || \
false)
static inline void _nocheck__trace_vtd_ir_remap_msi_req(uint64_t addr, uint64_t data)
{
if (trace_event_get_state(TRACE_VTD_IR_REMAP_MSI_REQ) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_ir_remap_msi_req " "addr 0x%"PRIx64" data 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, data);
}
}
static inline void trace_vtd_ir_remap_msi_req(uint64_t addr, uint64_t data)
{
if (true) {
_nocheck__trace_vtd_ir_remap_msi_req(addr, data);
}
}
#define TRACE_VTD_FSTS_PPF_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_FSTS_PPF) || \
false)
static inline void _nocheck__trace_vtd_fsts_ppf(bool set)
{
if (trace_event_get_state(TRACE_VTD_FSTS_PPF) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_fsts_ppf " "FSTS PPF bit set to %d" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, set);
}
}
static inline void trace_vtd_fsts_ppf(bool set)
{
if (true) {
_nocheck__trace_vtd_fsts_ppf(set);
}
}
#define TRACE_VTD_FSTS_CLEAR_IP_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_FSTS_CLEAR_IP) || \
false)
static inline void _nocheck__trace_vtd_fsts_clear_ip(void)
{
if (trace_event_get_state(TRACE_VTD_FSTS_CLEAR_IP) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_fsts_clear_ip " "" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_vtd_fsts_clear_ip(void)
{
if (true) {
_nocheck__trace_vtd_fsts_clear_ip();
}
}
#define TRACE_VTD_FRR_NEW_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_FRR_NEW) || \
false)
static inline void _nocheck__trace_vtd_frr_new(int index, uint64_t hi, uint64_t lo)
{
if (trace_event_get_state(TRACE_VTD_FRR_NEW) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_frr_new " "index %d high 0x%"PRIx64" low 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, index, hi, lo);
}
}
static inline void trace_vtd_frr_new(int index, uint64_t hi, uint64_t lo)
{
if (true) {
_nocheck__trace_vtd_frr_new(index, hi, lo);
}
}
#define TRACE_VTD_WARN_INVALID_QI_TAIL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_WARN_INVALID_QI_TAIL) || \
false)
static inline void _nocheck__trace_vtd_warn_invalid_qi_tail(uint16_t tail)
{
if (trace_event_get_state(TRACE_VTD_WARN_INVALID_QI_TAIL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_warn_invalid_qi_tail " "tail 0x%"PRIx16 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, tail);
}
}
static inline void trace_vtd_warn_invalid_qi_tail(uint16_t tail)
{
if (true) {
_nocheck__trace_vtd_warn_invalid_qi_tail(tail);
}
}
#define TRACE_VTD_WARN_IR_VECTOR_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_WARN_IR_VECTOR) || \
false)
static inline void _nocheck__trace_vtd_warn_ir_vector(uint16_t sid, int index, int vec, int target)
{
if (trace_event_get_state(TRACE_VTD_WARN_IR_VECTOR) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_warn_ir_vector " "sid 0x%"PRIx16" index %d vec %d (should be: %d)" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, sid, index, vec, target);
}
}
static inline void trace_vtd_warn_ir_vector(uint16_t sid, int index, int vec, int target)
{
if (true) {
_nocheck__trace_vtd_warn_ir_vector(sid, index, vec, target);
}
}
#define TRACE_VTD_WARN_IR_TRIGGER_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VTD_WARN_IR_TRIGGER) || \
false)
static inline void _nocheck__trace_vtd_warn_ir_trigger(uint16_t sid, int index, int trig, int target)
{
if (trace_event_get_state(TRACE_VTD_WARN_IR_TRIGGER) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vtd_warn_ir_trigger " "sid 0x%"PRIx16" index %d trigger %d (should be: %d)" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, sid, index, trig, target);
}
}
static inline void trace_vtd_warn_ir_trigger(uint16_t sid, int index, int trig, int target)
{
if (true) {
_nocheck__trace_vtd_warn_ir_trigger(sid, index, trig, target);
}
}
#define TRACE_AMDVI_EVNTLOG_FAIL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_EVNTLOG_FAIL) || \
false)
static inline void _nocheck__trace_amdvi_evntlog_fail(uint64_t addr, uint32_t head)
{
if (trace_event_get_state(TRACE_AMDVI_EVNTLOG_FAIL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_evntlog_fail " "error: fail to write at addr 0x%"PRIx64" + offset 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, head);
}
}
static inline void trace_amdvi_evntlog_fail(uint64_t addr, uint32_t head)
{
if (true) {
_nocheck__trace_amdvi_evntlog_fail(addr, head);
}
}
#define TRACE_AMDVI_CACHE_UPDATE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_CACHE_UPDATE) || \
false)
static inline void _nocheck__trace_amdvi_cache_update(uint16_t domid, uint8_t bus, uint8_t slot, uint8_t func, uint64_t gpa, uint64_t txaddr)
{
if (trace_event_get_state(TRACE_AMDVI_CACHE_UPDATE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_cache_update " " update iotlb domid 0x%"PRIx16" devid: %02x:%02x.%x gpa 0x%"PRIx64" hpa 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, domid, bus, slot, func, gpa, txaddr);
}
}
static inline void trace_amdvi_cache_update(uint16_t domid, uint8_t bus, uint8_t slot, uint8_t func, uint64_t gpa, uint64_t txaddr)
{
if (true) {
_nocheck__trace_amdvi_cache_update(domid, bus, slot, func, gpa, txaddr);
}
}
#define TRACE_AMDVI_COMPLETION_WAIT_FAIL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_COMPLETION_WAIT_FAIL) || \
false)
static inline void _nocheck__trace_amdvi_completion_wait_fail(uint64_t addr)
{
if (trace_event_get_state(TRACE_AMDVI_COMPLETION_WAIT_FAIL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_completion_wait_fail " "error: fail to write at address 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr);
}
}
static inline void trace_amdvi_completion_wait_fail(uint64_t addr)
{
if (true) {
_nocheck__trace_amdvi_completion_wait_fail(addr);
}
}
#define TRACE_AMDVI_MMIO_WRITE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_MMIO_WRITE) || \
false)
static inline void _nocheck__trace_amdvi_mmio_write(const char * reg, uint64_t addr, unsigned size, uint64_t val, uint64_t offset)
{
if (trace_event_get_state(TRACE_AMDVI_MMIO_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_mmio_write " "%s write addr 0x%"PRIx64", size %u, val 0x%"PRIx64", offset 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, reg, addr, size, val, offset);
}
}
static inline void trace_amdvi_mmio_write(const char * reg, uint64_t addr, unsigned size, uint64_t val, uint64_t offset)
{
if (true) {
_nocheck__trace_amdvi_mmio_write(reg, addr, size, val, offset);
}
}
#define TRACE_AMDVI_MMIO_READ_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_MMIO_READ) || \
false)
static inline void _nocheck__trace_amdvi_mmio_read(const char * reg, uint64_t addr, unsigned size, uint64_t offset)
{
if (trace_event_get_state(TRACE_AMDVI_MMIO_READ) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_mmio_read " "%s read addr 0x%"PRIx64", size %u offset 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, reg, addr, size, offset);
}
}
static inline void trace_amdvi_mmio_read(const char * reg, uint64_t addr, unsigned size, uint64_t offset)
{
if (true) {
_nocheck__trace_amdvi_mmio_read(reg, addr, size, offset);
}
}
#define TRACE_AMDVI_MMIO_READ_INVALID_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_MMIO_READ_INVALID) || \
false)
static inline void _nocheck__trace_amdvi_mmio_read_invalid(int max, uint64_t addr, unsigned size)
{
if (trace_event_get_state(TRACE_AMDVI_MMIO_READ_INVALID) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_mmio_read_invalid " "error: addr outside region (max 0x%x): read addr 0x%" PRIx64 ", size %u" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, max, addr, size);
}
}
static inline void trace_amdvi_mmio_read_invalid(int max, uint64_t addr, unsigned size)
{
if (true) {
_nocheck__trace_amdvi_mmio_read_invalid(max, addr, size);
}
}
#define TRACE_AMDVI_COMMAND_ERROR_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_COMMAND_ERROR) || \
false)
static inline void _nocheck__trace_amdvi_command_error(uint64_t status)
{
if (trace_event_get_state(TRACE_AMDVI_COMMAND_ERROR) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_command_error " "error: Executing commands with command buffer disabled 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, status);
}
}
static inline void trace_amdvi_command_error(uint64_t status)
{
if (true) {
_nocheck__trace_amdvi_command_error(status);
}
}
#define TRACE_AMDVI_COMMAND_READ_FAIL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_COMMAND_READ_FAIL) || \
false)
static inline void _nocheck__trace_amdvi_command_read_fail(uint64_t addr, uint32_t head)
{
if (trace_event_get_state(TRACE_AMDVI_COMMAND_READ_FAIL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_command_read_fail " "error: fail to access memory at 0x%"PRIx64" + 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, head);
}
}
static inline void trace_amdvi_command_read_fail(uint64_t addr, uint32_t head)
{
if (true) {
_nocheck__trace_amdvi_command_read_fail(addr, head);
}
}
#define TRACE_AMDVI_COMMAND_EXEC_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_COMMAND_EXEC) || \
false)
static inline void _nocheck__trace_amdvi_command_exec(uint32_t head, uint32_t tail, uint64_t buf)
{
if (trace_event_get_state(TRACE_AMDVI_COMMAND_EXEC) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_command_exec " "command buffer head at 0x%"PRIx32" command buffer tail at 0x%"PRIx32" command buffer base at 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, head, tail, buf);
}
}
static inline void trace_amdvi_command_exec(uint32_t head, uint32_t tail, uint64_t buf)
{
if (true) {
_nocheck__trace_amdvi_command_exec(head, tail, buf);
}
}
#define TRACE_AMDVI_UNHANDLED_COMMAND_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_UNHANDLED_COMMAND) || \
false)
static inline void _nocheck__trace_amdvi_unhandled_command(uint8_t type)
{
if (trace_event_get_state(TRACE_AMDVI_UNHANDLED_COMMAND) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_unhandled_command " "unhandled command 0x%"PRIx8 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, type);
}
}
static inline void trace_amdvi_unhandled_command(uint8_t type)
{
if (true) {
_nocheck__trace_amdvi_unhandled_command(type);
}
}
#define TRACE_AMDVI_INTR_INVAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_INTR_INVAL) || \
false)
static inline void _nocheck__trace_amdvi_intr_inval(void)
{
if (trace_event_get_state(TRACE_AMDVI_INTR_INVAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_intr_inval " "Interrupt table invalidated" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_amdvi_intr_inval(void)
{
if (true) {
_nocheck__trace_amdvi_intr_inval();
}
}
#define TRACE_AMDVI_IOTLB_INVAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IOTLB_INVAL) || \
false)
static inline void _nocheck__trace_amdvi_iotlb_inval(void)
{
if (trace_event_get_state(TRACE_AMDVI_IOTLB_INVAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_iotlb_inval " "IOTLB pages invalidated" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_amdvi_iotlb_inval(void)
{
if (true) {
_nocheck__trace_amdvi_iotlb_inval();
}
}
#define TRACE_AMDVI_PREFETCH_PAGES_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_PREFETCH_PAGES) || \
false)
static inline void _nocheck__trace_amdvi_prefetch_pages(void)
{
if (trace_event_get_state(TRACE_AMDVI_PREFETCH_PAGES) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_prefetch_pages " "Pre-fetch of AMD-Vi pages requested" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_amdvi_prefetch_pages(void)
{
if (true) {
_nocheck__trace_amdvi_prefetch_pages();
}
}
#define TRACE_AMDVI_PAGES_INVAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_PAGES_INVAL) || \
false)
static inline void _nocheck__trace_amdvi_pages_inval(uint16_t domid)
{
if (trace_event_get_state(TRACE_AMDVI_PAGES_INVAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_pages_inval " "AMD-Vi pages for domain 0x%"PRIx16 " invalidated" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, domid);
}
}
static inline void trace_amdvi_pages_inval(uint16_t domid)
{
if (true) {
_nocheck__trace_amdvi_pages_inval(domid);
}
}
#define TRACE_AMDVI_ALL_INVAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_ALL_INVAL) || \
false)
static inline void _nocheck__trace_amdvi_all_inval(void)
{
if (trace_event_get_state(TRACE_AMDVI_ALL_INVAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_all_inval " "Invalidation of all AMD-Vi cache requested " "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_amdvi_all_inval(void)
{
if (true) {
_nocheck__trace_amdvi_all_inval();
}
}
#define TRACE_AMDVI_PPR_EXEC_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_PPR_EXEC) || \
false)
static inline void _nocheck__trace_amdvi_ppr_exec(void)
{
if (trace_event_get_state(TRACE_AMDVI_PPR_EXEC) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ppr_exec " "Execution of PPR queue requested " "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_amdvi_ppr_exec(void)
{
if (true) {
_nocheck__trace_amdvi_ppr_exec();
}
}
#define TRACE_AMDVI_DEVTAB_INVAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_DEVTAB_INVAL) || \
false)
static inline void _nocheck__trace_amdvi_devtab_inval(uint8_t bus, uint8_t slot, uint8_t func)
{
if (trace_event_get_state(TRACE_AMDVI_DEVTAB_INVAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_devtab_inval " "device table entry for devid: %02x:%02x.%x invalidated" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, slot, func);
}
}
static inline void trace_amdvi_devtab_inval(uint8_t bus, uint8_t slot, uint8_t func)
{
if (true) {
_nocheck__trace_amdvi_devtab_inval(bus, slot, func);
}
}
#define TRACE_AMDVI_COMPLETION_WAIT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_COMPLETION_WAIT) || \
false)
static inline void _nocheck__trace_amdvi_completion_wait(uint64_t addr, uint64_t data)
{
if (trace_event_get_state(TRACE_AMDVI_COMPLETION_WAIT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_completion_wait " "completion wait requested with store address 0x%"PRIx64" and store data 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, data);
}
}
static inline void trace_amdvi_completion_wait(uint64_t addr, uint64_t data)
{
if (true) {
_nocheck__trace_amdvi_completion_wait(addr, data);
}
}
#define TRACE_AMDVI_CONTROL_STATUS_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_CONTROL_STATUS) || \
false)
static inline void _nocheck__trace_amdvi_control_status(uint64_t val)
{
if (trace_event_get_state(TRACE_AMDVI_CONTROL_STATUS) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_control_status " "MMIO_STATUS state 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, val);
}
}
static inline void trace_amdvi_control_status(uint64_t val)
{
if (true) {
_nocheck__trace_amdvi_control_status(val);
}
}
#define TRACE_AMDVI_IOTLB_RESET_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IOTLB_RESET) || \
false)
static inline void _nocheck__trace_amdvi_iotlb_reset(void)
{
if (trace_event_get_state(TRACE_AMDVI_IOTLB_RESET) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_iotlb_reset " "IOTLB exceed size limit - reset " "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
);
}
}
static inline void trace_amdvi_iotlb_reset(void)
{
if (true) {
_nocheck__trace_amdvi_iotlb_reset();
}
}
#define TRACE_AMDVI_DTE_GET_FAIL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_DTE_GET_FAIL) || \
false)
static inline void _nocheck__trace_amdvi_dte_get_fail(uint64_t addr, uint32_t offset)
{
if (trace_event_get_state(TRACE_AMDVI_DTE_GET_FAIL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_dte_get_fail " "error: failed to access Device Entry devtab 0x%"PRIx64" offset 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, offset);
}
}
static inline void trace_amdvi_dte_get_fail(uint64_t addr, uint32_t offset)
{
if (true) {
_nocheck__trace_amdvi_dte_get_fail(addr, offset);
}
}
#define TRACE_AMDVI_INVALID_DTE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_INVALID_DTE) || \
false)
static inline void _nocheck__trace_amdvi_invalid_dte(uint64_t addr)
{
if (trace_event_get_state(TRACE_AMDVI_INVALID_DTE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_invalid_dte " "PTE entry at 0x%"PRIx64" is invalid " "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr);
}
}
static inline void trace_amdvi_invalid_dte(uint64_t addr)
{
if (true) {
_nocheck__trace_amdvi_invalid_dte(addr);
}
}
#define TRACE_AMDVI_GET_PTE_HWERROR_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_GET_PTE_HWERROR) || \
false)
static inline void _nocheck__trace_amdvi_get_pte_hwerror(uint64_t addr)
{
if (trace_event_get_state(TRACE_AMDVI_GET_PTE_HWERROR) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_get_pte_hwerror " "hardware error eccessing PTE at addr 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr);
}
}
static inline void trace_amdvi_get_pte_hwerror(uint64_t addr)
{
if (true) {
_nocheck__trace_amdvi_get_pte_hwerror(addr);
}
}
#define TRACE_AMDVI_MODE_INVALID_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_MODE_INVALID) || \
false)
static inline void _nocheck__trace_amdvi_mode_invalid(uint8_t level, uint64_t addr)
{
if (trace_event_get_state(TRACE_AMDVI_MODE_INVALID) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_mode_invalid " "error: translation level 0x%"PRIx8" translating addr 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, level, addr);
}
}
static inline void trace_amdvi_mode_invalid(uint8_t level, uint64_t addr)
{
if (true) {
_nocheck__trace_amdvi_mode_invalid(level, addr);
}
}
#define TRACE_AMDVI_PAGE_FAULT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_PAGE_FAULT) || \
false)
static inline void _nocheck__trace_amdvi_page_fault(uint64_t addr)
{
if (trace_event_get_state(TRACE_AMDVI_PAGE_FAULT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_page_fault " "error: page fault accessing guest physical address 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr);
}
}
static inline void trace_amdvi_page_fault(uint64_t addr)
{
if (true) {
_nocheck__trace_amdvi_page_fault(addr);
}
}
#define TRACE_AMDVI_IOTLB_HIT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IOTLB_HIT) || \
false)
static inline void _nocheck__trace_amdvi_iotlb_hit(uint8_t bus, uint8_t slot, uint8_t func, uint64_t addr, uint64_t txaddr)
{
if (trace_event_get_state(TRACE_AMDVI_IOTLB_HIT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_iotlb_hit " "hit iotlb devid %02x:%02x.%x gpa 0x%"PRIx64" hpa 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, slot, func, addr, txaddr);
}
}
static inline void trace_amdvi_iotlb_hit(uint8_t bus, uint8_t slot, uint8_t func, uint64_t addr, uint64_t txaddr)
{
if (true) {
_nocheck__trace_amdvi_iotlb_hit(bus, slot, func, addr, txaddr);
}
}
#define TRACE_AMDVI_TRANSLATION_RESULT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_TRANSLATION_RESULT) || \
false)
static inline void _nocheck__trace_amdvi_translation_result(uint8_t bus, uint8_t slot, uint8_t func, uint64_t addr, uint64_t txaddr)
{
if (trace_event_get_state(TRACE_AMDVI_TRANSLATION_RESULT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_translation_result " "devid: %02x:%02x.%x gpa 0x%"PRIx64" hpa 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, bus, slot, func, addr, txaddr);
}
}
static inline void trace_amdvi_translation_result(uint8_t bus, uint8_t slot, uint8_t func, uint64_t addr, uint64_t txaddr)
{
if (true) {
_nocheck__trace_amdvi_translation_result(bus, slot, func, addr, txaddr);
}
}
#define TRACE_AMDVI_MEM_IR_WRITE_REQ_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_MEM_IR_WRITE_REQ) || \
false)
static inline void _nocheck__trace_amdvi_mem_ir_write_req(uint64_t addr, uint64_t val, uint32_t size)
{
if (trace_event_get_state(TRACE_AMDVI_MEM_IR_WRITE_REQ) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_mem_ir_write_req " "addr 0x%"PRIx64" data 0x%"PRIx64" size 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, val, size);
}
}
static inline void trace_amdvi_mem_ir_write_req(uint64_t addr, uint64_t val, uint32_t size)
{
if (true) {
_nocheck__trace_amdvi_mem_ir_write_req(addr, val, size);
}
}
#define TRACE_AMDVI_MEM_IR_WRITE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_MEM_IR_WRITE) || \
false)
static inline void _nocheck__trace_amdvi_mem_ir_write(uint64_t addr, uint64_t val)
{
if (trace_event_get_state(TRACE_AMDVI_MEM_IR_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_mem_ir_write " "addr 0x%"PRIx64" data 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, val);
}
}
static inline void trace_amdvi_mem_ir_write(uint64_t addr, uint64_t val)
{
if (true) {
_nocheck__trace_amdvi_mem_ir_write(addr, val);
}
}
#define TRACE_AMDVI_IR_REMAP_MSI_REQ_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_REMAP_MSI_REQ) || \
false)
static inline void _nocheck__trace_amdvi_ir_remap_msi_req(uint64_t addr, uint64_t data, uint8_t devid)
{
if (trace_event_get_state(TRACE_AMDVI_IR_REMAP_MSI_REQ) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_remap_msi_req " "addr 0x%"PRIx64" data 0x%"PRIx64" devid 0x%"PRIx8 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, data, devid);
}
}
static inline void trace_amdvi_ir_remap_msi_req(uint64_t addr, uint64_t data, uint8_t devid)
{
if (true) {
_nocheck__trace_amdvi_ir_remap_msi_req(addr, data, devid);
}
}
#define TRACE_AMDVI_IR_REMAP_MSI_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_REMAP_MSI) || \
false)
static inline void _nocheck__trace_amdvi_ir_remap_msi(uint64_t addr, uint64_t data, uint64_t addr2, uint64_t data2)
{
if (trace_event_get_state(TRACE_AMDVI_IR_REMAP_MSI) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_remap_msi " "(addr 0x%"PRIx64", data 0x%"PRIx64") -> (addr 0x%"PRIx64", data 0x%"PRIx64")" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, data, addr2, data2);
}
}
static inline void trace_amdvi_ir_remap_msi(uint64_t addr, uint64_t data, uint64_t addr2, uint64_t data2)
{
if (true) {
_nocheck__trace_amdvi_ir_remap_msi(addr, data, addr2, data2);
}
}
#define TRACE_AMDVI_ERR_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_ERR) || \
false)
static inline void _nocheck__trace_amdvi_err(const char * str)
{
if (trace_event_get_state(TRACE_AMDVI_ERR) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_err " "%s" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, str);
}
}
static inline void trace_amdvi_err(const char * str)
{
if (true) {
_nocheck__trace_amdvi_err(str);
}
}
#define TRACE_AMDVI_IR_IRTE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_IRTE) || \
false)
static inline void _nocheck__trace_amdvi_ir_irte(uint64_t addr, uint64_t data)
{
if (trace_event_get_state(TRACE_AMDVI_IR_IRTE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_irte " "addr 0x%"PRIx64" offset 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, addr, data);
}
}
static inline void trace_amdvi_ir_irte(uint64_t addr, uint64_t data)
{
if (true) {
_nocheck__trace_amdvi_ir_irte(addr, data);
}
}
#define TRACE_AMDVI_IR_IRTE_VAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_IRTE_VAL) || \
false)
static inline void _nocheck__trace_amdvi_ir_irte_val(uint32_t data)
{
if (trace_event_get_state(TRACE_AMDVI_IR_IRTE_VAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_irte_val " "data 0x%"PRIx32 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, data);
}
}
static inline void trace_amdvi_ir_irte_val(uint32_t data)
{
if (true) {
_nocheck__trace_amdvi_ir_irte_val(data);
}
}
#define TRACE_AMDVI_IR_ERR_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_ERR) || \
false)
static inline void _nocheck__trace_amdvi_ir_err(const char * str)
{
if (trace_event_get_state(TRACE_AMDVI_IR_ERR) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_err " "%s" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, str);
}
}
static inline void trace_amdvi_ir_err(const char * str)
{
if (true) {
_nocheck__trace_amdvi_ir_err(str);
}
}
#define TRACE_AMDVI_IR_INTCTL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_INTCTL) || \
false)
static inline void _nocheck__trace_amdvi_ir_intctl(uint8_t val)
{
if (trace_event_get_state(TRACE_AMDVI_IR_INTCTL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_intctl " "int_ctl 0x%"PRIx8 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, val);
}
}
static inline void trace_amdvi_ir_intctl(uint8_t val)
{
if (true) {
_nocheck__trace_amdvi_ir_intctl(val);
}
}
#define TRACE_AMDVI_IR_TARGET_ABORT_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_TARGET_ABORT) || \
false)
static inline void _nocheck__trace_amdvi_ir_target_abort(const char * str)
{
if (trace_event_get_state(TRACE_AMDVI_IR_TARGET_ABORT) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_target_abort " "%s" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, str);
}
}
static inline void trace_amdvi_ir_target_abort(const char * str)
{
if (true) {
_nocheck__trace_amdvi_ir_target_abort(str);
}
}
#define TRACE_AMDVI_IR_DELIVERY_MODE_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_DELIVERY_MODE) || \
false)
static inline void _nocheck__trace_amdvi_ir_delivery_mode(const char * str)
{
if (trace_event_get_state(TRACE_AMDVI_IR_DELIVERY_MODE) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_delivery_mode " "%s" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, str);
}
}
static inline void trace_amdvi_ir_delivery_mode(const char * str)
{
if (true) {
_nocheck__trace_amdvi_ir_delivery_mode(str);
}
}
#define TRACE_AMDVI_IR_IRTE_GA_VAL_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_AMDVI_IR_IRTE_GA_VAL) || \
false)
static inline void _nocheck__trace_amdvi_ir_irte_ga_val(uint64_t hi, uint64_t lo)
{
if (trace_event_get_state(TRACE_AMDVI_IR_IRTE_GA_VAL) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:amdvi_ir_irte_ga_val " "hi 0x%"PRIx64" lo 0x%"PRIx64 "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, hi, lo);
}
}
static inline void trace_amdvi_ir_irte_ga_val(uint64_t hi, uint64_t lo)
{
if (true) {
_nocheck__trace_amdvi_ir_irte_ga_val(hi, lo);
}
}
#define TRACE_VMPORT_REGISTER_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VMPORT_REGISTER) || \
false)
static inline void _nocheck__trace_vmport_register(unsigned char command, void * func, void * opaque)
{
if (trace_event_get_state(TRACE_VMPORT_REGISTER) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vmport_register " "command: 0x%02x func: %p opaque: %p" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, command, func, opaque);
}
}
static inline void trace_vmport_register(unsigned char command, void * func, void * opaque)
{
if (true) {
_nocheck__trace_vmport_register(command, func, opaque);
}
}
#define TRACE_VMPORT_COMMAND_BACKEND_DSTATE() ( \
trace_event_get_state_dynamic_by_id(TRACE_VMPORT_COMMAND) || \
false)
static inline void _nocheck__trace_vmport_command(unsigned char command)
{
if (trace_event_get_state(TRACE_VMPORT_COMMAND) && qemu_loglevel_mask(LOG_TRACE)) {
struct timeval _now;
gettimeofday(&_now, NULL);
qemu_log("%d@%zu.%06zu:vmport_command " "command: 0x%02x" "\n",
qemu_get_thread_id(),
(size_t)_now.tv_sec, (size_t)_now.tv_usec
, command);
}
}
static inline void trace_vmport_command(unsigned char command)
{
if (true) {
_nocheck__trace_vmport_command(command);
}
}
#endif /* TRACE_HW_I386_GENERATED_TRACERS_H */
| 35.880707
| 175
| 0.719298
|
[
"vector"
] |
193486f53f209d4bd725c296215cb97d85cb27ff
| 172
|
h
|
C
|
docu/Concepts/VertexBufferCompoundConcept.h
|
LukasBanana/ForkENGINE
|
8b575bd1d47741ad5025a499cb87909dbabc3492
|
[
"BSD-3-Clause"
] | 13
|
2017-03-21T22:46:18.000Z
|
2020-07-30T01:31:57.000Z
|
docu/Concepts/VertexBufferCompoundConcept.h
|
LukasBanana/ForkENGINE
|
8b575bd1d47741ad5025a499cb87909dbabc3492
|
[
"BSD-3-Clause"
] | null | null | null |
docu/Concepts/VertexBufferCompoundConcept.h
|
LukasBanana/ForkENGINE
|
8b575bd1d47741ad5025a499cb87909dbabc3492
|
[
"BSD-3-Clause"
] | 2
|
2018-07-23T19:56:41.000Z
|
2020-07-30T01:32:01.000Z
|
class VertexBufferCompound : public VertexBuffer
{
public:
void SetupSubBuffers(const std::vector<VertexBufferPtr>& subVertexBuffers);
void SetupFormat();
};
| 15.636364
| 77
| 0.744186
|
[
"vector"
] |
193cc259bcf298bfd89efedfb13f5f642050467a
| 2,602
|
c
|
C
|
nitan/quest/tulong/npc/shadow1.c
|
cantona/NT6
|
073f4d491b3cfe6bfbe02fbad12db8983c1b9201
|
[
"MIT"
] | 1
|
2019-03-27T07:25:16.000Z
|
2019-03-27T07:25:16.000Z
|
nitan/quest/tulong/npc/shadow1.c
|
cantona/NT6
|
073f4d491b3cfe6bfbe02fbad12db8983c1b9201
|
[
"MIT"
] | null | null | null |
nitan/quest/tulong/npc/shadow1.c
|
cantona/NT6
|
073f4d491b3cfe6bfbe02fbad12db8983c1b9201
|
[
"MIT"
] | null | null | null |
#include <ansi.h>
inherit NPC;
void create()
{
set_name("血刀老祖--幻", ({ "xuedao laozu-shadow","shadow" }));
set("long",@LONG
這喇嘛身着黃袍，年紀極老，尖頭削耳，臉上都是皺紋。他就是血刀門第四代掌門。
不過仔細一看，似乎不象是真人。
LONG
);
set("title",HIR"血刀門第四代掌門"NOR);
set("gender", "男性");
set("age", 85);
set("attitude", "peaceful");
set("shen_type", -1);
set("str", 130);
set("int", 130);
set("con", 130);
set("dex", 130);
set("max_qi", 311000);
set("max_jing", 101100);
set("neili", 20100);
set("max_neili", 20100);
set("jiali", 50);
set("combat_exp", 180011000);
set("score", 18110000);
set_skill("lamaism", 1150);
set_skill("literate", 1180);
set_skill("force", 1180);
set_skill("parry", 1180);
set_skill("blade", 1180);
set_skill("sword", 1120);
set_skill("dodge", 1180);
set_skill("longxiang-gong", 1180);
set_skill("shenkong-xing", 1180);
set_skill("hand", 1180);
set_skill("dashou-yin", 1180);
set_skill("mingwang-jian", 1120);
set_skill("xuedao-daofa", 2100);
map_skill("force", "longxiang-gong");
map_skill("dodge", "shenkong-xing");
map_skill("hand", "dashou-yin");
map_skill("parry", "xuedao-daofa");
map_skill("blade", "xuedao-daofa");
map_skill("sword", "mingwang-jian");
prepare_skill("hand","dashou-yin");
set("chat_chance_combat", 50);
set("chat_msg_combat", ({
(: perform_action, "blade.shendao" :),
(: perform_action, "blade.shendao" :),
(: perform_action, "blade.shendao" :),
(: perform_action, "blade.shendao" :),
(: perform_action, "blade.shendao" :),
}) );
create_family("雪山寺", 4, "弟子");
set("class", "bonze");
setup();
carry_object("/clone/weapon/blade.c")->wield();
}
int accept_fight(object ob)
{
ob=this_player();
if( !query("fighter", ob)){command("grin");command("say 好，送死的來了！\n");
set("fighter", 1, ob);
set_temp("m_success/幻影", 1, ob);
remove_call_out("kill_ob");
call_out("kill_ob", 1, ob);
return 1;
}
else
write(query("name", ob)+"，你已經上過場了！\n");}
void die()
{
object ob; message_vision("\n$N一晃，變為一縷輕煙消失了。\n", this_object());
ob = new("/quest/tulong/npc/shadow2");
ob->move(environment(this_object()));
destruct(this_object());
}
| 29.908046
| 79
| 0.519985
|
[
"object"
] |
1946ebe9fab8adad906e4b5e292ecbcb3712bc01
| 10,207
|
c
|
C
|
ueb03/src/io.c
|
NHollmann/FHW-CG1
|
126faeaf99722ea19fea953a7c1a1fc6c1913387
|
[
"MIT"
] | 3
|
2020-05-28T16:48:34.000Z
|
2020-12-02T09:35:23.000Z
|
ueb03/src/io.c
|
NHollmann/FHW-CG1
|
126faeaf99722ea19fea953a7c1a1fc6c1913387
|
[
"MIT"
] | null | null | null |
ueb03/src/io.c
|
NHollmann/FHW-CG1
|
126faeaf99722ea19fea953a7c1a1fc6c1913387
|
[
"MIT"
] | 1
|
2020-07-07T18:16:49.000Z
|
2020-07-07T18:16:49.000Z
|
/**
* @file
* Ein-/Ausgabe-Modul.
* Das Modul kapselt die Ein- und Ausgabe-Funktionalitaet (insbesondere die GLUT-
* Callbacks) des Programms.
*
* Bestandteil einer Uebung im Rahmen des Moduls Praktikum Grundlagen der Computergrafik
* an der FH Wedel.
*
* @author Nicolas Hollmann, Daniel Klintworth
*/
/* ---- System Header einbinden ---- */
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
/* ---- Eigene Header einbinden ---- */
#include "io.h"
#include "types.h"
#include "input.h"
#include "logic.h"
#include "scene.h"
#include "hud.h"
#include "debugGL.h"
/* ---- Konstanten ---- */
/** Anzahl der Aufrufe der Timer-Funktion pro Sekunde */
#define TIMER_CALLS_PS 60
/* ---- Interne Funktionen ---- */
/**
* Setzt einen Viewport fuer 3-dimensionale Darstellung
* mit perspektivischer Projektion und legt eine Kamera fest.
*
* @param x, y Position des Viewports im Fenster - (0, 0) ist die untere linke Ecke
* @param width, height Breite und Hoehe des Viewports
*/
static void set3DViewport(GLint x, GLint y, GLint width, GLint height)
{
/* Seitenverhaeltnis bestimmen */
double aspect = (double)width / height;
/* Folge Operationen beeinflussen die Projektionsmatrix */
glMatrixMode(GL_PROJECTION);
/* Einheitsmatrix laden */
glLoadIdentity();
/* Viewport-Position und -Ausdehnung bestimmen */
glViewport(x, y, width, height);
/* Perspektivische Darstellung */
gluPerspective(70, /* Oeffnungswinkel */
aspect, /* Seitenverhaeltnis */
0.05, /* nahe Clipping-Ebene */
100); /* ferne Clipping-Ebene */
/* Folge Operationen beeinflussen die Modelviewmatrix */
glMatrixMode(GL_MODELVIEW);
/* Einheitsmatrix laden */
glLoadIdentity();
}
/**
* Setzt einen Viewport fuer 2-dimensionale Darstellung.
*
* @param x, y Position des Viewports im Fenster - (0, 0) ist die untere linke Ecke
* @param width, height Breite und Hoehe des Viewports
*/
static void set2DViewport(GLint x, GLint y, GLint width, GLint height)
{
/* Seitenverhaeltnis bestimmen */
double aspect = (double)width / height;
/* Folge Operationen beeinflussen die Projektionsmatrix */
glMatrixMode(GL_PROJECTION);
/* Einheitsmatrix laden */
glLoadIdentity();
/* Viewport-Position und -Ausdehnung bestimmen */
glViewport(x, y, width, height);
/* Das Koordinatensystem bleibt immer quadratisch */
if (aspect <= 1)
{
gluOrtho2D(-1, 1, /* left, right */
-1 / aspect, 1 / aspect); /* bottom, top */
}
else
{
gluOrtho2D(-1 * aspect, 1 * aspect, /* left, right */
-1, 1); /* bottom, top */
}
/* Folge Operationen beeinflussen die Modelviewmatrix */
glMatrixMode(GL_MODELVIEW);
/* Einheitsmatrix laden */
glLoadIdentity();
}
/**
* Mouse-Button-Callback.
* @param button Taste, die den Callback ausgeloest hat.
* @param state Status der Taste, die den Callback ausgeloest hat.
* @param x X-Position des Mauszeigers beim Ausloesen des Callbacks.
* @param y Y-Position des Mauszeigers beim Ausloesen des Callbacks.
*/
static void cbMouseButton (int button, int state, int x, int y)
{
handleMouseEvent(x, y, mouseButton, button, state);
}
/**
* Mouse-Motion-Callback.
* @param x X-Position des Mauszeigers.
* @param y Y-Position des Mauszeigers.
*/
static void cbMouseMotion (int x, int y)
{
handleMouseEvent(x, y, mouseMotion, 0, 0);
}
/**
* Mouse-Passive-Motion-Callback.
* @param x X-Position des Mauszeigers.
* @param y Y-Position des Mauszeigers.
*/
static void
cbMousePassiveMotion (int x, int y)
{
handleMouseEvent(x, y, mousePassiveMotion, 0, 0);
}
/**
* Callback fuer Tastendruck.
* Ruft Ereignisbehandlung fuer Tastaturereignis auf.
*
* @param key betroffene Taste (In)
* @param x x-Position der Maus zur Zeit des Tastendrucks (In)
* @param y y-Position der Maus zur Zeit des Tastendrucks (In)
*/
static void cbKeyboard(unsigned char key, int x, int y)
{
handleKeyboardEvent(key, GLUT_DOWN, GL_FALSE, x, y);
}
/**
* Callback fuer Tastenloslassen.
* Ruft Ereignisbehandlung fuer Tastaturereignis auf.
*
* @param key betroffene Taste (In)
* @param x x-Position der Maus zur Zeit des Loslassens (In)
* @param y y-Position der Maus zur Zeit des Loslassens (In)
*/
static void cbKeyboardUp(unsigned char key, int x, int y)
{
handleKeyboardEvent(key, GLUT_UP, GL_FALSE, x, y);
}
/**
* Callback fuer Druck auf Spezialtasten.
* Ruft Ereignisbehandlung fuer Tastaturereignis auf.
*
* @param key betroffene Taste (In)
* @param x x-Position der Maus zur Zeit des Tastendrucks (In)
* @param y y-Position der Maus zur Zeit des Tastendrucks (In)
*/
static void cbSpecial(int key, int x, int y)
{
handleKeyboardEvent(key, GLUT_DOWN, GL_TRUE, x, y);
}
/**
* Callback fuer Loslassen von Spezialtasten.
* Ruft Ereignisbehandlung fuer Tastaturereignis auf.
*
* @param key betroffene Taste (In)
* @param x x-Position der Maus zur Zeit des Loslassens (In)
* @param y y-Position der Maus zur Zeit des Loslassens (In)
*/
static void cbSpecialUp(int key, int x, int y)
{
handleKeyboardEvent(key, GLUT_UP, GL_TRUE, x, y);
}
/**
* Timer-Callback.
* Initiiert Berechnung der aktuellen Position und Farben und anschliessendes
* Neuzeichnen, setzt sich selbst erneut als Timer-Callback.
*
* @param lastCallTime Zeitpunkt, zu dem die Funktion als Timer-Funktion
* registriert wurde (In)
*/
static void cbTimer(int lastCallTime)
{
/* Seit dem Programmstart vergangene Zeit in Millisekunden */
int thisCallTime = glutGet(GLUT_ELAPSED_TIME);
/* Seit dem letzten Funktionsaufruf vergangene Zeit in Sekunden */
double interval = (double)(thisCallTime - lastCallTime) / 1000.0f;
if (isPaused())
{
interval = 0.0;
}
/* Spiellogik updaten */
updateLogic(interval);
/* Wieder als Timer-Funktion registrieren */
glutTimerFunc(1000 / TIMER_CALLS_PS, cbTimer, thisCallTime);
/* Neuzeichnen anstossen */
glutPostRedisplay();
}
/**
* Zeichen-Callback.
* Loescht die Buffer, ruft das Zeichnen der Szene auf und tauscht den Front-
* und Backbuffer.
*/
static void cbDisplay(void)
{
/* Fensterdimensionen auslesen */
int width = glutGet(GLUT_WINDOW_WIDTH);
int height = glutGet(GLUT_WINDOW_HEIGHT);
/* Buffer zuruecksetzen */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* 3D Ansicht */
set3DViewport(0, 0, width, height);
if (getAnaglyphMode() == ANAGLYPH_OFF)
{
drawScene3D(EYE_CENTER);
}
else
{
glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
drawScene3D(EYE_LEFT);
glClear(GL_DEPTH_BUFFER_BIT);
glColorMask(GL_FALSE, getAnaglyphMode() == ANAGLYPH_COLOR, GL_TRUE, GL_TRUE);
drawScene3D(EYE_RIGHT);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
/* 2D Minimap */
set2DViewport(width / 3 * 2, height / 3 * 2, width / 3, height / 3);
drawScene2D();
/* HUD */
set2DViewport(0, 0, width, height);
drawHUD();
/* Objekt anzeigen */
glutSwapBuffers();
}
/**
* Registrierung der GLUT-Callback-Routinen.
*/
static void registerCallbacks(void)
{
/* Mouse-Button-Callback (wird ausgefuehrt, wenn eine Maustaste
* gedrueckt oder losgelassen wird) */
glutMouseFunc (cbMouseButton);
/* Mouse-Motion-Callback (wird ausgefuehrt, wenn die Maus bewegt wird,
* waehrend eine Maustaste gedrueckt wird) */
glutMotionFunc (cbMouseMotion);
/* Mouse-Motion-Callback (wird ausgefuehrt, wenn die Maus bewegt wird,
* waehrend keine Maustaste gedrueckt wird) */
glutPassiveMotionFunc (cbMousePassiveMotion);
/* Tasten-Druck-Callback - wird ausgefuehrt, wenn eine Taste gedrueckt wird */
glutKeyboardFunc(cbKeyboard);
/* Tasten-Loslass-Callback - wird ausgefuehrt, wenn eine Taste losgelassen
* wird */
glutKeyboardUpFunc(cbKeyboardUp);
/* Spezialtasten-Druck-Callback - wird ausgefuehrt, wenn Spezialtaste
* (F1 - F12, Links, Rechts, Oben, Unten, Bild-Auf, Bild-Ab, Pos1, Ende oder
* Einfuegen) gedrueckt wird */
glutSpecialFunc(cbSpecial);
/* Spezialtasten-Loslass-Callback - wird ausgefuehrt, wenn eine Spezialtaste
* losgelassen wird */
glutSpecialUpFunc(cbSpecialUp);
/* Automat. Tastendruckwiederholung ignorieren */
glutIgnoreKeyRepeat(1);
/* Timer-Callback - wird einmalig nach msescs Millisekunden ausgefuehrt */
glutTimerFunc(1000 / TIMER_CALLS_PS, /* msecs - bis Aufruf von func */
cbTimer, /* func - wird aufgerufen */
glutGet(GLUT_ELAPSED_TIME)); /* value - Parameter, mit dem
func aufgerufen wird */
/* Display-Callback - wird an mehreren Stellen imlizit (z.B. im Anschluss an
* Reshape-Callback) oder explizit (durch glutPostRedisplay) angestossen */
glutDisplayFunc(cbDisplay);
}
/* ---- Oeffentliche Funktionen ---- */
/**
* Initialisiert das Programm (inkl. I/O und OpenGL) und startet die
* Ereignisbehandlung.
*
* @param title Beschriftung des Fensters (In)
* @param width Breite des Fensters (In)
* @param height Hoehe des Fensters (In)
* @return ID des erzeugten Fensters, 0 im Fehlerfall
*/
int initAndStartIO(char *title, int width, int height)
{
int windowID = 0;
/* Kommandozeile imitieren */
int argc = 1;
char *argv = "cmd";
/* Glut initialisieren */
glutInit(&argc, &argv);
INFO(("Erzeuge Fenster...\n"));
/* Initialisieren des Fensters */
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); /* fuer DoubleBuffering */
glutInitWindowSize(width, height);
glutInitWindowPosition(
(glutGet(GLUT_SCREEN_WIDTH) - width) / 2,
(glutGet(GLUT_SCREEN_HEIGHT) - height) / 2);
/* Fenster erzeugen */
windowID = glutCreateWindow(title);
if (windowID)
{
INFO(("...fertig.\n\n"));
INFO(("Initialisiere Zufallsgenerator...\n"));
srand(time(0));
INFO(("...fertig.\n\n"));
INFO(("Initialisiere Szene...\n"));
if (initScene())
{
INFO(("...fertig.\n\n"));
INFO(("Initialisiere Logik...\n"));
initLevel(LEVEL_1);
INFO(("...fertig.\n\n"));
INFO(("Registriere Callbacks...\n"));
registerCallbacks();
INFO(("...fertig.\n\n"));
INFO(("Trete in Schleife der Ereignisbehandlung ein...\n"));
glutMainLoop();
}
else
{
INFO(("...fehlgeschlagen.\n\n"));
glutDestroyWindow(windowID);
windowID = 0;
}
}
else
{
INFO(("...fehlgeschlagen.\n\n"));
}
return windowID;
}
| 25.645729
| 89
| 0.700402
|
[
"3d"
] |
194a078e22db48381fa4890e6229f28600d5f31b
| 1,715
|
h
|
C
|
include/utils.h
|
alexst07/readline
|
2301312976b0878a6eca1a08648745b618cd6dd5
|
[
"Apache-2.0"
] | 3
|
2018-01-11T02:44:35.000Z
|
2021-03-09T14:28:39.000Z
|
include/utils.h
|
alexst07/readline
|
2301312976b0878a6eca1a08648745b618cd6dd5
|
[
"Apache-2.0"
] | null | null | null |
include/utils.h
|
alexst07/readline
|
2301312976b0878a6eca1a08648745b618cd6dd5
|
[
"Apache-2.0"
] | null | null | null |
#ifndef READLINE_UTILS_H
#define READLINE_UTILS_H
#include <memory>
#include <vector>
#include <string>
#include "text.h"
#include "complete.h"
namespace readline {
std::vector<std::string> SplitArgs(const std::string& line, int line_pos);
bool CheckNewArg(const std::string& line, int line_pos);
enum class ListDirType {
FILES,
DIR,
FILES_DIR
};
std::vector<std::string> ListDir(const std::string& dir, ListDirType t);
void MatchArg(const std::string& arg, List* list);
std::vector<std::string> MatchArg(const std::string& arg,
std::vector<std::string>& list);
std::vector<ItemDescr> MatchArg(const std::string& arg,
std::vector<ItemDescr>& list);
std::unique_ptr<List> MatchDirList(const std::vector<std::string>& args);
// parser the parser in last part and the rest, for example:
// /home/alex/test
// test is the last part and /home/alex/ is the rest
// supress point avoid that last part return as "." pwd
std::tuple<std::string, std::string> ParserPath(const std::string& arg,
bool supress_point = true);
std::string DirectoryFormat(const std::string& dir);
bool IsDirectory(const std::string path);
std::tuple<std::unique_ptr<List>, RetType, bool> RetDirFileList(
const std::vector<std::string>& params, bool tip, ListDirType type);
std::tuple<std::unique_ptr<List>, RetType, bool> RetList(
std::vector<std::string>&& plist, const std::vector<std::string>& params,
bool tip);
std::tuple<std::unique_ptr<List>, RetType, bool> RetList(
std::vector<ItemDescr>&& plist_descr,
const std::vector<std::string>& params, bool tip);
std::wstring str2wstr(const std::string& str);
std::string wstr2str(const std::wstring& wstr);
}
#endif // READLINE_UTILS_H
| 26.796875
| 77
| 0.715452
|
[
"vector"
] |
194b08e6df3046fe231df55556a94c0cdf8b3731
| 1,827
|
h
|
C
|
SimSpark/spark/plugin/agentsynceffector/agentsynceffector.h
|
IllyasvielEin/Robocup3dInstaller
|
12e91d9372dd08a92feebf98e916c98bc2242ff4
|
[
"MIT"
] | null | null | null |
SimSpark/spark/plugin/agentsynceffector/agentsynceffector.h
|
IllyasvielEin/Robocup3dInstaller
|
12e91d9372dd08a92feebf98e916c98bc2242ff4
|
[
"MIT"
] | null | null | null |
SimSpark/spark/plugin/agentsynceffector/agentsynceffector.h
|
IllyasvielEin/Robocup3dInstaller
|
12e91d9372dd08a92feebf98e916c98bc2242ff4
|
[
"MIT"
] | null | null | null |
/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*-
this file is part of rcssserver3D
Fri May 9 2003
Copyright (C) 2002,2003 Koblenz University
Copyright (C) 2003 RoboCup Soccer Server 3D Maintenance Group
$Id$
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef AGENTSYNCEFFECTOR_H
#define AGENTSYNCEFFECTOR_H
#include <oxygen/agentaspect/effector.h>
class AgentSyncEffector : public oxygen::Effector
{
public:
AgentSyncEffector();
virtual ~AgentSyncEffector();
/** realize the sync action asap */
virtual bool Realize(boost::shared_ptr<oxygen::ActionObject> action);
/** returns the name of the predicate this effector implements. */
virtual std::string GetPredicate() { return "syn"; }
/** constructs an Actionobject, describing a predicate */
virtual boost::shared_ptr<oxygen::ActionObject>
GetActionObject(const oxygen::Predicate& predicate);
/** setup the reference to the agent aspect node */
virtual void OnLink();
/** remove the reference to the agent aspect node */
virtual void OnUnlink();
private:
boost::shared_ptr<oxygen::AgentAspect> mAgentAspect;
};
DECLARE_CLASS(AgentSyncEffector);
#endif // AGENTSYNCEFFECTOR_H
| 32.625
| 73
| 0.731801
|
[
"3d"
] |
19522ae29811a7aa4b895b187ff88707521aa0e2
| 15,909
|
h
|
C
|
include/swift/Reflection/TypeRef.h
|
ramki1979/swift
|
ed1b753995dab77c63e9a06f9d18dbecbfc97f8d
|
[
"Apache-2.0"
] | 2
|
2021-08-15T15:59:22.000Z
|
2021-11-17T10:55:28.000Z
|
include/swift/Reflection/TypeRef.h
|
ramki1979/swift
|
ed1b753995dab77c63e9a06f9d18dbecbfc97f8d
|
[
"Apache-2.0"
] | null | null | null |
include/swift/Reflection/TypeRef.h
|
ramki1979/swift
|
ed1b753995dab77c63e9a06f9d18dbecbfc97f8d
|
[
"Apache-2.0"
] | null | null | null |
//===--- TypeRef.h - Swift Type References for Reflection -------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// Implements the structures of type references for property and enum
// case reflection.
//
//===----------------------------------------------------------------------===//
#ifndef SWIFT_REFLECTION_TYPEREF_H
#define SWIFT_REFLECTION_TYPEREF_H
#include "swift/Basic/Demangle.h"
#include "llvm/Support/Casting.h"
#include <iostream>
class NodePointer;
namespace swift {
namespace reflection {
class ReflectionContext;
using llvm::cast;
enum class TypeRefKind {
#define TYPEREF(Id, Parent) Id,
#include "swift/Reflection/TypeRefs.def"
#undef TYPEREF
};
class TypeRef;
using TypeRefPointer = std::shared_ptr<TypeRef>;
using ConstTypeRefPointer = std::shared_ptr<const TypeRef>;
using TypeRefVector = std::vector<TypeRefPointer>;
using ConstTypeRefVector = const std::vector<TypeRefPointer>;
class TypeRef : public std::enable_shared_from_this<TypeRef> {
TypeRefKind Kind;
public:
TypeRef(TypeRefKind Kind) : Kind(Kind) {}
TypeRefKind getKind() const {
return Kind;
}
void dump() const;
void dump(std::ostream &OS, unsigned Indent = 0) const;
};
class BuiltinTypeRef final : public TypeRef {
std::string MangledName;
public:
BuiltinTypeRef(std::string MangledName)
: TypeRef(TypeRefKind::Builtin), MangledName(MangledName) {}
static std::shared_ptr<BuiltinTypeRef> create(std::string MangledName) {
return std::make_shared<BuiltinTypeRef>(MangledName);
}
std::string getMangledName() const {
return MangledName;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::Builtin;
}
};
class NominalTypeRef final : public TypeRef {
std::string MangledName;
public:
NominalTypeRef(std::string MangledName)
: TypeRef(TypeRefKind::Nominal), MangledName(MangledName) {}
static std::shared_ptr<NominalTypeRef> create(std::string MangledName) {
return std::make_shared<NominalTypeRef>(MangledName);
}
std::string getMangledName() const {
return MangledName;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::Nominal;
}
};
class BoundGenericTypeRef final : public TypeRef {
std::string MangledName;
TypeRefVector GenericParams;
public:
BoundGenericTypeRef(std::string MangledName, TypeRefVector GenericParams)
: TypeRef(TypeRefKind::BoundGeneric),
MangledName(MangledName),
GenericParams(GenericParams) {}
static std::shared_ptr<BoundGenericTypeRef>
create(std::string MangledName, TypeRefVector GenericParams) {
return std::make_shared<BoundGenericTypeRef>(MangledName, GenericParams);
}
std::string getMangledName() const {
return MangledName;
}
TypeRefVector getGenericParams() {
return GenericParams;
}
ConstTypeRefVector getGenericParams() const {
return GenericParams;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::BoundGeneric;
}
};
class TupleTypeRef final : public TypeRef {
TypeRefVector Elements;
public:
TupleTypeRef(TypeRefVector Elements)
: TypeRef(TypeRefKind::Tuple), Elements(Elements) {}
static std::shared_ptr<TupleTypeRef> create(TypeRefVector Elements) {
return std::make_shared<TupleTypeRef>(Elements);
}
TypeRefVector getElements() {
return Elements;
};
ConstTypeRefVector getElements() const {
return Elements;
};
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::Tuple;
}
};
class FunctionTypeRef final : public TypeRef {
TypeRefPointer Input;
TypeRefPointer Result;
public:
FunctionTypeRef(TypeRefPointer Input, TypeRefPointer Result)
: TypeRef(TypeRefKind::Function), Input(Input), Result(Result) {}
static std::shared_ptr<FunctionTypeRef> create(TypeRefPointer Input,
TypeRefPointer Result) {
return std::make_shared<FunctionTypeRef>(Input, Result);
}
TypeRefPointer getInput() {
return Input;
};
ConstTypeRefPointer getInput() const {
return Input;
};
TypeRefPointer getResult() {
return Result;
}
ConstTypeRefPointer getResult() const {
return Result;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::Function;
}
};
class ProtocolTypeRef final : public TypeRef {
std::string ModuleName;
std::string Name;
public:
ProtocolTypeRef(std::string ModuleName, std::string Name)
: TypeRef(TypeRefKind::Protocol), ModuleName(ModuleName), Name(Name) {}
static std::shared_ptr<ProtocolTypeRef>
create(std::string ModuleName, std::string Name) {
return std::make_shared<ProtocolTypeRef>(ModuleName, Name);
}
std::string getName() const {
return Name;
}
std::string getModuleName() const {
return ModuleName;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::Protocol;
}
};
class ProtocolCompositionTypeRef final : public TypeRef {
TypeRefVector Protocols;
public:
ProtocolCompositionTypeRef(TypeRefVector Protocols)
: TypeRef(TypeRefKind::ProtocolComposition), Protocols(Protocols) {}
static std::shared_ptr<ProtocolCompositionTypeRef>
create(TypeRefVector Protocols) {
return std::make_shared<ProtocolCompositionTypeRef>(Protocols);
}
TypeRefVector getProtocols() {
return Protocols;
}
ConstTypeRefVector getProtocols() const {
return Protocols;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::ProtocolComposition;
}
};
class MetatypeTypeRef final : public TypeRef {
TypeRefPointer InstanceType;
public:
MetatypeTypeRef(TypeRefPointer InstanceType)
: TypeRef(TypeRefKind::Metatype), InstanceType(InstanceType) {}
static std::shared_ptr<MetatypeTypeRef> create(TypeRefPointer InstanceType) {
return std::make_shared<MetatypeTypeRef>(InstanceType);
}
TypeRefPointer getInstanceType() {
return InstanceType;
}
ConstTypeRefPointer getInstanceType() const {
return InstanceType;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::Metatype;
}
};
class ExistentialMetatypeTypeRef final : public TypeRef {
TypeRefPointer InstanceType;
public:
ExistentialMetatypeTypeRef(TypeRefPointer InstanceType)
: TypeRef(TypeRefKind::ExistentialMetatype), InstanceType(InstanceType) {}
static std::shared_ptr<ExistentialMetatypeTypeRef>
create(TypeRefPointer InstanceType) {
return std::make_shared<ExistentialMetatypeTypeRef>(InstanceType);
}
TypeRefPointer getInstanceType() {
return InstanceType;
}
ConstTypeRefPointer getInstanceType() const {
return InstanceType;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::ExistentialMetatype;
}
};
class GenericTypeParameterTypeRef final : public TypeRef {
const uint32_t Index;
const uint32_t Depth;
public:
GenericTypeParameterTypeRef(uint32_t Index, uint32_t Depth)
: TypeRef(TypeRefKind::GenericTypeParameter), Index(Index), Depth(Depth) {}
static std::shared_ptr<GenericTypeParameterTypeRef>
create(uint32_t Index, uint32_t Depth) {
return std::make_shared<GenericTypeParameterTypeRef>(Index, Depth);
}
uint32_t getIndex() const {
return Index;
}
uint32_t getDepth() const {
return Depth;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::GenericTypeParameter;
}
};
class DependentMemberTypeRef final : public TypeRef {
TypeRefPointer Member;
TypeRefPointer Base;
public:
DependentMemberTypeRef(TypeRefPointer Member, TypeRefPointer Base)
: TypeRef(TypeRefKind::DependentMember), Member(Member), Base(Base) {}
static std::shared_ptr<DependentMemberTypeRef>
create(TypeRefPointer Member, TypeRefPointer Base) {
return std::make_shared<DependentMemberTypeRef>(Member, Base);
}
TypeRefPointer getMember() {
return Member;
}
ConstTypeRefPointer getMember() const {
return Member;
}
TypeRefPointer getBase() {
return Base;
}
ConstTypeRefPointer getBase() const {
return Base;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::DependentMember;
}
};
class AssociatedTypeRef final : public TypeRef {
std::string Name;
public:
AssociatedTypeRef(std::string Name)
: TypeRef(TypeRefKind::Associated), Name(Name) {}
static std::shared_ptr<AssociatedTypeRef> create(std::string Name) {
return std::make_shared<AssociatedTypeRef>(Name);
}
std::string getName() const {
return Name;
}
static bool classof(const TypeRef *TR) {
return TR->getKind() == TypeRefKind::Associated;
}
};
template <typename ImplClass, typename RetTy = void, typename... Args>
class TypeRefVisitor {
public:
RetTy visit(const TypeRef *typeRef, Args... args) {
switch (typeRef->getKind()) {
#define TYPEREF(Id, Parent) \
case TypeRefKind::Id: \
return static_cast<ImplClass*>(this) \
->visit##Id##TypeRef(cast<Id##TypeRef>(typeRef), \
::std::forward<Args>(args)...);
#include "swift/Reflection/TypeRefs.def"
}
}
};
class PrintTypeRef : public TypeRefVisitor<PrintTypeRef, void> {
std::ostream &OS;
unsigned Indent;
std::ostream &indent(unsigned Amount) {
for (unsigned i = 0; i < Amount; ++i)
OS << ' ';
return OS;
}
std::ostream &printHeader(std::string Name) {
indent(Indent) << '(' << Name;
return OS;
}
template<typename T>
std::ostream &printField(std::string name, const T &value) {
if (!name.empty())
OS << " " << name << "=" << value;
else
OS << " " << value;
return OS;
}
void printRec(const TypeRef *typeRef) {
OS << "\n";
if (typeRef == nullptr)
OS << "<<null>>";
else {
Indent += 2;
visit(typeRef);
Indent -=2;
}
}
public:
PrintTypeRef(std::ostream &OS, unsigned Indent)
: OS(OS), Indent(Indent) {}
void visitBuiltinTypeRef(const BuiltinTypeRef *B) {
printHeader("builtin");
auto demangled = Demangle::demangleTypeAsString(B->getMangledName());
printField("", demangled);
OS << ')';
}
void visitNominalTypeRef(const NominalTypeRef *N) {
printHeader("nominal");
auto demangled = Demangle::demangleTypeAsString(N->getMangledName());
printField("", demangled);
OS << ')';
}
void visitBoundGenericTypeRef(const BoundGenericTypeRef *BG) {
printHeader("bound-generic");
auto demangled = Demangle::demangleTypeAsString(BG->getMangledName());
printField("", demangled);
for (auto param : BG->getGenericParams())
printRec(param.get());
OS << ')';
}
void visitTupleTypeRef(const TupleTypeRef *T) {
printHeader("tuple");
for (auto element : T->getElements())
printRec(element.get());
OS << ')';
}
void visitFunctionTypeRef(const FunctionTypeRef *F) {
printHeader("function");
printRec(F->getInput().get());
printRec(F->getResult().get());
OS << ')';
}
void visitProtocolTypeRef(const ProtocolTypeRef *P) {
printHeader("protocol");
printField("module", P->getModuleName());
printField("name", P->getName());
OS << ')';
}
void visitProtocolCompositionTypeRef(const ProtocolCompositionTypeRef *PC) {
printHeader("protocol-composition");
for (auto protocol : PC->getProtocols())
printRec(protocol.get());
OS << ')';
}
void visitMetatypeTypeRef(const MetatypeTypeRef *M) {
printHeader("metatype");
printRec(M->getInstanceType().get());
OS << ')';
}
void visitExistentialMetatypeTypeRef(const ExistentialMetatypeTypeRef *EM) {
printHeader("existential-metatype");
printRec(EM->getInstanceType().get());
OS << ')';
}
void visitGenericTypeParameterTypeRef(const GenericTypeParameterTypeRef *GTP){
printHeader("generic-type-parameter");
printField("index", GTP->getIndex());
printField("depth", GTP->getDepth());
OS << ')';
}
void visitDependentMemberTypeRef(const DependentMemberTypeRef *DM) {
printHeader("dependent-member");
printRec(DM->getBase().get());
printRec(DM->getMember().get());
OS << ')';
}
void visitAssociatedTypeRef(const AssociatedTypeRef *AT) {
printHeader("associated-type");
printField("name", AT->getName());
OS << ')';
}
};
TypeRefPointer decodeDemangleNode(Demangle::NodePointer Node) {
using NodeKind = Demangle::Node::Kind;
switch (Node->getKind()) {
case NodeKind::Type:
return decodeDemangleNode(Node->getChild(0));
case NodeKind::BoundGenericClass:
case NodeKind::BoundGenericEnum:
case NodeKind::BoundGenericStructure: {
auto mangledName = Demangle::mangleNode(Node->getChild(0));
auto genericArgs = Node->getChild(1);
TypeRefVector Params;
for (auto genericArg : *genericArgs)
Params.push_back(decodeDemangleNode(genericArg));
return BoundGenericTypeRef::create(mangledName, Params);
}
case NodeKind::Class:
case NodeKind::Enum:
case NodeKind::Structure: {
auto mangledName = Demangle::mangleNode(Node);
return NominalTypeRef::create(mangledName);
}
case NodeKind::BuiltinTypeName: {
auto mangledName = Demangle::mangleNode(Node);
return BuiltinTypeRef::create(mangledName);
}
case NodeKind::ExistentialMetatype: {
auto instance = decodeDemangleNode(Node->getChild(0));
return ExistentialMetatypeTypeRef::create(instance);
}
case NodeKind::Metatype: {
auto instance = decodeDemangleNode(Node->getChild(0));
return MetatypeTypeRef::create(instance);
}
case NodeKind::Protocol: {
auto moduleName = Node->getChild(0)->getText();
auto name = Node->getChild(1)->getText();
return ProtocolTypeRef::create(moduleName, name);
}
case NodeKind::DependentGenericParamType: {
auto depth = Node->getChild(0)->getIndex();
auto index = Node->getChild(1)->getIndex();
return GenericTypeParameterTypeRef::create(index, depth);
}
case NodeKind::FunctionType: {
auto input = decodeDemangleNode(Node->getChild(0));
auto result = decodeDemangleNode(Node->getChild(1));
return FunctionTypeRef::create(input, result);
}
case NodeKind::ArgumentTuple:
return decodeDemangleNode(Node->getChild(0));
case NodeKind::ReturnType:
return decodeDemangleNode(Node->getChild(0));
case NodeKind::NonVariadicTuple: {
TypeRefVector Elements;
for (auto element : *Node)
Elements.push_back(decodeDemangleNode(element));
return TupleTypeRef::create(Elements);
}
case NodeKind::TupleElement:
return decodeDemangleNode(Node->getChild(0));
case NodeKind::DependentGenericType: {
return decodeDemangleNode(Node->getChild(1));
}
case NodeKind::DependentMemberType: {
auto member = decodeDemangleNode(Node->getChild(0));
auto base = decodeDemangleNode(Node->getChild(1));
return DependentMemberTypeRef::create(member, base);
}
case NodeKind::DependentAssociatedTypeRef:
return AssociatedTypeRef::create(Node->getText());
default:
return nullptr;
}
}
void TypeRef::dump() const {
dump(std::cerr);
}
void TypeRef::dump(std::ostream &OS, unsigned Indent) const {
PrintTypeRef(OS, Indent).visit(this);
OS << "\n";
}
} // end namespace reflection
} // end namespace swift
#endif // SWIFT_REFLECTION_TYPEREF_H
| 26.603679
| 80
| 0.68829
|
[
"vector"
] |
19550db59c53b68cc0c7d9d1c3e15bf697874289
| 4,967
|
h
|
C
|
Source/Foundation/bsfUtility/ThirdParty/simdpp/detail/shuffle/neon_int64x2.h
|
Milerius/bsf
|
8715b344d6b7893f64fd5dccaaf10603a27c7a15
|
[
"MIT"
] | 1,745
|
2018-03-16T02:10:28.000Z
|
2022-03-26T17:34:21.000Z
|
include/simdpp/detail/shuffle/neon_int64x2.h
|
leannejdong/MGOSDT
|
29559e5feb19490e77b11d0382558cd8529feba4
|
[
"BSD-3-Clause"
] | 395
|
2018-03-16T10:18:20.000Z
|
2021-08-04T16:52:08.000Z
|
include/simdpp/detail/shuffle/neon_int64x2.h
|
leannejdong/MGOSDT
|
29559e5feb19490e77b11d0382558cd8529feba4
|
[
"BSD-3-Clause"
] | 267
|
2018-03-17T19:32:54.000Z
|
2022-02-17T16:55:50.000Z
|
/* Copyright (C) 2011-2012 Povilas Kanapickas <[email protected]>
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef LIBSIMDPP_DETAIL_SHUFFLE_NEON_INT64x2_H
#define LIBSIMDPP_DETAIL_SHUFFLE_NEON_INT64x2_H
#if SIMDPP_USE_NEON
#include <type_traits>
namespace simdpp {
namespace SIMDPP_ARCH_NAMESPACE {
namespace detail {
namespace neon_shuffle_int64x2 {
#if SIMDPP_USE_NEON32
/*
The code below implements generalized permutations of elements within
int64x2 vectors using half-vector move instructions available on NEON.
*/
using T = uint64x2; // full vector
using H = uint64x1_t; // half vector
/// Returns the lower/higher part of a vector. Cost: 0
SIMDPP_INL H lo(T a) { return vget_low_u64(a.native()); }
SIMDPP_INL H hi(T a) { return vget_high_u64(a.native()); }
/// Combines two half vectors. Cost: 0
SIMDPP_INL T co(H lo, H hi) { return vcombine_u64(lo, hi); }
// 2-element permutation
template<unsigned s0, unsigned s1> SIMDPP_INL
T permute2(T a)
{
const unsigned sel = s0*2 + s1;
switch (sel) {
default:
case 0: /*00*/ return co(lo(a), lo(a));
case 1: /*01*/ return a;
case 2: /*10*/ return co(hi(a), lo(a));
case 3: /*11*/ return co(hi(a), hi(a));
}
}
// 2-element shuffle: the first element must come from a, the second - from b
template<unsigned s0, unsigned s1> SIMDPP_INL
T shuffle1(T a, T b)
{
const unsigned sel = s0*2 + s1;
switch (sel) {
default:
case 0: /*00*/ return co(lo(a), lo(b));
case 1: /*01*/ return co(lo(a), hi(b));
case 2: /*10*/ return co(hi(a), lo(b));
case 3: /*11*/ return co(hi(a), hi(b));
}
}
template<unsigned s0, unsigned s1> SIMDPP_INL
T shuffle2x2(const T& a, const T& b)
{
const unsigned sel = s0*4 + s1;
switch (sel) {
default:
case 0: /*00*/ return co(lo(a), lo(a));
case 1: /*01*/ return a;
case 2: /*02*/ return co(lo(a), lo(b));
case 3: /*03*/ return co(lo(a), hi(b));
case 4: /*10*/ return co(hi(a), lo(a));
case 5: /*11*/ return co(hi(a), hi(a));
case 6: /*12*/ return co(hi(a), lo(b));
case 7: /*13*/ return co(hi(a), hi(b));
case 8: /*20*/ return co(lo(b), lo(a));
case 9: /*21*/ return co(lo(b), hi(a));
case 10: /*22*/ return co(lo(b), lo(b));
case 11: /*23*/ return b;
case 12: /*30*/ return co(hi(b), lo(a));
case 13: /*31*/ return co(hi(b), hi(a));
case 14: /*32*/ return co(hi(b), lo(b));
case 15: /*33*/ return co(hi(b), hi(b));
}
}
#else // SIMDPP_USE_NEON64
using T = uint64x2; // full vector
// Moves the high half of b onto high half of a
SIMDPP_INL T move_hi(const T& a, const T& b)
{
T mask = make_uint(0xffffffffffffffff, 0x0);
return vbslq_u64(mask.native(), a.native(), b.native());
}
// 2-element permutation
template<unsigned s0, unsigned s1> SIMDPP_INL
T permute2(const T& a)
{
const unsigned sel = s0*2 + s1;
switch (sel) {
default:
case 0: /*00*/ return vzip1q_u64(a.native(), a.native());
case 1: /*01*/ return a;
case 2: /*10*/ return vextq_u64(a.native(), a.native(), 1);
case 3: /*11*/ return vzip2q_u64(a.native(), a.native());
}
}
// 2-element shuffle: the first element must come from a, the second - from b
template<unsigned s0, unsigned s1> SIMDPP_INL
T shuffle1(const T& a, const T& b)
{
const unsigned sel = s0*2 + s1;
switch (sel) {
default:
case 0: /*00*/ return vzip1q_u64(a.native(), b.native());
case 1: /*01*/ return move_hi(a, b);
case 2: /*10*/ return vextq_u64(a.native(), b.native(), 1);
case 3: /*11*/ return vzip2q_u64(a.native(), b.native());
}
}
template<unsigned s0, unsigned s1> SIMDPP_INL
T shuffle2x2(const T& a, const T& b)
{
const unsigned sel = s0*4 + s1;
switch (sel) {
default:
case 0: /*00*/ return vzip1q_u64(a.native(), a.native());
case 1: /*01*/ return a;
case 2: /*02*/ return vzip1q_u64(a.native(), b.native());
case 3: /*03*/ return move_hi(a, b);
case 4: /*10*/ return vextq_u64(a.native(), a.native(), 1);
case 5: /*11*/ return vzip2q_u64(a.native(), a.native());
case 6: /*12*/ return vextq_u64(a.native(), b.native(), 1);
case 7: /*13*/ return vzip2q_u64(a.native(), b.native());
case 8: /*20*/ return vzip1q_u64(b.native(), a.native());
case 9: /*21*/ return move_hi(b, a);
case 10: /*22*/ return vzip1q_u64(b.native(), b.native());
case 11: /*23*/ return b;
case 12: /*30*/ return vextq_u64(b.native(), a.native(), 1);
case 13: /*31*/ return vzip2q_u64(b.native(), a.native());
case 14: /*32*/ return vextq_u64(b.native(), b.native(), 1);
case 15: /*33*/ return vzip2q_u64(b.native(), b.native());
}
}
#endif
} // namespace neon_shuffle_int64x2
} // namespace detail
} // namespace SIMDPP_ARCH_NAMESPACE
} // namespace simdpp
#endif
#endif
| 30.472393
| 77
| 0.610429
|
[
"vector"
] |
19567bbcf719f32c0db85fe872e1484a83e3e1a1
| 5,587
|
h
|
C
|
Projects/EduBtM/Header/EduBtM_errorcodes.h
|
probifrost/CS360DB
|
b46fb9b40405a8a408ac5fee3613a73a2075869d
|
[
"BSD-3-Clause"
] | 10
|
2015-09-10T07:10:21.000Z
|
2020-07-09T06:20:25.000Z
|
Projects/EduBtM/Header/EduBtM_errorcodes.h
|
probifrost/CS360DB
|
b46fb9b40405a8a408ac5fee3613a73a2075869d
|
[
"BSD-3-Clause"
] | null | null | null |
Projects/EduBtM/Header/EduBtM_errorcodes.h
|
probifrost/CS360DB
|
b46fb9b40405a8a408ac5fee3613a73a2075869d
|
[
"BSD-3-Clause"
] | 15
|
2015-09-10T07:50:13.000Z
|
2022-03-01T09:20:40.000Z
|
/******************************************************************************/
/* */
/* Copyright (c) 2013-2015, Kyu-Young Whang, KAIST */
/* All rights reserved. */
/* */
/* Redistribution and use in source and binary forms, with or without */
/* modification, are permitted provided that the following conditions */
/* are met: */
/* */
/* 1. Redistributions of source code must retain the above copyright */
/* notice, this list of conditions and the following disclaimer. */
/* */
/* 2. Redistributions in binary form must reproduce the above copyright */
/* notice, this list of conditions and the following disclaimer in */
/* the documentation and/or other materials provided with the */
/* distribution. */
/* */
/* 3. Neither the name of the copyright holder nor the names of its */
/* contributors may be used to endorse or promote products derived */
/* from this software without specific prior written permission. */
/* */
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */
/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE */
/* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, */
/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, */
/* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; */
/* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER */
/* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT */
/* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN */
/* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
/* POSSIBILITY OF SUCH DAMAGE. */
/* */
/******************************************************************************/
/******************************************************************************/
/* */
/* ODYSSEUS/EduCOSMOS Educational Purpose Object Storage System */
/* (Version 1.0) */
/* */
/* Developed by Professor Kyu-Young Whang et al. */
/* */
/* Advanced Information Technology Research Center (AITrc) */
/* Korea Advanced Institute of Science and Technology (KAIST) */
/* */
/* e-mail: [email protected] */
/* */
/******************************************************************************/
/*
* Macro Definitions
*/
#define ERR_ENCODE_ERROR_CODE(base,no) ( -1 * (((base) << 16) | no) )
/*
* Error Base Definitions
*/
#define GENERAL_ERR_BASE 1
#define BTM_ERR_BASE 7
/*
* Error Definitions for GENERAL_ERR_BASE
*/
#define eBADCURSOR ERR_ENCODE_ERROR_CODE(GENERAL_ERR_BASE,9)
/*
* Error Definitions for OM_ERR_BASE
*/
#define eBADPARAMETER_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,0)
#define eBADBTREEPAGE_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,1)
#define eBADPAGE_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,2)
#define eNOTFOUND_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,3)
#define eDUPLICATEDOBJECTID_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,4)
#define eBADCOMPOP_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,5)
#define eDUPLICATEDKEY_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,6)
#define eBADPAGETYPE_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,7)
#define eEXCEEDMAXDEPTHOFBTREE_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,8)
#define eTRAVERSEPATH_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,9)
#define eNOSUCHTREELATCH_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,10)
#define eDELETEOBJECTFAILED_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,11)
#define eBADCACHETREELATCHCELLPTR_BTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,12)
#define NUM_ERRORS_BTM_ERR_BASE 13
#define eNOTSUPPORTED_EDUBTM ERR_ENCODE_ERROR_CODE(BTM_ERR_BASE,14)
| 67.313253
| 90
| 0.456238
|
[
"object"
] |
196fa66fcfacd5b572be1fb139d77f535c6b240a
| 1,200
|
h
|
C
|
src/game/rail.h
|
le0nklcpp/eoavov
|
723a196fee89155840c6ab2bd426f4c08aee1588
|
[
"Zlib"
] | 2
|
2021-08-03T18:50:55.000Z
|
2022-03-21T20:09:28.000Z
|
src/game/rail.h
|
le0nklcpp/eoavov
|
723a196fee89155840c6ab2bd426f4c08aee1588
|
[
"Zlib"
] | null | null | null |
src/game/rail.h
|
le0nklcpp/eoavov
|
723a196fee89155840c6ab2bd426f4c08aee1588
|
[
"Zlib"
] | 1
|
2021-07-20T05:08:33.000Z
|
2021-07-20T05:08:33.000Z
|
#ifndef __GAME_RAIL_H_
#define __GAME_RAIL_H_
#include "eoavov.h"
/* This is entity for creating paths
tag - entity tag
fromtag - previous rail entity tag
totag - next rail entity tag
revert - if set to 1, then the entity moving along this route will be sent back after reaching this entity, also it marks entity route as reverted
arrivaltime - time(in millis) moving from this rail to next rail takes
/newent rail tag fromtag totag revert arrivaltime
It works like that:
railent1 --------- railent2 ---------- railent3
entity1^
-after setting entity1 route entity1 will move from railent1 to railent2, from railent2 to railent3
-moving between the rails entity1 will use the shortest path
*/
struct rail;
namespace game{
#define validrail(a) (a->arrivetime>0&&(a->revert?a->prev:a->next))
extern vector<rail*>rails;
void clearroutes();
};
struct rail{
vec o;
rail*prev,*next;
int arrivetime,tag;
bool revert;
rail(extentity&e);
~rail(){}
};
struct routeManager{
bool revert;
int timestamp;
vec dir;
rail*cur,*next;
routeManager():cur(NULL),next(NULL){}
void set(rail*c,bool r=false);
bool end();
bool finished(const vec o);
vec move();
};
#endif
| 27.272727
| 149
| 0.714167
|
[
"vector"
] |
1977c2071979303f29a8c262f6bd1e984381612e
| 7,541
|
h
|
C
|
paginglandscape/PlugIns/IPLSceneManager/include/OgreIPLVirtualPageWindow.h
|
chen0040/cpp-ogre-mllab
|
b85305cd7e95559a178664577c8e858a5b9dd05b
|
[
"MIT"
] | 1
|
2021-10-04T09:40:26.000Z
|
2021-10-04T09:40:26.000Z
|
paginglandscape/PlugIns/IPLSceneManager/include/OgreIPLVirtualPageWindow.h
|
chen0040/cpp-ogre-mllab
|
b85305cd7e95559a178664577c8e858a5b9dd05b
|
[
"MIT"
] | null | null | null |
paginglandscape/PlugIns/IPLSceneManager/include/OgreIPLVirtualPageWindow.h
|
chen0040/cpp-ogre-mllab
|
b85305cd7e95559a178664577c8e858a5b9dd05b
|
[
"MIT"
] | 6
|
2019-05-05T22:29:55.000Z
|
2022-01-03T14:18:54.000Z
|
/***************************************************************************
OgreIPLVirtualPageWindow.h
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
***************************************************************************/
#ifndef __IPLVIRTUALPAGEWINDOW_H__
#define __IPLVIRTUALPAGEWINDOW_H__
#include "OgreIPLPage.h"
#include <OgreSceneNode.h>
namespace Ogre
{
class IPLSceneManager;
/** This is a virtual window page manager for organizing Pages into a visible landscape.
*/
class IPLVirtualPageWindow
{
public:
IPLVirtualPageWindow( IPLSceneManager* sm );
virtual ~IPLVirtualPageWindow( );
/** setup page windows by initializing both page vector containers
to the required size and fill with pages in active window and NULL
in old window
@param xcount number of pages in window on x axis
@param zcount number of pages in window on z axis
*/
void setPageWindowSize( const int xcount, const int zcount );
/** update the window view based on the new position
@remarks
the window manager will shift the window view if
the view position is outside the view boundaries
if the view position is still in the view boundaries then nothing is done
*/
void updateViewPosition( const float x, const float z );
/** change the parameters that define how big the world map is
@param PageXCount number of pages that are along the X axis in the Map
@param PageZCount number of pages that are along the Z axis in the Map
@param PagePixelSize is the width and height in pixel of the height map data that defines the page
*/
void setWorldMapSize( const int PageXCount, const int PageZCount, const int PagePixelSize );
/** change the wold scale - values must be > 0
*/
void setWorldScale( const float x, const float z );
/** get the height of the terrain at the world coordinates x,z
@remarks
if the world coordinates are within the virtual page window then the actual world height
is returned. If outside the virtual window then -1 is returned
@param worldx real world position on x axis
@param worldz real world position on z axis
*/
float getWorldHeight( float worldx, float worldz );
IPLSceneManager* getSceneManager( void ) const;
SceneNode* getRootSceneNode( void ) const;
private:
void _preLoad( void );
/** swap ActiveWindow and OldWindow. Normally done after the pages have been shuffled in the window.
*/
void _switchWindow( void ); // TODO: Not implemented
/** shift the pages in the active window into the Old window
after the shift each page is informed of its new map index and new position for the scene node
Swap Active window with old window so the shuffled windows become the active view
@param ShiftX number of pages to shift on the x axis
@param SHiftY number of pages to shift on the z axis
*/
void _shufflePages( const int ShiftX, const int ShiftY );
/** notify pages in window of what map indexes and scene node position they should have
this method would be called after calling shufflePages
It is up to the pages to decide if they need to unload and reload. Moving the scene node is upto them.
*/
void _updatePageMapIndexes( void ); // TODO: Not implemented
/** checks if the world coordinates are within the window center region
returns true if the view is within the boundaries
@param worldx position on x axis in the world
@param worldz position on z axis in the world
*/
bool _isViewCentered( const float worldx, const float worldz ) const ;
/** using the world coordinates as the new center view position calculate
min x,max x, min v and max v that define the center boundaries. These boundaries are
used by isVeiwCentered to determine if the view position is still within
the center boundaries
@param x world position on world x axis
@param z world position on world y axis
*/
void _setCenterAreaBoundries( const float worldx, const float worldz );
/** convert world coordinates into page map index
assumes the map repeats in x and z direction in the world
works for negative coordinates also
normally used to find the center page in the window
@param x world coordinate on x axis
@param z world coordinate on z axis
@param PageX reference to page index on x axis that will receive converted value
@param PageZ reference to page index on z axis that will receive converted value
*/
void _getPageMapIdxFromWorldPosition( float x, float z, int & PageX, int & PageZ );
/** get the Map Page offsets using absolute page indexes
@remarks the method assumes that the map is repeating in both x and z coordinates and that the map
has a size equal or greater to one on both axis
@param AbsolutePage_x page index on x axis
@param AbsolutePage_z page index on z axis
@param MapPageOffestX reference that will receive the page offset in relation to the map on the x axis
@param MapPageOffestZ reference that will receive the page offset in relation to the map on the z axis
*/
void _getMapPageOffset( const int AbsolutePage_x, const int AbsolutePage_z, int & MapPageOffsetX, int & MapPageOffsetZ );
/** Get the Page absolute indices from a world position vector
@remarks
Method is used to find the Page indices using a world position.
Beats having to iterate through the Page list to find a page at a particular
position in the world.
The page indices returned are not clamped to the map page count.
@param worldx position on x axis
@param worldz position on z axis
@param x result placed in reference to the x index of the page
@param z result placed in reference to the z index of the page
*/
void _getWorldPageIndices( const float worldx, const float worldz, int& x, int& z );
float mWorldScale_x;
float mWorldScale_z;
int mPagePixelSize;
float mBoundryExtent;
int mWindowPageCount_x; // number of pages that make up the window along the x axis
int mWindowPageCount_z; // number of pages that make up the window along the z axis
int mWorldMap_PageCount_x; // number of pages that make up the map along x axis
int mWorldMap_PageCount_z; // number of pages that make up the map along z axis
int mAbsolutePageOffset_x; // position of window in absolute page index from origin on x axis
int mAbsolutePageOffset_z; // position of window in absolute page index from origin on z axis
int mMapPageOffset_x; // relative Map page index for bottom left corner of Window on x axis
int mMapPageOffset_z; // relative Map page index for bottom left corner of Window on z axis
// center area boundary
float mBoundryMinX;
float mBoundryMinZ;
float mBoundryMaxX;
float mBoundryMaxZ;
IPLSceneManager* mSceneManager;
SceneNode* mRootSceneNode;
typedef std::vector < IPLPage * > IPLPageRow;
typedef std::vector < IPLPageRow > IPLPages;
IPLPages mActiveWindow;
IPLPages mOldWindow;
};
}
#endif
| 38.47449
| 122
| 0.746983
|
[
"vector"
] |
1979c637aaab6f78f689aecbed7f653c14b417f5
| 959
|
h
|
C
|
include/xemmai/symbol.h
|
shin1m/xemmai
|
dbeb22058ffdec0dda7d2575b86e750b87ed4197
|
[
"MIT",
"Unlicense"
] | 5
|
2015-11-01T22:08:39.000Z
|
2021-06-08T04:44:38.000Z
|
include/xemmai/symbol.h
|
shin1m/xemmai
|
dbeb22058ffdec0dda7d2575b86e750b87ed4197
|
[
"MIT",
"Unlicense"
] | null | null | null |
include/xemmai/symbol.h
|
shin1m/xemmai
|
dbeb22058ffdec0dda7d2575b86e750b87ed4197
|
[
"MIT",
"Unlicense"
] | null | null | null |
#ifndef XEMMAI__SYMBOL_H
#define XEMMAI__SYMBOL_H
#include "object.h"
namespace xemmai
{
class t_symbol
{
friend class t_object;
friend struct t_finalizes<t_bears<t_symbol>>;
friend struct t_type_of<t_object>;
friend struct t_type_of<t_type>;
friend struct t_type_of<t_symbol>;
std::map<std::wstring, t_slot, std::less<>>::iterator v_entry;
t_symbol(std::map<std::wstring, t_slot, std::less<>>::iterator a_entry) : v_entry(a_entry)
{
v_entry->second = t_object::f_of(this);
}
~t_symbol();
public:
XEMMAI__PORTABLE__EXPORT static t_object* f_instantiate(std::wstring_view a_value);
const std::wstring& f_string() const
{
return v_entry->first;
}
};
template<>
struct t_type_of<t_symbol> : t_holds<t_symbol>
{
void f_define();
using t_base::t_base;
static void f_do_scan(t_object* a_this, t_scan a_scan)
{
a_scan(a_this->f_as<t_symbol>().v_entry->second);
}
void f_do_instantiate(t_pvalue* a_stack, size_t a_n);
};
}
#endif
| 19.18
| 91
| 0.736184
|
[
"object"
] |
19a06e875c4e57235e48e2247ba222f0536491c1
| 14,814
|
h
|
C
|
ProcessParser.h
|
zmostafa/CppND-System-Monitor
|
4168bbc5e948b67b3c4d0cfe96aa716cb999c614
|
[
"MIT"
] | null | null | null |
ProcessParser.h
|
zmostafa/CppND-System-Monitor
|
4168bbc5e948b67b3c4d0cfe96aa716cb999c614
|
[
"MIT"
] | null | null | null |
ProcessParser.h
|
zmostafa/CppND-System-Monitor
|
4168bbc5e948b67b3c4d0cfe96aa716cb999c614
|
[
"MIT"
] | null | null | null |
#include <algorithm>
#include <iostream>
#include <math.h>
#include <thread>
#include <chrono>
#include <iterator>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <vector>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <cerrno>
#include <cstring>
#include <dirent.h>
#include <time.h>
#include <unistd.h>
#include "constants.h"
/* include filesystem header for new directory iterator
https://stackoverflow.com/questions/45867379/why-does-gcc-not-seem-to-have-the-filesystem-standard-library
To link with the library you need to add -lstdc++fs to the command line.*/
#include <experimental/filesystem>
using namespace std;
class ProcessParser{
private:
std::ifstream stream;
public:
static string getCmd(string pid);
static vector<string> getPidList();
static std::string getVmSize(string pid);
static std::string getCpuPercent(string pid);
static long int getSysUpTime();
static std::string getProcUpTime(string pid);
static string getProcUser(string pid);
static vector<string> getSysCpuPercent(string coreNumber = "");
static float getSysRamPercent();
static string getSysKernelVersion();
static int getTotalThreads();
static int getTotalNumberOfProcesses();
static int getNumberOfRunningProcesses();
static string getOSName();
static std::string PrintCpuStats(std::vector<std::string> values1, std::vector<std::string>values2);
static bool isPidExisting(string pid);
static int getNumberOfCores();
static float get_sys_active_cpu_time(vector<string> values);
static float get_sys_idle_cpu_time(vector<string>values);
};
// TODO: Define all of the above functions below:
bool ProcessParser::isPidExisting(string pid){
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + pid, fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
return true;
}
string ProcessParser::getCmd(string pid){
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + pid + Path::cmdPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
string cmd;
std::getline(fstream,cmd);
return cmd;
}
// RE-implement this function using the filesystem lib
vector<string> ProcessParser::getPidList()
{
DIR* dir;
// Basically, we are scanning /proc dir for all directories with numbers as their names
// If we get valid check we store dir names in vector as list of machine pids
vector<string> container;
if(!(dir = opendir("/proc")))
throw std::runtime_error(std::strerror(errno));
while (dirent* dirp = readdir(dir)) {
// is this a directory?
if(dirp->d_type != DT_DIR)
continue;
// Is every character of the name a digit?
if (all_of(dirp->d_name, dirp->d_name + std::strlen(dirp->d_name), [](char c){ return std::isdigit(c); })) {
container.push_back(dirp->d_name);
}
}
//Validating process of directory closing
if(closedir(dir))
throw std::runtime_error(std::strerror(errno));
return container;
}
std::string ProcessParser::getVmSize(string pid){
std::ifstream fstream;
float result;
string line;
string inputString = "VmData:";
try{
Util::getStream(Path::basePath() + pid + Path::statusPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
while (getline(fstream,line))
{
if(line.compare(0,inputString.size(),inputString) == 0){
istringstream str(line);
istream_iterator<string> beg(str),end;
vector<string> str_val (beg,end);
// convert Kb to Gb
result = (stof(str_val[1])/float(1024));
break;
}
}
return to_string(result);
}
std::string ProcessParser::getCpuPercent(string pid){
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + pid + "/" + Path::statPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
string line;
float result;
getline(fstream,line);
istringstream str(line);
istream_iterator<string> beg(str),end;
vector<string> vlaues(beg,end);
float utime = stof(ProcessParser::getProcUpTime(pid));
float uptime = ProcessParser::getSysUpTime();
float stime = stof(vlaues[14]);
float cutime = stof(vlaues[15]);
float cstime = stof(vlaues[16]);
float starttime = stof(vlaues[21]);
float frequency = sysconf(_SC_CLK_TCK);
float total_time = utime + stime + cutime + cstime;
float seconds = uptime - (starttime/frequency);
result = 100.0 * ((total_time/frequency)/seconds);
return to_string(result);
}
long int ProcessParser::getSysUpTime(){
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + Path::upTimePath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
string upTime;
std::getline(fstream,upTime);
istringstream str(upTime);
istream_iterator<string> beg(str),end;
vector<string> vlaues(beg,end);
return stol(vlaues[0]);
}
std::string ProcessParser::getProcUpTime(string pid){
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + pid + "/" + Path::statPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
string line;
float result;
getline(fstream,line);
istringstream str(line);
istream_iterator<string> beg(str),end;
vector<string> vlaues(beg,end);
result = stof(vlaues[13])/sysconf(_SC_CLK_TCK);
return to_string(result);
}
string ProcessParser::getProcUser(string pid){
string line;
string name = "Uid:";
string result;
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + pid + Path::statusPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
// reading Uid line from status file
while (std::getline(fstream, line)) {
if (line.compare(0, name.size(),name) == 0) {
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
result = values[1];
break;
}
}
// Finding equivilant user to Uid in /etc/passwd file
std::ifstream userStream;
try{
Util::getStream("/etc/passwd", userStream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
// Searching for name of the user with selected UID
name =("x:" + result);
while (std::getline(userStream, line)) {
if (line.find(name) != std::string::npos) {
result = line.substr(0, line.find(":"));
return result;
}
}
return "";
}
vector<string> ProcessParser::getSysCpuPercent(string coreNumber){
string line;
string name = "cpu" + coreNumber;
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + Path::statPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
while (std::getline(fstream, line)) {
if (line.compare(0, name.size(),name) == 0) {
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
// set of cpu data active and idle times;
return values;
}
}
return (vector<string>());
}
float ProcessParser::getSysRamPercent(){
string line;
string name0 = "MemTotal:";
string name1 = "MemFree:";
string name2 = "MemAvailable:";
string name3 = "Buffers:";
float totalMem = 0.0;
float memFree = 0.0;
float memAval = 0.0;
float buffers = 0.0;
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + Path::memInfoPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
while (std::getline(fstream, line))
{
// if (totalMem != 0 && memFree != 0)
// break;
if(line.compare(0, name0.size(),name0) == 0){
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
totalMem = stof(values[1]);
}
if(line.compare(0, name1.size(),name1) == 0){
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
memFree = stof(values[1]);
}
if(line.compare(0, name2.size(),name2) == 0){
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
memAval = stof(values[1]);
}
if(line.compare(0, name3.size(),name3) == 0){
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
buffers = stof(values[1]);
// I do not like this :(
//break;
}
}
return float(100.0 * (1 - (memFree/(memAval-buffers))));
}
string ProcessParser::getSysKernelVersion(){
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + Path::versionPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
string version = "Linux";
string line;
while(std::getline(fstream,line)){
if(line.compare(0, version.size(), version) == 0){
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
return values[2];
}
}
return "";
}
int ProcessParser::getTotalThreads(){
string line;
int result = 0;
string name = "Threads:";
vector<string> _list = ProcessParser::getPidList();
for (int i=0 ; i<_list.size();i++) {
string pid = _list[i];
//getting every process and reading their number of their threads
std::ifstream fstream ;
try{
Util::getStream(Path::basePath() + pid + Path::statusPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
while (std::getline(fstream, line)) {
if (line.compare(0, name.size(), name) == 0) {
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
result += stoi(values[1]);
break;
}
}
}
return result;
}
int ProcessParser::getTotalNumberOfProcesses(){
string line;
int result = 0;
string name = "processes";
ifstream fstream ;
try{
Util::getStream(Path::basePath() + Path::statPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
while (std::getline(fstream, line)) {
if (line.compare(0, name.size(), name) == 0) {
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
result += stoi(values[1]);
break;
}
}
return result;
}
int ProcessParser::getNumberOfRunningProcesses(){
string line;
int result = 0;
string name = "procs_running";
ifstream fstream ;
try{
Util::getStream(Path::basePath() + Path::statPath(), fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
while (std::getline(fstream, line)) {
if (line.compare(0, name.size(), name) == 0) {
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
result += stoi(values[1]);
break;
}
}
return result;
}
string ProcessParser::getOSName(){
std::ifstream fstream;
try{
// Util::getStream(Path::basePath() + Path::osNamePath(), fstream);
// Reading os name from a different source
Util::getStream("/etc/os-release", fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
string name = "PRETTY_NAME=";
string line;
while(std::getline(fstream,line)){
if(line.compare(0, name.size(), name) == 0){
// istringstream buf(line);
// istream_iterator<string> beg(buf), end;
// vector<string> values(beg, end);
// return values[1] + values[2];
std::size_t found = line.find("=");
found++;
string result = line.substr(found);
result.erase(std::remove(result.begin(), result.end(), '"'), result.end());
return result;
}
}
return "";
}
std::string ProcessParser::PrintCpuStats(std::vector<std::string> values1, std::vector<std::string>values2){
float activeTime = ProcessParser::get_sys_active_cpu_time(values2) - ProcessParser::get_sys_active_cpu_time(values1);
float idleTime = ProcessParser::get_sys_idle_cpu_time(values2) - ProcessParser::get_sys_idle_cpu_time(values1);
float totalTime = activeTime + idleTime;
float result = 100.0 * (activeTime/totalTime);
std::string time = to_string(result);
return time;
}
int ProcessParser::getNumberOfCores(){
string line;
string name = "cpu cores";
std::ifstream fstream;
try{
Util::getStream(Path::basePath() + "cpuinfo", fstream);
} catch (std::string &exp) {
std::cout << exp << std::endl;
}
while (std::getline(fstream, line)) {
if (line.compare(0, name.size(),name) == 0) {
istringstream buf(line);
istream_iterator<string> beg(buf), end;
vector<string> values(beg, end);
return stoi(values[3]);
}
}
return 0;
}
/* These functions for calculating active and idle time are a direct extension of the system CPU percentage.
They sort and categorize a newly created string vector,
which contains parsed raw data from file. Because most of the data is recorded as time,
we are selecting and summing all active and idle time. */
float ProcessParser::get_sys_active_cpu_time(vector<string> values)
{
return (stof(values[S_USER]) +
stof(values[S_NICE]) +
stof(values[S_SYSTEM]) +
stof(values[S_IRQ]) +
stof(values[S_SOFTIRQ]) +
stof(values[S_STEAL]) +
stof(values[S_GUEST]) +
stof(values[S_GUEST_NICE]));
}
float ProcessParser::get_sys_idle_cpu_time(vector<string>values)
{
return (stof(values[S_IDLE]) + stof(values[S_IOWAIT]));
}
| 28.709302
| 121
| 0.59491
|
[
"vector"
] |
19a0aa3ed9e9af5c5ed54b34af4067892d3341b7
| 2,920
|
h
|
C
|
ocean/reflect_loss_beckmann.h
|
fraclipe/UnderSeaModelingLibrary
|
52ef9dd03c7cbe548749e4527190afe7668ff4e7
|
[
"BSD-2-Clause"
] | 1
|
2021-02-07T14:48:22.000Z
|
2021-02-07T14:48:22.000Z
|
ocean/reflect_loss_beckmann.h
|
Wolframy-NUDT/UnderSeaModelingLibrary
|
43365639b435841e1bf2297cf1ac575b8cf91932
|
[
"BSD-2-Clause"
] | null | null | null |
ocean/reflect_loss_beckmann.h
|
Wolframy-NUDT/UnderSeaModelingLibrary
|
43365639b435841e1bf2297cf1ac575b8cf91932
|
[
"BSD-2-Clause"
] | null | null | null |
/**
* @file reflect_loss_beckmann.h
* Models ocean surface reflection loss using Beckmann-Spizzichino model.
*/
#pragma once
#include <usml/ocean/reflect_loss_model.h>
#include <usml/ocean/wave_height_pierson.h>
namespace usml {
namespace ocean {
/// @ingroup boundaries
/// @{
/**
* Models ocean surface reflection loss using Beckmann-Spizzichino model.
* Jones et. al. has shown that this model can be broken into high and low
* frequency components. The high frequency component is given by:
* \f[
* RL_{high} = -20 \: log_{10} \left( \sqrt{1-v_3} \right)
* \f]\f[
* v_3 = max \left( \frac{1}{2} sin \theta, \left[ 1 -
* \frac{ exp(-a \theta^2 / 4 ) }{ \sqrt{ \pi a \theta^2 } } \right] sin \theta
* \right)
* \f]
* where
* \f$ a = \frac{1}{ 2 ( 0.003 + 5.1x10^{-3} w ) } \f$,
* \f$ w \f$ = wind speed (m/sec), and
* \f$ v_3 \f$ is limited to a 0.99 value.
* Note that the high frequency component is frequency independent.
* The low frequency component is given by:
* \f[
* RL_{1ow} = -20 \: log_{10}
* \left( 0.3 + \frac{0.7}{1+6.0x10^{-11} w^4 f^2 } \right)
* \f]
* where
* \f$ f \f$ = signal frequency (Hz).
* Note that the low frequency component is grazing angle independent.
* The total reflection loss is the sum of these two terms in dB.
*
* @xref Adrian D. Jones, Janice Sendt, Alec J. Duncan, Paul A. Clarke and
* Amos Maggi, "Modelling the acoustic reflection loss at the rough
* ocean surface," Proceedings of ACOUSTICS 2009, Australian Acoustical Society,
* 23-25 November 2009, Adelaide, Australia.
*/
class USML_DECLSPEC reflect_loss_beckmann: public reflect_loss_model {
public:
/**
* Initializes ocean surface reflection loss using using
* Beckmann-Spizzichino model.
*
* @param wind_speed Wind_speed used to develop rough seas (m/s).
*/
reflect_loss_beckmann( double wind_speed ) :
_wind_speed( wind_speed )
{
}
/**
* Computes the broadband reflection loss and phase change.
*
* @param location Location at which to compute reflection loss.
* @param frequencies Frequencies over which to compute loss. (Hz).
* @param angle Grazing angle relative to the interface (radians).
* @param amplitude Change in ray intensity in dB (output).
* @param phase Change in ray phase in radians (output).
* Hard-coded to a value of PI for this model.
* Phase change not computed if this is NULL.
*/
virtual void reflect_loss(const wposition1& location,
const seq_vector& frequencies, double angle,
vector<double>* amplitude, vector<double>* phase = NULL) ;
private:
/** Wind speed (m/sec). */
const double _wind_speed;
};
/// @}
} // end of namespace ocean
} // end of namespace usml
| 33.953488
| 85
| 0.627397
|
[
"vector",
"model"
] |
19a13203e98de1d151aaa9ff6aa07d18f77f1215
| 2,816
|
h
|
C
|
HeavyFlavorAnalysis/SpecificDecay/interface/BPHBuToJPsiKBuilder.h
|
ckamtsikis/cmssw
|
ea19fe642bb7537cbf58451dcf73aa5fd1b66250
|
[
"Apache-2.0"
] | 852
|
2015-01-11T21:03:51.000Z
|
2022-03-25T21:14:00.000Z
|
HeavyFlavorAnalysis/SpecificDecay/interface/BPHBuToJPsiKBuilder.h
|
ckamtsikis/cmssw
|
ea19fe642bb7537cbf58451dcf73aa5fd1b66250
|
[
"Apache-2.0"
] | 30,371
|
2015-01-02T00:14:40.000Z
|
2022-03-31T23:26:05.000Z
|
HeavyFlavorAnalysis/SpecificDecay/interface/BPHBuToJPsiKBuilder.h
|
ckamtsikis/cmssw
|
ea19fe642bb7537cbf58451dcf73aa5fd1b66250
|
[
"Apache-2.0"
] | 3,240
|
2015-01-02T05:53:18.000Z
|
2022-03-31T17:24:21.000Z
|
#ifndef HeavyFlavorAnalysis_SpecificDecay_BPHBuToJPsiKBuilder_h
#define HeavyFlavorAnalysis_SpecificDecay_BPHBuToJPsiKBuilder_h
/** \class BPHBuToJPsiKBuilder
*
* Description:
* Class to build B+- to JPsi K+- candidates
*
* \author Paolo Ronchese INFN Padova
*
*/
//----------------------
// Base Class Headers --
//----------------------
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHDecayToResTrkBuilder.h"
//------------------------------------
// Collaborating Class Declarations --
//------------------------------------
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoBuilder.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoCandidate.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHPlusMinusCandidate.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHParticleMasses.h"
#include "FWCore/Framework/interface/Event.h"
//---------------
// C++ Headers --
//---------------
#include <string>
#include <vector>
// ---------------------
// -- Class Interface --
// ---------------------
class BPHBuToJPsiKBuilder : public BPHDecayToResTrkBuilder {
public:
/** Constructor
*/
BPHBuToJPsiKBuilder(const edm::EventSetup& es,
const std::vector<BPHPlusMinusConstCandPtr>& jpsiCollection,
const BPHRecoBuilder::BPHGenericCollection* kaonCollection)
: BPHDecayToResTrkBuilder(es,
"JPsi",
BPHParticleMasses::jPsiMass,
BPHParticleMasses::jPsiMWidth,
jpsiCollection,
"Kaon",
BPHParticleMasses::kaonMass,
BPHParticleMasses::kaonMSigma,
kaonCollection) {
setResMassRange(2.80, 3.40);
setTrkPtMin(0.7);
setTrkEtaMax(10.0);
setMassRange(3.50, 8.00);
setProbMin(0.02);
setMassFitRange(5.00, 6.00);
setConstr(true);
}
// deleted copy constructor and assignment operator
BPHBuToJPsiKBuilder(const BPHBuToJPsiKBuilder& x) = delete;
BPHBuToJPsiKBuilder& operator=(const BPHBuToJPsiKBuilder& x) = delete;
/** Destructor
*/
~BPHBuToJPsiKBuilder() override {}
/** Operations
*/
/// set cuts
void setKPtMin(double pt) { setTrkPtMin(pt); }
void setKEtaMax(double eta) { setTrkEtaMax(eta); }
void setJPsiMassMin(double m) { setResMassMin(m); }
void setJPsiMassMax(double m) { setResMassMax(m); }
/// get current cuts
double getKPtMin() const { return getTrkPtMin(); }
double getKEtaMax() const { return getTrkEtaMax(); }
double getJPsiMassMin() const { return getResMassMin(); }
double getJPsiMassMax() const { return getResMassMax(); }
};
#endif
| 32.744186
| 82
| 0.604403
|
[
"vector"
] |
19a4e7329c535ec8fe07bd069f6a849215d5cbe8
| 1,718
|
h
|
C
|
core/modmanager.h
|
clever-lang/clever
|
2c03e4d4a4bd48b110226907fd158ba76bbccb97
|
[
"MIT"
] | 20
|
2015-03-13T16:03:08.000Z
|
2022-02-22T17:47:40.000Z
|
core/modmanager.h
|
felipensp/clever
|
f0795e5ad271750795f55386d2aad815a1d7cb82
|
[
"MIT"
] | 1
|
2021-05-14T11:50:44.000Z
|
2021-05-14T11:50:44.000Z
|
core/modmanager.h
|
felipensp/clever
|
f0795e5ad271750795f55386d2aad815a1d7cb82
|
[
"MIT"
] | 9
|
2015-01-14T19:21:54.000Z
|
2020-10-01T16:42:06.000Z
|
/**
* Clever programming language
* Copyright (c) Clever Team
*
* This file is distributed under the MIT license. See LICENSE for details.
*/
#ifndef CLEVER_MODMANAGER_H
#define CLEVER_MODMANAGER_H
#ifdef CLEVER_MSVC
#include <unordered_map>
#else
#include <tr1/unordered_map>
#endif
#include <vector>
#include "core/module.h"
#include "core/ast.h"
namespace clever {
class Value;
class Environment;
class Driver;
/// Package manager
class ModManager {
public:
enum ImportKind {
NONE = 0,
TYPE = 1<<0,
FUNCTION = 1<<1,
ALL = TYPE | FUNCTION,
NAMESPACE = 1<<2
};
ModManager(Driver* driver)
: m_driver(driver), m_user(NULL) {}
~ModManager() {}
/// Initialization routine
void init();
/// Shutdown routine
void shutdown();
void setIncludePath(const std::string& path) { m_include_path = path; }
Module* getUserModule() const { return m_user; }
/// Adds a new package to the map
void addModule(const std::string&, Module*);
/// Imports the module to the current scope
ast::Node* importModule(Scope*, const std::string&,
size_t = ModManager::ALL, const CString* = NULL) const;
ast::Node* importFile(Scope*, const std::string&,
size_t = ModManager::ALL, const CString* = NULL) const;
void loadVar(Scope*, const CString*, Value*) const;
void loadModule(Scope*, Module*, size_t, const CString*) const;
void loadModuleContent(Scope*, Module*, size_t, const CString*, const std::string&) const;
void loadFunction(Scope*, const std::string&, Function*) const;
void loadType(Scope*, const std::string&, Type*) const;
private:
Driver* m_driver;
ModuleMap m_mods;
Module* m_user;
std::string m_include_path;
};
} // clever
#endif // CLEVER_MODMANAGER_H
| 22.311688
| 91
| 0.701397
|
[
"vector"
] |
19a6a1ded7fa39287adae14aff3921465d6ebdde
| 8,722
|
h
|
C
|
test/btunittest/behaviac_generated/types/internal/behaviac_customized_types.h
|
nefeithu/behaviac
|
3c8b09b5dc64e0090bf02e273687c6d94f328ad3
|
[
"BSD-3-Clause"
] | 2,504
|
2016-11-11T17:12:12.000Z
|
2022-03-30T10:39:05.000Z
|
test/btunittest/behaviac_generated/types/internal/behaviac_customized_types.h
|
mlik5hao/behaviac
|
a280fe24b3e7c357e607c397287a76a8bec33de3
|
[
"BSD-3-Clause"
] | 127
|
2016-12-28T04:54:08.000Z
|
2022-03-17T10:26:55.000Z
|
test/btunittest/behaviac_generated/types/internal/behaviac_customized_types.h
|
mlik5hao/behaviac
|
a280fe24b3e7c357e607c397287a76a8bec33de3
|
[
"BSD-3-Clause"
] | 821
|
2016-11-11T11:15:24.000Z
|
2022-03-30T15:06:18.000Z
|
// ---------------------------------------------------------------------
// THIS FILE IS AUTO-GENERATED BY BEHAVIAC DESIGNER, SO PLEASE DON'T MODIFY IT BY YOURSELF!
// ---------------------------------------------------------------------
#ifndef _BEHAVIAC_CUSTOMIZED_TYPES_H_
#define _BEHAVIAC_CUSTOMIZED_TYPES_H_
#include "behaviac/agent/agent.h"
// -------------------
// Customized enums
// -------------------
DECLARE_BEHAVIAC_ENUM_EX(EnumTest, EnumTest);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(EnumTest);
DECLARE_BEHAVIAC_ENUM_EX(FSMAgentTest::EMessage, EMessage);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(FSMAgentTest::EMessage);
DECLARE_BEHAVIAC_ENUM_EX(TNS::NE::NAT::eColor, eColor);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TNS::NE::NAT::eColor);
enum ETest
{
EA,
EB,
EC,
};
DECLARE_BEHAVIAC_ENUM_EX(ETest, ETest);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(ETest);
// -------------------
// Customized structs
// -------------------
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(Act, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(Act);
template< typename SWAPPER >
inline void SwapByteImplement(Act& v)
{
SwapByteImplement< SWAPPER >(v.Var_B_Loop);
SwapByteImplement< SWAPPER >(v.Var_List_EnumTest);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const Act& lhs, const Act& rhs)
{
return Equal(lhs.Var_B_Loop, rhs.Var_B_Loop)
&& Equal(lhs.Var_List_EnumTest, rhs.Var_List_EnumTest);
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(BSASN::SpatialCoord, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(BSASN::SpatialCoord);
template< typename SWAPPER >
inline void SwapByteImplement(BSASN::SpatialCoord& v)
{
SwapByteImplement< SWAPPER >(v.coordX);
SwapByteImplement< SWAPPER >(v.coordY);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const BSASN::SpatialCoord& lhs, const BSASN::SpatialCoord& rhs)
{
return Equal(lhs.coordX, rhs.coordX)
&& Equal(lhs.coordY, rhs.coordY);
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(BSASN::TransitPlan, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(BSASN::TransitPlan);
template< typename SWAPPER >
inline void SwapByteImplement(BSASN::TransitPlan& v)
{
SwapByteImplement< SWAPPER >(v.plan_ID);
SwapByteImplement< SWAPPER >(v.plan_selection_precedence);
SwapByteImplement< SWAPPER >(v.transit_points);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const BSASN::TransitPlan& lhs, const BSASN::TransitPlan& rhs)
{
return Equal(lhs.plan_ID, rhs.plan_ID)
&& Equal(lhs.plan_selection_precedence, rhs.plan_selection_precedence)
&& Equal(lhs.transit_points, rhs.transit_points);
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(IList, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(IList);
template< typename SWAPPER >
inline void SwapByteImplement(IList& v)
{
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const IList& lhs, const IList& rhs)
{
return &lhs == &rhs;
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(System::Object, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(System::Object);
template< typename SWAPPER >
inline void SwapByteImplement(System::Object& v)
{
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const System::Object& lhs, const System::Object& rhs)
{
return &lhs == &rhs;
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(TestClassA, true);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TestClassA);
template< typename SWAPPER >
inline void SwapByteImplement(TestClassA& v)
{
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const TestClassA& lhs, const TestClassA& rhs)
{
return &lhs == &rhs;
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(TestNamespace::ClassAsValueType, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TestNamespace::ClassAsValueType);
template< typename SWAPPER >
inline void SwapByteImplement(TestNamespace::ClassAsValueType& v)
{
SwapByteImplement< SWAPPER >(v.x);
SwapByteImplement< SWAPPER >(v.y);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const TestNamespace::ClassAsValueType& lhs, const TestNamespace::ClassAsValueType& rhs)
{
return Equal(lhs.x, rhs.x)
&& Equal(lhs.y, rhs.y);
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(TestNamespace::Float2, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TestNamespace::Float2);
template< typename SWAPPER >
inline void SwapByteImplement(TestNamespace::Float2& v)
{
SwapByteImplement< SWAPPER >(v.x);
SwapByteImplement< SWAPPER >(v.y);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const TestNamespace::Float2& lhs, const TestNamespace::Float2& rhs)
{
return Equal(lhs.x, rhs.x)
&& Equal(lhs.y, rhs.y);
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(TestNS::Float2, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TestNS::Float2);
template< typename SWAPPER >
inline void SwapByteImplement(TestNS::Float2& v)
{
SwapByteImplement< SWAPPER >(v.x);
SwapByteImplement< SWAPPER >(v.y);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const TestNS::Float2& lhs, const TestNS::Float2& rhs)
{
return Equal(lhs.x, rhs.x)
&& Equal(lhs.y, rhs.y);
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(TestNS::Node, true);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TestNS::Node);
template< typename SWAPPER >
inline void SwapByteImplement(TestNS::Node& v)
{
SwapByteImplement< SWAPPER >(v.name);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const TestNS::Node& lhs, const TestNS::Node& rhs)
{
return &lhs == &rhs;
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(TNS::ST::kCar, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TNS::ST::kCar);
template< typename SWAPPER >
inline void SwapByteImplement(TNS::ST::kCar& v)
{
SwapByteImplement< SWAPPER >(v.brand);
SwapByteImplement< SWAPPER >(v.price);
SwapByteImplement< SWAPPER >(v.color);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const TNS::ST::kCar& lhs, const TNS::ST::kCar& rhs)
{
return Equal(lhs.brand, rhs.brand)
&& Equal(lhs.price, rhs.price)
&& Equal(lhs.color, rhs.color);
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(TNS::ST::PER::WRK::kEmployee, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TNS::ST::PER::WRK::kEmployee);
template< typename SWAPPER >
inline void SwapByteImplement(TNS::ST::PER::WRK::kEmployee& v)
{
SwapByteImplement< SWAPPER >(v.id);
SwapByteImplement< SWAPPER >(v.name);
SwapByteImplement< SWAPPER >(v.code);
SwapByteImplement< SWAPPER >(v.weight);
SwapByteImplement< SWAPPER >(v.isMale);
SwapByteImplement< SWAPPER >(v.skinColor);
SwapByteImplement< SWAPPER >(v.car);
SwapByteImplement< SWAPPER >(v.boss);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const TNS::ST::PER::WRK::kEmployee& lhs, const TNS::ST::PER::WRK::kEmployee& rhs)
{
return Equal(lhs.id, rhs.id)
&& Equal(lhs.name, rhs.name)
&& Equal(lhs.code, rhs.code)
&& Equal(lhs.weight, rhs.weight)
&& Equal(lhs.isMale, rhs.isMale)
&& Equal(lhs.skinColor, rhs.skinColor)
&& Equal(lhs.car, rhs.car)
&& Equal(lhs.boss, rhs.boss);
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(UnityEngine::GameObject, true);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(UnityEngine::GameObject);
template< typename SWAPPER >
inline void SwapByteImplement(UnityEngine::GameObject& v)
{
SwapByteImplement< SWAPPER >(v.name);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const UnityEngine::GameObject& lhs, const UnityEngine::GameObject& rhs)
{
return &lhs == &rhs;
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(UnityEngine::Vector3, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(UnityEngine::Vector3);
template< typename SWAPPER >
inline void SwapByteImplement(UnityEngine::Vector3& v)
{
SwapByteImplement< SWAPPER >(v.x);
SwapByteImplement< SWAPPER >(v.y);
SwapByteImplement< SWAPPER >(v.z);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const UnityEngine::Vector3& lhs, const UnityEngine::Vector3& rhs)
{
return Equal(lhs.x, rhs.x)
&& Equal(lhs.y, rhs.y)
&& Equal(lhs.z, rhs.z);
}
}
}
struct StructTest
{
bool a;
};
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(StructTest, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(StructTest);
template< typename SWAPPER >
inline void SwapByteImplement(StructTest& v)
{
SwapByteImplement< SWAPPER >(v.a);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const StructTest& lhs, const StructTest& rhs)
{
return Equal(lhs.a, rhs.a);
}
}
}
#endif // _BEHAVIAC_CUSTOMIZED_TYPES_H_
| 22.081013
| 107
| 0.728847
|
[
"object"
] |
19ae13f6a9b74d85df475495cedbf345308087e9
| 1,676
|
h
|
C
|
util.h
|
k0ss/haze
|
60a718975137da9cefc4e1895712bd7b440f5fbb
|
[
"Apache-2.0"
] | 47
|
2020-09-27T01:46:05.000Z
|
2021-07-27T04:48:11.000Z
|
util.h
|
k0ss/haze
|
60a718975137da9cefc4e1895712bd7b440f5fbb
|
[
"Apache-2.0"
] | 2
|
2020-10-31T20:05:33.000Z
|
2020-12-26T03:49:46.000Z
|
util.h
|
k0ss/haze
|
60a718975137da9cefc4e1895712bd7b440f5fbb
|
[
"Apache-2.0"
] | 7
|
2020-09-27T11:17:29.000Z
|
2021-05-01T21:17:33.000Z
|
#include <vector>
#include <string>
#include <chrono>
#include <iomanip>
#include <optional>
#include <ostream>
#include <filesystem>
namespace fs = std::filesystem;
std::vector<char> file2vec(fs::path path);
bool dir_exists(char* path);
bool dir_create(char* path);
std::ostream& operator<<(std::ostream& os, std::chrono::nanoseconds ns)
{
using namespace std::chrono;
using days = duration<int, std::ratio<86400>>;
auto d = duration_cast<days>(ns);
ns -= d;
auto h = duration_cast<hours>(ns);
ns -= h;
auto m = duration_cast<minutes>(ns);
ns -= m;
auto s = duration_cast<seconds>(ns);
ns -= s;
std::optional<int64_t> fs_count;
// WARN: HARDCODED VALUE BELOW
int precision = 3;
//int precision = os.precision();
switch (precision) {
case 9: fs_count = ns.count();
break;
case 6: fs_count = duration_cast<microseconds>(ns).count();
break;
case 3: fs_count = duration_cast<milliseconds>(ns).count();
break;
}
// WARN: HARDCODED VALUE
fs_count = duration_cast<milliseconds>(ns).count();
char fill = os.fill('0');
if (d.count())
os << d.count() << "d ";
if (d.count() || h.count())
os << std::setw(2) << h.count() << "h ";
if (d.count() || h.count() || m.count())
os << std::setw(d.count() || h.count() ? 2 : 1) << m.count() << "m ";
os << std::setw(d.count() || h.count() || m.count() ? 2 : 1) << s.count();
if (fs_count.has_value())
os << "." << std::setw(precision) << fs_count.value() << "s";
//if (!d.count() && !h.count() && !m.count())
// os << "s";
os.fill(fill);
return os;
}
| 26.1875
| 78
| 0.563246
|
[
"vector"
] |
19ae308b003b1b4c1da993dd3072ced447a0bbd8
| 160
|
h
|
C
|
AppTypes.h
|
chen0040/cpp-mfc-fractal-art-iec-lgp
|
108b6ca40f73accc7959da5da0fdcb963136ad0c
|
[
"MIT"
] | 3
|
2020-01-10T11:12:38.000Z
|
2022-03-13T01:34:56.000Z
|
AppTypes.h
|
chen0040/cpp-mfc-fractal-art-iec-lgp
|
108b6ca40f73accc7959da5da0fdcb963136ad0c
|
[
"MIT"
] | null | null | null |
AppTypes.h
|
chen0040/cpp-mfc-fractal-art-iec-lgp
|
108b6ca40f73accc7959da5da0fdcb963136ad0c
|
[
"MIT"
] | null | null | null |
#ifndef _H_XS_APPLICATION_TYPES_H
#define _H_XS_APPLICATION_TYPES_H
#include <vector>
class CViewport;
typedef std::vector<CViewport*> ViewportGroup;
#endif
| 16
| 46
| 0.825
|
[
"vector"
] |
19b17b3b49157ba0c5a82a5db78fd1c8c57ec43d
| 31,617
|
c
|
C
|
lib/am335x_sdk/ti/csl/src/ip/csitx/V0/priv/csitx_sanity.c
|
brandonbraun653/Apollo
|
a1ece2cc3f1d3dae48fdf8fe94f0bbb59d405fce
|
[
"MIT"
] | 2
|
2021-12-27T10:19:01.000Z
|
2022-03-15T07:09:06.000Z
|
lib/am335x_sdk/ti/csl/src/ip/csitx/V0/priv/csitx_sanity.c
|
brandonbraun653/Apollo
|
a1ece2cc3f1d3dae48fdf8fe94f0bbb59d405fce
|
[
"MIT"
] | null | null | null |
lib/am335x_sdk/ti/csl/src/ip/csitx/V0/priv/csitx_sanity.c
|
brandonbraun653/Apollo
|
a1ece2cc3f1d3dae48fdf8fe94f0bbb59d405fce
|
[
"MIT"
] | null | null | null |
/**********************************************************************
* Copyright (C) 2012-2019 Cadence Design Systems, Inc.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
**********************************************************************
* WARNING: This file is auto-generated using api-generator utility.
* api-generator: 13.04.5beed88
* Do not edit it manually.
**********************************************************************
* Cadence Core Driver for MIPI CSI Host Controller
**********************************************************************/
/* parasoft-begin-suppress METRICS-18-3 "Follow the Cyclomatic Complexity limit of 10, DRV-4789" */
/* parasoft-begin-suppress METRICS-36-3 "A function should not be called from more than 5 different functions, DRV-3823" */
/* parasoft-begin-suppress METRICS-39-3 "The value of VOCF metric for a function should not be higher than 4, DRV-4790" */
/* parasoft-begin-suppress METRICS-41-3 "Number of blocks of comments per statement, DRV-4926" */
/* parasoft-begin-suppress MISRA2012-RULE-8_7 "Functions and objects should not be defined with external linkage if they are referenced in only one translation unit, DRV-4139" */
/**
* This file contains sanity API functions. The purpose of sanity functions
* is to check input parameters validity. They take the same parameters as
* original API functions and return 0 on success or CDN_EINVAL on wrong parameter
* value(s).
*/
#include <ti/csl/csl_csitx.h>
#include <cps_drv.h>
#include "csitx_structs_if.h"
#include "csitx_sanity.h"
/**
* Function to validate struct Config
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_ConfigSF(const CSITX_Config *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
return ret;
}
/**
* Function to validate struct DphyConfig1
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_DphyConfig1SF(const CSITX_DphyConfig1 *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
return ret;
}
/**
* Function to validate struct DphyConfig
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_DphyConfigSF(const CSITX_DphyConfig *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
else
{
if (obj->dphyClockMode > (1U))
{
ret = CDN_EINVAL;
}
if (obj->dphyMode > (2U))
{
ret = CDN_EINVAL;
}
}
return ret;
}
/**
* Function to validate struct DataTypeConfig
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_DataTypeConfigSF(const CSITX_DataTypeConfig *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
else
{
if (obj->lineCountEnable > (1U))
{
ret = CDN_EINVAL;
}
if (obj->lineStartEndEnable > (1U))
{
ret = CDN_EINVAL;
}
if (obj->dataType > (63U))
{
ret = CDN_EINVAL;
}
if (obj->extendedDataType > (1U))
{
ret = CDN_EINVAL;
}
if (obj->packedEnable > (1U))
{
ret = CDN_EINVAL;
}
}
return ret;
}
/**
* Function to validate struct VirtualChannelConfig
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_VirtualChannelConfigSF(const CSITX_VirtualChannelConfig *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
else
{
if (obj->frameCountEnable > (1U))
{
ret = CDN_EINVAL;
}
}
return ret;
}
/**
* Function to validate struct WaitBurstTimeConfig
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_WaitBurstTimeConfigSF(const CSITX_WaitBurstTimeConfig *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
return ret;
}
/**
* Function to validate struct StreamConfig
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_StreamConfigSF(const CSITX_StreamConfig *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
else
{
if (obj->slaveMode > (1U))
{
ret = CDN_EINVAL;
}
}
return ret;
}
/**
* Function to validate struct RxCompatibilityConfig
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_RxCompatibilityConfigSF(const CSITX_RxCompatibilityConfig *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
return ret;
}
/**
* Function to validate struct EpdConfig
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_EpdConfigSF(const CSITX_EpdConfig *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
else
{
if (obj->enable > (1U))
{
ret = CDN_EINVAL;
}
if (obj->option > (1U))
{
ret = CDN_EINVAL;
}
if (obj->spSpacers > (0x3FFFU))
{
ret = CDN_EINVAL;
}
if (obj->lpSpacers > (0x3FFFU))
{
ret = CDN_EINVAL;
}
}
return ret;
}
/**
* Function to validate struct Callbacks
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_CallbacksSF(const CSITX_Callbacks *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
return ret;
}
/**
* Function to validate struct PrivateData
*
* @param[in] obj pointer to struct to be verified
* @returns 0 for valid
* @returns CDN_EINVAL for invalid
*/
uint32_t CSITX_PrivateDataSF(const CSITX_PrivateData *obj)
{
uint32_t ret = 0;
if (obj == NULL)
{
ret = CDN_EINVAL;
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] config "Driver/hardware configuration required."
* @param[out] memReq "Size of the memory allocation required."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction1(const CSITX_Config* config, const CSITX_SysReq* memReq)
{
/* Declaring return variable */
uint32_t ret = 0;
if (memReq == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_ConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver state info specific to this instance."
* @param[in] config "Specifies driver/hardware configuration."
* @param[in] callbacks "Client-supplied callback functions."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction2(const CSITX_PrivateData* pD, const CSITX_Config* config, const CSITX_Callbacks* callbacks)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_ConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_CallbacksSF(callbacks) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data filled by Init."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction3(const CSITX_PrivateData* pD)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] enable "'configuration_request' bit from the CONFIG register is tested. If enable Configuration Request is enabled, false otherwise."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction8(const CSITX_PrivateData* pD, const uint32_t* enable)
{
/* Declaring return variable */
uint32_t ret = 0;
if (enable == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[in] config "Configuration to apply to D-PHY."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction9(const CSITX_PrivateData* pD, const CSITX_DphyConfig* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_DphyConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] config "DPHY config."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction10(const CSITX_PrivateData* pD, const CSITX_DphyConfig* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (config == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[in] config "Configuration to apply to DPHY CFG1."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction11(const CSITX_PrivateData* pD, const CSITX_DphyConfig1* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_DphyConfig1SF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] config "DPHY CFG1 config."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction12(const CSITX_PrivateData* pD, const CSITX_DphyConfig1* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (config == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[in] config "Virtual channel configuration."
* @param[in] number Number of the Virtual channel to configure
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction13(const CSITX_PrivateData* pD, const CSITX_VirtualChannelConfig* config, const CSITX_VcNumber number)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_VirtualChannelConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (
(number != CSITX_VC0) &&
(number != CSITX_VC1) &&
(number != CSITX_VC2) &&
(number != CSITX_VC3) &&
(number != CSITX_VC4) &&
(number != CSITX_VC5) &&
(number != CSITX_VC6) &&
(number != CSITX_VC7) &&
(number != CSITX_VC8) &&
(number != CSITX_VC9) &&
(number != CSITX_VC10) &&
(number != CSITX_VC11) &&
(number != CSITX_VC12) &&
(number != CSITX_VC13) &&
(number != CSITX_VC14) &&
(number != CSITX_VC15)
)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] config "Virtual channel configuration."
* @param[in] number Number of the virtual channel
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction14(const CSITX_PrivateData* pD, const CSITX_VirtualChannelConfig* config, const CSITX_VcNumber number)
{
/* Declaring return variable */
uint32_t ret = 0;
if (config == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (
(number != CSITX_VC0) &&
(number != CSITX_VC1) &&
(number != CSITX_VC2) &&
(number != CSITX_VC3) &&
(number != CSITX_VC4) &&
(number != CSITX_VC5) &&
(number != CSITX_VC6) &&
(number != CSITX_VC7) &&
(number != CSITX_VC8) &&
(number != CSITX_VC9) &&
(number != CSITX_VC10) &&
(number != CSITX_VC11) &&
(number != CSITX_VC12) &&
(number != CSITX_VC13) &&
(number != CSITX_VC14) &&
(number != CSITX_VC15)
)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[in] config "Data type configuration."
* @param[in] number Number of the Data type to configure.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction15(const CSITX_PrivateData* pD, const CSITX_DataTypeConfig* config, const CSITX_DtNumber number)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_DataTypeConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (
(number != CSITX_DT0) &&
(number != CSITX_DT1) &&
(number != CSITX_DT2) &&
(number != CSITX_DT3) &&
(number != CSITX_DT4) &&
(number != CSITX_DT5) &&
(number != CSITX_DT6) &&
(number != CSITX_DT7) &&
(number != CSITX_DT8) &&
(number != CSITX_DT9) &&
(number != CSITX_DT10) &&
(number != CSITX_DT11) &&
(number != CSITX_DT12) &&
(number != CSITX_DT13) &&
(number != CSITX_DT14) &&
(number != CSITX_DT15)
)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] config "Data type configuration."
* @param[in] number Number of the data type
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction16(const CSITX_PrivateData* pD, const CSITX_DataTypeConfig* config, const CSITX_DtNumber number)
{
/* Declaring return variable */
uint32_t ret = 0;
if (config == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (
(number != CSITX_DT0) &&
(number != CSITX_DT1) &&
(number != CSITX_DT2) &&
(number != CSITX_DT3) &&
(number != CSITX_DT4) &&
(number != CSITX_DT5) &&
(number != CSITX_DT6) &&
(number != CSITX_DT7) &&
(number != CSITX_DT8) &&
(number != CSITX_DT9) &&
(number != CSITX_DT10) &&
(number != CSITX_DT11) &&
(number != CSITX_DT12) &&
(number != CSITX_DT13) &&
(number != CSITX_DT14) &&
(number != CSITX_DT15)
)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[in] config "Stream configuration."
* @param[in] number Pixel interface number.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction17(const CSITX_PrivateData* pD, const CSITX_StreamConfig* config, const CSITX_IfNumber number)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_StreamConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (
(number != CSITX_PIXEL_IF0) &&
(number != CSITX_PIXEL_IF1) &&
(number != CSITX_PIXEL_IF2) &&
(number != CSITX_PIXEL_IF3)
)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] config "Stream configuration."
* @param[in] number Pixel interface number.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction18(const CSITX_PrivateData* pD, const CSITX_StreamConfig* config, const CSITX_IfNumber number)
{
/* Declaring return variable */
uint32_t ret = 0;
if (config == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (
(number != CSITX_PIXEL_IF0) &&
(number != CSITX_PIXEL_IF1) &&
(number != CSITX_PIXEL_IF2) &&
(number != CSITX_PIXEL_IF3)
)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] enable "'bypass_mode_enable' bit from the CONFIG register is tested. If enable Bypass Mode Enable is enabled, false otherwise."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction20(const CSITX_PrivateData* pD, const bool* enable)
{
/* Declaring return variable */
uint32_t ret = 0;
if (enable == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[in] config DPHY Wait Time Configuration.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction27(const CSITX_PrivateData* pD, const CSITX_WaitBurstTimeConfig* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_WaitBurstTimeConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] config "DPHY Wait Time Configuration."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction28(const CSITX_PrivateData* pD, const CSITX_WaitBurstTimeConfig* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (config == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] value "Contents of the DPHY_CLK_WAKEUP register."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction30(const CSITX_PrivateData* pD, const uint16_t* value)
{
/* Declaring return variable */
uint32_t ret = 0;
if (value == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] value "Contents of the DEBUG_PROT_FSM register."
* @param[in] number Number of the Pixel interface.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction35(const CSITX_PrivateData* pD, const uint32_t* value, const CSITX_IfNumber number)
{
/* Declaring return variable */
uint32_t ret = 0;
if (value == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (
(number != CSITX_PIXEL_IF0) &&
(number != CSITX_PIXEL_IF1) &&
(number != CSITX_PIXEL_IF2) &&
(number != CSITX_PIXEL_IF3)
)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] value "D-PHY config."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction40(const CSITX_PrivateData* pD, const uint16_t* value)
{
/* Declaring return variable */
uint32_t ret = 0;
if (value == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD Pointer to driver's private data object.
* @param[out] asfInfo Pointer to ASF information structure.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction42(const CSITX_PrivateData* pD, const CSITX_AsfInfo* asfInfo)
{
/* Declaring return variable */
uint32_t ret = 0;
if (asfInfo == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Pointer to the private data initialized by init".
* @param[out] value "Output value."
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction43(const CSITX_PrivateData* pD, const CSITX_DeviceConfig* value)
{
/* Declaring return variable */
uint32_t ret = 0;
if (value == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[in] config EPD configuration.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction44(const CSITX_PrivateData* pD, const CSITX_EpdConfig* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_EpdConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD "Driver instance data."
* @param[out] config EPD configuration.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction45(const CSITX_PrivateData* pD, const CSITX_EpdConfig* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (config == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD Driver instance data
* @param[in] config CSIRX compatibility configuration.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction48(const CSITX_PrivateData* pD, const CSITX_RxCompatibilityConfig* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else if (CSITX_RxCompatibilityConfigSF(config) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/**
* A common function to check the validity of API functions with
* following parameter types
* @param[in] pD Driver instance data
* @param[out] config CSIRX compatibility configuration.
* @return 0 success
* @return CDN_EINVAL invalid parameters
*/
uint32_t CSITX_SanityFunction49(const CSITX_PrivateData* pD, const CSITX_RxCompatibilityConfig* config)
{
/* Declaring return variable */
uint32_t ret = 0;
if (config == NULL)
{
ret = CDN_EINVAL;
}
else if (CSITX_PrivateDataSF(pD) == CDN_EINVAL)
{
ret = CDN_EINVAL;
}
else
{
/*
* All 'if ... else if' constructs shall be terminated with an 'else' statement
* (MISRA2012-RULE-15_7-3)
*/
}
return ret;
}
/* parasoft-end-suppress MISRA2012-RULE-8_7 */
/* parasoft-end-suppress METRICS-41-3 */
/* parasoft-end-suppress METRICS-39-3 */
/* parasoft-end-suppress METRICS-36-3 */
/* parasoft-end-suppress METRICS-18-3 */
| 24.75881
| 178
| 0.613689
|
[
"object"
] |
19b7f8e3bc1583cd5fec784322458e85a853d6fd
| 121
|
h
|
C
|
source/defs.h
|
alexwim/sat-solver
|
7503a00b6c4d5893651dbc78acf086eafdafb3e9
|
[
"MIT"
] | null | null | null |
source/defs.h
|
alexwim/sat-solver
|
7503a00b6c4d5893651dbc78acf086eafdafb3e9
|
[
"MIT"
] | null | null | null |
source/defs.h
|
alexwim/sat-solver
|
7503a00b6c4d5893651dbc78acf086eafdafb3e9
|
[
"MIT"
] | null | null | null |
#ifndef DEFS_H
#define DEFS_H
#include <vector>
typedef int LITERAL;
typedef std::vector<LITERAL> CLAUSE;
#endif
| 12.1
| 36
| 0.727273
|
[
"vector"
] |
19bd1c5902cb7e382aae83295c00ead24e312e11
| 5,483
|
h
|
C
|
Examples/DocsExamples/source/Programming with Documents/Working with OleObjects and ActiveX.h
|
btolfa/Aspose.Words-for-C
|
f75c77380b75546907ee63b96590f5250d2ffa90
|
[
"MIT"
] | 32
|
2018-08-23T07:48:20.000Z
|
2021-12-24T07:27:02.000Z
|
Examples/DocsExamples/source/Programming with Documents/Working with OleObjects and ActiveX.h
|
btolfa/Aspose.Words-for-C
|
f75c77380b75546907ee63b96590f5250d2ffa90
|
[
"MIT"
] | 1
|
2021-11-23T03:35:31.000Z
|
2022-01-26T09:19:44.000Z
|
Examples/DocsExamples/source/Programming with Documents/Working with OleObjects and ActiveX.h
|
btolfa/Aspose.Words-for-C
|
f75c77380b75546907ee63b96590f5250d2ffa90
|
[
"MIT"
] | 13
|
2018-07-31T05:02:33.000Z
|
2022-03-06T22:12:36.000Z
|
#pragma once
#include <cstdint>
#include <iostream>
#include <Aspose.Words.Cpp/Document.h>
#include <Aspose.Words.Cpp/DocumentBuilder.h>
#include <Aspose.Words.Cpp/Drawing/Ole/Forms2OleControl.h>
#include <Aspose.Words.Cpp/Drawing/Ole/Forms2OleControlCollection.h>
#include <Aspose.Words.Cpp/Drawing/Ole/Forms2OleControlType.h>
#include <Aspose.Words.Cpp/Drawing/Ole/OleControl.h>
#include <Aspose.Words.Cpp/Drawing/OleFormat.h>
#include <Aspose.Words.Cpp/Drawing/OlePackage.h>
#include <Aspose.Words.Cpp/Drawing/Shape.h>
#include <Aspose.Words.Cpp/Node.h>
#include <Aspose.Words.Cpp/NodeCollection.h>
#include <Aspose.Words.Cpp/NodeType.h>
#include <Aspose.Words.Cpp/Saving/SaveOutputParameters.h>
#include <system/array.h>
#include <system/details/dispose_guard.h>
#include <system/enumerator_adapter.h>
#include <system/exceptions.h>
#include <system/io/file.h>
#include <system/io/memory_stream.h>
#include <system/io/stream.h>
#include <system/object_ext.h>
#include "DocsExamplesBase.h"
using System::ArrayPtr;
using System::MakeArray;
using System::MakeObject;
using System::SharedPtr;
using System::String;
using namespace Aspose::Words;
using namespace Aspose::Words::Drawing;
using namespace Aspose::Words::Drawing::Ole;
namespace DocsExamples { namespace Programming_with_Documents {
class WorkingWithOleObjectsAndActiveX : public DocsExamplesBase
{
public:
void InsertOleObject()
{
//ExStart:DocumentBuilderInsertOleObject
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);
builder->InsertOleObject(u"http://www.aspose.com", u"htmlfile", true, true, nullptr);
doc->Save(ArtifactsDir + u"WorkingWithOleObjectsAndActiveX.InsertOleObject.docx");
//ExEnd:DocumentBuilderInsertOleObject
}
void InsertOleObjectWithOlePackage()
{
//ExStart:InsertOleObjectwithOlePackage
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);
ArrayPtr<uint8_t> bs = System::IO::File::ReadAllBytes(MyDir + u"Zip file.zip");
{
SharedPtr<System::IO::Stream> stream = MakeObject<System::IO::MemoryStream>(bs);
SharedPtr<Shape> shape = builder->InsertOleObject(stream, u"Package", true, nullptr);
SharedPtr<OlePackage> olePackage = shape->get_OleFormat()->get_OlePackage();
olePackage->set_FileName(u"filename.zip");
olePackage->set_DisplayName(u"displayname.zip");
doc->Save(ArtifactsDir + u"WorkingWithOleObjectsAndActiveX.InsertOleObjectWithOlePackage.docx");
}
//ExEnd:InsertOleObjectwithOlePackage
//ExStart:GetAccessToOLEObjectRawData
auto oleShape = System::DynamicCast<Shape>(doc->GetChild(NodeType::Shape, 0, true));
ArrayPtr<uint8_t> oleRawData = oleShape->get_OleFormat()->GetRawData();
//ExEnd:GetAccessToOLEObjectRawData
}
void InsertOleObjectAsIcon()
{
//ExStart:InsertOLEObjectAsIcon
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);
builder->InsertOleObjectAsIcon(MyDir + u"Presentation.pptx", false, ImagesDir + u"Logo icon.ico", u"My embedded file");
doc->Save(ArtifactsDir + u"WorkingWithOleObjectsAndActiveX.InsertOleObjectAsIcon.docx");
//ExEnd:InsertOLEObjectAsIcon
}
void InsertOleObjectAsIconUsingStream()
{
//ExStart:InsertOLEObjectAsIconUsingStream
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);
{
auto stream = MakeObject<System::IO::MemoryStream>(System::IO::File::ReadAllBytes(MyDir + u"Presentation.pptx"));
builder->InsertOleObjectAsIcon(stream, u"Package", ImagesDir + u"Logo icon.ico", u"My embedded file");
}
doc->Save(ArtifactsDir + u"WorkingWithOleObjectsAndActiveX.InsertOleObjectAsIconUsingStream.docx");
//ExEnd:InsertOLEObjectAsIconUsingStream
}
void ReadActiveXControlProperties()
{
auto doc = MakeObject<Document>(MyDir + u"ActiveX controls.docx");
String properties = u"";
for (const auto& shape : System::IterateOver<Shape>(doc->GetChildNodes(NodeType::Shape, true)))
{
if (shape->get_OleFormat() == nullptr)
{
break;
}
SharedPtr<OleControl> oleControl = shape->get_OleFormat()->get_OleControl();
if (oleControl->get_IsForms2OleControl())
{
auto checkBox = System::DynamicCast<Forms2OleControl>(oleControl);
properties = properties + u"\nCaption: " + checkBox->get_Caption();
properties = properties + u"\nValue: " + checkBox->get_Value();
properties = properties + u"\nEnabled: " + checkBox->get_Enabled();
properties = properties + u"\nType: " + System::ObjectExt::ToString(checkBox->get_Type());
if (checkBox->get_ChildNodes() != nullptr)
{
properties = properties + u"\nChildNodes: " + checkBox->get_ChildNodes();
}
properties += u"\n";
}
}
properties = properties + u"\nTotal ActiveX Controls found: " + doc->GetChildNodes(NodeType::Shape, true)->get_Count();
std::cout << (String(u"\n") + properties) << std::endl;
}
};
}} // namespace DocsExamples::Programming_with_Documents
| 38.612676
| 127
| 0.674266
|
[
"shape"
] |
19bd4eacb2628977a459fd4e06cc0d151978c2eb
| 153
|
h
|
C
|
quad_mesh_simplify/c/mesh_inversion.h
|
jannessm/quadric-mesh-simplification
|
d3a33c5abd852d229e787c4b7197762dd31a1f19
|
[
"MIT"
] | 23
|
2020-06-12T07:18:43.000Z
|
2022-02-22T07:34:59.000Z
|
quad_mesh_simplify/c/mesh_inversion.h
|
WangFengShao/quadric-mesh-simplification
|
42086c1ac508f62e6e1bfd9cbf15f78aaa18d608
|
[
"MIT"
] | 8
|
2020-08-17T14:04:52.000Z
|
2021-02-19T21:37:07.000Z
|
quad_mesh_simplify/c/mesh_inversion.h
|
WangFengShao/quadric-mesh-simplification
|
42086c1ac508f62e6e1bfd9cbf15f78aaa18d608
|
[
"MIT"
] | 4
|
2020-08-16T17:50:48.000Z
|
2021-12-10T09:15:34.000Z
|
#include <stdbool.h>
#include "mesh.h"
bool has_mesh_inversion(unsigned int v1, unsigned int v2, Mesh* mesh, double* new_position, bool* deleted_faces);
| 38.25
| 113
| 0.771242
|
[
"mesh"
] |
19c125734ca9ccdacfe3485ddb11132a18b8e98e
| 30,015
|
c
|
C
|
compiler.c
|
homma/krc
|
0fdefc15bb97ed4692544a03e7d7b22c9122f662
|
[
"BSD-2-Clause"
] | 1
|
2019-12-27T13:29:02.000Z
|
2019-12-27T13:29:02.000Z
|
compiler.c
|
homma/krc
|
0fdefc15bb97ed4692544a03e7d7b22c9122f662
|
[
"BSD-2-Clause"
] | null | null | null |
compiler.c
|
homma/krc
|
0fdefc15bb97ed4692544a03e7d7b22c9122f662
|
[
"BSD-2-Clause"
] | 1
|
2019-12-27T13:29:04.000Z
|
2019-12-27T13:29:04.000Z
|
// KRC compiler
// Note: What is now '{' here was '{ ' in the BCPL.
#include "common.h"
#include "iolib.h"
#include "listlib.h"
#include "compiler.h"
//----------------------------------------------------------------------
// The KRC system is Copyright (c) D. A. Turner 1981
// All rights reserved. It is distributed as free software under the
// terms in the file "COPYING", which is included in the distribution.
//----------------------------------------------------------------------
// local function declarations
static bool isop(list x);
static bool isinfix(list x);
static bool isrelop(list x);
static word diprio(operator op);
static operator mkinfix(token t);
static void printzf_exp(list x);
static bool islistexp(list e);
static bool isrelation(list x);
static bool isrelation_beginning(list a, list x);
static bool is_non_associative(operator op);
static bool is_right_associative(operator op);
static bool is_left_associative(operator op);
static word leftprec(operator op);
static word rightprec(operator op);
static bool rotate(list e);
static bool parmy(list x);
static list rest(list c);
static list subtract(list x, list y);
static void expr(word n);
static bool startformal(token t);
static bool startsimple(token t);
static void combn(void);
static void simple(void);
static void compilename(atom n);
static word qualifier(void);
static void perform_alpha_conversions();
static bool isgenerator(list t);
static void alpha_convert(list var, list p);
static list skipchunk(list P);
static void conv1(list T, list var, list var1);
static list formal(void);
static list internalise(list val);
static list pattern(void);
static void compilelhs(list lhs, word nargs);
static void compileformal(list x, word i);
static void plant0(instruction op);
static void plant1(instruction op, list a);
static void plant2(instruction op, list a, list b);
static list collectcode(void);
// global variables
void (*TRUEWRCH)(word c) = bcpl_wrch;
list LASTLHS = NIL;
list TRUTH;
list FALSITY;
list INFINITY;
// infix operator names
//
// interesting elements start at [1]
// the indices correspond to the operator values in compiler.h
// EQ_SY was (token)'=', changed DT May 2015
// renamed from INFIXNAMEVEC
static token infix_names[] = {
(token)0, (token)':', PLUSPLUS_SY, DASHDASH_SY, (token)'|',
(token)'&', (token)'>', GE_SY, NE_SY, EQ_SY,
LE_SY, (token)'<', (token)'+', (token)'-', (token)'*',
(token)'/', (token)'%', STARSTAR_SY, (token)'.',
};
// infix operator priorities
//
// renamed from INIFXPRIOVEC
static word infix_pri[] = {0, 0, 0, 0, 1, 2, 3, 3, 3, 3,
3, 3, 4, 4, 5, 5, 5, 6, 6};
// code vector
//
// bases for garbage collection
// store for opcodes and their params, which may be operators,
// various CONStructs or the addresses of C functions.
static list CODEV = NIL;
// appears to be a store for formal parameters
static list ENV[100];
static word ENVP;
void init_codev() {
ENVP = -1;
CODEV = NIL;
}
// check if x is an operator
static bool isop(list x) {
// return x == (list)ALPHA || x == (list)INDIR ||
// ((list)QUOTE <= x && x <= (list)QUOTE_OP);
// check if x is in operator enum - see compiler.h
return (list)ALPHA <= x && x <= (list)QUOTE_OP;
}
// check if x is an infix operator
static bool isinfix(list x) { return (list)COLON_OP <= x && x <= (list)DOT_OP; }
// check if x is a relational operator
static bool isrelop(list x) { return (list)GR_OP <= x && x <= (list)LS_OP; }
// return the priority of an operator from its index in infix_pri
static word diprio(operator op) { return op == -1 ? -1 : infix_pri[op]; }
// make infix operator
//
// takes a token, returns an operator
// else -1 if t not the name of an infix
static operator mkinfix(token t) {
// legacy, accept "=" for "=="
if (t == (token)'=') {
return EQ_OP;
}
// search t in infix_names
// infix operator's range is (COLON_OP(1) .. DOT_OP(18))
word i = 1;
while (!(i > DOT_OP || infix_names[i] == t)) {
i++;
}
// not found
if (i > DOT_OP) {
return -1;
}
return i;
}
// print expression
//
// n is the priority level
void printexp(list e, word n) {
if (e == NIL) {
// empty
bcpl_writes("[]");
} else if (isatom(e)) {
// atom
bcpl_writes(NAME((atom)e));
} else if (isnum(e)) {
// number
word x = getnum(e);
if (x < 0 && n > 5) {
wrch('(');
bcpl_writen(x);
wrch(')');
} else {
bcpl_writen(x);
}
} else {
if (!iscons(e)) {
if (e == (list)NOT_OP) {
// NOT op
bcpl_writes("'\\'");
} else if (e == (list)LENGTH_OP) {
// length op
bcpl_writes("'#'");
} else {
fprintf(bcpl_OUTPUT, "<internal value:%p>", e);
}
return;
}
{
// maybe could be operator
list op = getop(e);
if (!isop(op) && n <= 7) {
printexp(op, 7);
wrch(' ');
printexp(next(e), 8);
} else if (op == (list)QUOTE) {
printatom((atom)getval(e), true);
} else if (op == (list)INDIR || op == (list)ALPHA) {
printexp(TL(e), n);
} else if (op == (list)DOTDOT_OP || op == (list)COMMADOTDOT_OP) {
wrch('[');
e = next(e);
printexp(gettoken(e), 0);
if (op == (list)COMMADOTDOT_OP) {
wrch(',');
e = next(e);
printexp(gettoken(e), 0);
}
bcpl_writes("..");
if (next(e) != INFINITY) {
printexp(next(e), 0);
}
wrch(']');
} else if (op == (list)ZF_OP) {
wrch('{');
printzf_exp(next(e));
wrch('}');
} else if (op == (list)NOT_OP && n <= 3) {
wrch('\\');
printexp(next(e), 3);
} else if (op == (list)NEG_OP && n <= 5) {
wrch('-');
printexp(next(e), 5);
} else if (op == (list)LENGTH_OP && n <= 7) {
wrch('#');
printexp(next(e), 7);
} else if (op == (list)QUOTE_OP) {
// '#', '\', 'op'
wrch('\'');
if (next(e) == (list)LENGTH_OP) {
wrch('#');
} else if (next(e) == (list)NOT_OP) {
wrch('\\');
} else {
writetoken(infix_names[(word)next(e)]);
}
wrch('\'');
} else if (islistexp(e)) {
wrch('[');
while (e != NIL) {
printexp(gettoken(next(e)), 0);
// first time : [ next , next_next
// after that : [ e , next , next_next
if (next(next(e)) != NIL) {
wrch(',');
}
e = next(next(e));
}
wrch(']');
} else if (op == (list)AND_OP && n <= 3 && rotate(e) &&
isrelation(getop(next(e))) &&
isrelation_beginning(TL(TL(HD(TL(e)))), TL(TL(e)))) {
// continued relations
printexp(HD(TL(HD(TL(e)))), 4);
wrch(' ');
writetoken(infix_names[(word)HD(HD(TL(e)))]);
wrch(' ');
printexp(TL(TL(e)), 2);
} else if (isinfix(op) && infix_pri[(word)op] >= n) {
printexp(HD(TL(e)), leftprec((operator) op));
// DOT_OP should be spaced, DT 2015
if (op != (list)COLON_OP) {
wrch(' ');
}
writetoken(infix_names[(word)op]);
if (op != (list)COLON_OP) {
wrch(' ');
}
printexp(TL(TL(e)), rightprec((operator) op));
} else {
wrch('(');
printexp(e, 0);
wrch(')');
}
}
}
}
// print ZF expression
static void printzf_exp(list x) {
list y = x;
while (TL(y) != NIL) {
y = TL(y);
}
// body
printexp(HD(y), 0);
// print "such that" as bar '|' if a generator directly follows
if (iscons(HD(x)) && HD(HD(x)) == (list)GENERATOR) {
wrch('|');
} else {
wrch(';');
}
while (TL(x) != NIL) {
list qualifier = HD(x);
if (iscons(qualifier) && HD(qualifier) == (list)GENERATOR) {
printexp(HD(TL(qualifier)), 0);
// deals with repeated generators
while (iscons(TL(x)) &&
#ifdef INSTRUMENT_KRC_GC
iscons(HD(TL(x))) &&
#endif
HD(HD(TL(x))) == (list)GENERATOR &&
equal(TL(TL(HD(TL(x)))), TL(TL(qualifier)))) {
x = TL(x);
qualifier = HD(x);
wrch(',');
printexp(HD(TL(qualifier)), 0);
}
bcpl_writes("<-");
printexp(TL(TL(qualifier)), 0);
} else {
printexp(qualifier, 0);
}
x = TL(x);
if (TL(x) != NIL) {
wrch(';');
}
}
}
// check if e is a list expression
static bool islistexp(list e) {
while (iscons(e) && getop(e) == (list)COLON_OP) {
list e1 = TL(TL(e));
while (iscons(e1) && getop(e1) == (list)INDIR) {
e1 = TL(e1);
}
TL(TL(e)) = e1;
e = e1;
}
return e == NIL;
}
// check if x is a relation ('>', '>=', '\=', '==', '~=', '<=', '<')
static bool isrelation(list x) { return iscons(x) && isrelop(HD(x)); }
// called from printexp
static bool isrelation_beginning(list a, list x) {
// acceptable list: correct?
// (relop a ...)
// (& relop a ...)
// (& & ... relop a ...)
// isrelation(x) && => x = (relop . _)
// equeal(HD(TL(x)), a)) => x = (_ . (a . _))
// => x = (relop . (a . _))
// iscons(x) && => x = (_ . _)
// HD(x) == (list)AND_OP && => x = ('&' . _)
// isrelation_beginning(a, HD(TL(x)))) => x = (_ . (next_x . _))
// => x = ('&' . (next_x . _))
return (isrelation(x) && equal(HD(TL(x)), a)) ||
(iscons(x) && HD(x) == (list)AND_OP &&
isrelation_beginning(a, HD(TL(x))));
}
// relops are non-associative
static bool is_non_associative(operator op) { return isrelop((list)op); }
// colon, append, listdiff, and, or, exp are right-associative
static bool is_right_associative(operator op) {
return op == COLON_OP || op == APPEND_OP || op == LISTDIFF_OP ||
op == AND_OP || op == OR_OP || op == EXP_OP;
}
// all other infixes are left-associative
static bool is_left_associative(operator op) {
return !is_non_associative(op) && !is_right_associative(op);
}
// operator precedences
//
// non-associatives : +1 always
// right associatives : +1 when left
// left associatives : +1 when right
// returns operator precedence
static word leftprec(operator op) {
if (is_right_associative(op) || is_non_associative(op)) {
return infix_pri[op] + 1;
} else {
return infix_pri[op];
}
// return op == COLON_OP || op == APPEND_OP || op == LISTDIFF_OP ||
// op == AND_OP || op == OR_OP || op == EXP_OP ||
// isrelop((list)op)
// ? infix_pri[op] + 1
// : infix_pri[op];
}
// returns operator precedence
static word rightprec(operator op) {
if (is_right_associative(op)) {
return infix_pri[op];
} else {
return infix_pri[op] + 1;
}
// return op == COLON_OP || op == APPEND_OP || op == LISTDIFF_OP ||
// op == AND_OP || op == OR_OP || op == EXP_OP
// ? infix_pri[op]
// : infix_pri[op] + 1;
}
// puts nested and's into rightist form to ensure
// detection of continued relations
static bool rotate(list e) {
while (iscons(HD(TL(e))) && HD(HD(TL(e))) == (list)AND_OP) {
list x = TL(HD(TL(e)));
list c = TL(TL(e));
list a = HD(x);
list b = TL(x);
HD(TL(e)) = a, TL(TL(e)) = cons((list)AND_OP, cons(b, c));
}
return true;
}
// decompiler
// the val field of each user defined name
// contains - cons(cons(nargs, comment), <list of eqns>)
void display(atom id, bool withnos, bool doublespacing) {
if (VAL(id) == NIL) {
fprintf(bcpl_OUTPUT, "\"%s\" - not defined\n", NAME(id));
return;
}
{
list x = HD(VAL(id));
list eqns = TL(VAL(id));
word nargs = (word)(HD(x));
list comment = TL(x);
word n = length(eqns);
LASTLHS = NIL;
if (comment != NIL) {
list c = comment;
fprintf(bcpl_OUTPUT, " %s :-", NAME(id));
while (c != NIL) {
bcpl_writes(NAME((atom)HD(c)));
c = TL(c);
if (c != NIL) {
wrch('\n');
if (doublespacing) {
wrch('\n');
}
}
}
bcpl_writes(";\n");
if (doublespacing) {
wrch('\n');
}
}
if (comment != NIL && n == 1 && HD(TL(HD(eqns))) == (list)CALL_C) {
return;
}
for (word i = 1; i <= n; i++) {
if (withnos && (n > 1 || comment != NIL)) {
fprintf(bcpl_OUTPUT, "%2" W ") ", i);
} else {
bcpl_writes(" ");
}
removelineno(HD(eqns));
displayeqn(id, nargs, HD(eqns));
if (doublespacing) {
wrch('\n');
}
eqns = TL(eqns);
}
}
}
static void shch(word ch) { TRUEWRCH(' '); }
// equation decoder
void displayeqn(atom id, word nargs, list eqn) {
list lhs = HD(eqn);
list code = TL(eqn);
if (nargs == 0) {
bcpl_writes(NAME(id));
LASTLHS = (list)id;
} else {
if (equal(lhs, LASTLHS)) {
wrch = shch;
} else {
LASTLHS = lhs;
}
printexp(lhs, 0);
wrch = TRUEWRCH;
}
bcpl_writes(" = ");
if (HD(code) == (list)CALL_C) {
bcpl_writes("<primitive function>");
} else {
displayrhs(lhs, nargs, code);
}
wrch('\n');
}
void displayrhs(list lhs, word nargs, list code) {
list v[100];
word i = nargs;
bool if_flag = false;
// unpack formal parameters into v
while (i > 0) {
i = i - 1;
v[i] = TL(lhs);
lhs = HD(lhs);
}
i = nargs - 1;
do {
switch ((word)(HD(code))) {
case LOAD_C:
code = TL(code);
i++;
v[i] = HD(code);
break;
case LOADARG_C:
code = TL(code);
i++;
v[i] = v[(word)(HD(code))];
break;
case APPLY_C:
i--;
v[i] = cons(v[i], v[i + 1]);
break;
case APPLYINFIX_C:
code = TL(code);
i--;
v[i] = cons(HD(code), cons(v[i], v[i + 1]));
break;
case CONTINUE_INFIX_C:
code = TL(code);
v[i - 1] = cons(HD(code), cons(v[i - 1], v[i]));
// note that 2nd arg is left in place above
// new expression
break;
case IF_C:
if_flag = true;
break;
case FORMLIST_C:
code = TL(code);
i++;
v[i] = NIL;
for (word j = 1; j <= (word)(HD(code)); j++) {
i = i - 1;
v[i] = cons((list)COLON_OP, cons(v[i], v[i + 1]));
}
break;
case FORMZF_C:
code = TL(code);
i = i - (word)(HD(code));
v[i] = cons(v[i], NIL);
for (word j = (word)(HD(code)); j >= 1; j = j - 1) {
v[i] = cons(v[i + j], v[i]);
}
v[i] = cons((list)ZF_OP, v[i]);
break;
case CONT_GENERATOR_C:
code = TL(code);
for (word j = 1; j <= (word)(HD(code)); j++) {
v[i - j] = cons((list)GENERATOR, cons(v[i - j], TL(TL(v[i]))));
}
break;
case MATCH_C:
case MATCHARG_C:
code = TL(code);
code = TL(code);
break;
case MATCHPAIR_C:
code = TL(code);
{
list x = v[(word)HD(code)];
i = i + 2;
v[i - 1] = HD(TL(x)), v[i] = TL(TL(x));
}
break;
case STOP_C:
printexp(v[i], 0);
if (!if_flag) {
return;
}
bcpl_writes(", ");
printexp(v[i - 1], 0);
return;
default:
bcpl_writes("IMPOSSIBLE INSTRUCTION IN \"displayrhs\"\n");
}
// end of switch
code = TL(code);
} while (1);
}
// extracts that part of the code which
// determines which cases this equation applies to
list profile(list eqn) {
list code = TL(eqn);
if (HD(code) == (list)LINENO_C) {
code = TL(TL(code));
}
{
list c = code;
while (parmy(HD(c))) {
c = rest(c);
}
{
list hold = c;
while (!(HD(c) == (list)IF_C || HD(c) == (list)STOP_C)) {
c = rest(c);
}
if (HD(c) == (list)IF_C) {
return subtract(code, c);
} else {
return subtract(code, hold);
}
}
}
}
static bool parmy(list x) {
return x == (list)MATCH_C || x == (list)MATCHARG_C || x == (list)MATCHPAIR_C;
}
// removes one complete instruction from C
static list rest(list c) {
list x = HD(c);
c = TL(c);
if (x == (list)APPLY_C || x == (list)IF_C || x == (list)STOP_C) {
return c;
}
c = TL(c);
if (!(x == (list)MATCH_C || x == (list)MATCHARG_C)) {
return c;
}
return TL(c);
}
// list subtraction
static list subtract(list x, list y) {
list z = NIL;
while (x != y) {
z = cons(HD(x), z), x = TL(x);
}
// note the result is reversed - for our purposes this does not matter
return z;
}
// called whenever the definiendum is subject of a
// display,reorder or (partial)delete command - has the effect of
// restoring the standard line numbering
void removelineno(list eqn) {
if (HD(TL(eqn)) == (list)LINENO_C) {
TL(eqn) = TL(TL(TL(eqn)));
}
}
// compiler for krc expressions and equations
// renamed from exp as the name conflicts with exp(3)
list expression() {
init_codev();
expr(0);
plant0(STOP_C);
return collectcode();
}
// returns a triple: cons(subject,cons(nargs,eqn))
list equation() {
list subject = 0;
list lhs = 0;
word nargs = 0;
init_codev();
if (haveid()) {
// avoid global variables
// subject = (list)THE_ID;
// lhs = (list)THE_ID;
subject = (list)the_id();
lhs = (list)the_id();
while (startformal(HD(TOKENS))) {
lhs = cons(lhs, formal());
nargs = nargs + 1;
}
} else if (HD(TOKENS) == (list)'=' && LASTLHS != NIL) {
subject = LASTLHS;
lhs = LASTLHS;
while (iscons(subject)) {
subject = HD(subject);
nargs = nargs + 1;
}
} else {
syntax();
bcpl_writes("missing LHS\n");
return NIL;
}
compilelhs(lhs, nargs);
{
list code = collectcode();
check((token)'=');
expr(0);
plant0(STOP_C);
{
list expcode = collectcode();
// change from EMAS/KRC to allow guarded simple def
if (have((token)',')) {
expr(0);
plant0(IF_C);
code = append(code, append(collectcode(), expcode));
} else {
code = append(code, expcode);
}
if (HD(TOKENS) != EOFTOKEN) {
check(EOL);
}
if (!ERRORFLAG) {
LASTLHS = lhs;
}
if (nargs == 0) {
lhs = 0;
}
// in this case the lhs field is used to remember
// the value of the variable - 0 means not yet set
// OK
return cons(subject, cons((list)nargs, cons(lhs, code)));
}
}
}
// n is the priority level
static void expr(word n) {
if (n <= 3 && (have((token)'\\') || have((token)'~'))) {
plant1(LOAD_C, (list)NOT_OP);
expr(3);
plant0(APPLY_C);
} else if (n <= 5 && have((token)'+')) {
expr(5);
} else if (n <= 5 && have((token)'-')) {
plant1(LOAD_C, (list)NEG_OP);
expr(5);
plant0(APPLY_C);
} else if (have((token)'#')) {
plant1(LOAD_C, (list)LENGTH_OP);
combn();
plant0(APPLY_C);
} else if (startsimple(HD(TOKENS))) {
combn();
} else {
syntax();
return;
}
{
operator op = mkinfix(HD(TOKENS));
while (diprio(op) >= n) {
// for continued relations
word and_count = 0;
TOKENS = TL(TOKENS);
expr(rightprec(op));
if (ERRORFLAG) {
return;
}
while (isrelop((list)op) && isrelop((list)mkinfix(HD(TOKENS)))) {
// continued relations
and_count = and_count + 1;
plant1(CONTINUE_INFIX_C, (list)op);
op = mkinfix(HD(TOKENS));
TOKENS = TL(TOKENS);
expr(4);
if (ERRORFLAG) {
return;
}
}
plant1(APPLYINFIX_C, (list)op);
for (word i = 1; i <= and_count; i++) {
plant1(APPLYINFIX_C, (list)AND_OP);
}
// for continued relations
op = mkinfix(HD(TOKENS));
}
}
}
static void combn() {
simple();
while (startsimple(HD(TOKENS))) {
simple();
plant0(APPLY_C);
}
}
static bool startformal(token t) {
// return iscons(t) ? (HD(t) == IDENT || HD(t) == (list)CONST)
// : t == (token)'(' || t == (token)'[' || t == (token)'-';
if (iscons(t)) {
// identifier or constant
return (HD(t) == IDENT || HD(t) == (list)CONST);
} else {
// '(', '[', '-'
return t == (token)'(' || t == (token)'[' || t == (token)'-';
}
}
static bool startsimple(token t) {
// return iscons(t) ? (HD(t) == IDENT || HD(t) == (list)CONST)
// : t == (token)'(' || t == (token)'[' || t == (token)'{' ||
// t == (token)'\'';
if (iscons(t)) {
// identifier or constant
return (HD(t) == IDENT || HD(t) == (list)CONST);
} else {
// '(', '[', '{', '\''
return t == (token)'(' || t == (token)'[' || t == (token)'{' ||
t == (token)'\'';
}
}
static void simple() {
if (haveid()) {
// avoid global variables
// compilename(THE_ID);
compilename(the_id());
} else if (haveconst()) {
// avoid global variables
// plant1(LOAD_C, (list)internalise(THE_CONST));
plant1(LOAD_C, (list)internalise(the_const()));
} else if (have((token)'(')) {
// (
expr(0);
// (_)
check((token)')');
} else if (have((token)'[')) {
// [
if (have((token)']')) {
// [] => NIL
plant1(LOAD_C, NIL);
} else {
word n = 1;
expr(0);
if (have((token)',')) {
// [_,
expr(0);
n = n + 1;
}
if (have(DOTDOT_SY)) {
// [_,_.. => COMMADOTDOT
// [_.. => DOTDOT
if (HD(TOKENS) == (token)']') {
// [_..]
plant1(LOAD_C, INFINITY);
} else {
expr(0);
}
if (n == 2) {
plant0(APPLY_C);
}
plant1(APPLYINFIX_C, (list)(n == 1 ? DOTDOT_OP : COMMADOTDOT_OP));
// OK
} else {
while (have((token)',')) {
// [_,_, ...
expr(0);
n = n + 1;
}
plant1(FORMLIST_C, (list)n);
// OK
}
check((token)']');
}
} else if (have((token)'{')) {
// {
// ZF expressions bug?
word n = 0;
// unused
// list hold = TOKENS;
perform_alpha_conversions();
expr(0);
// implicit zf body no longer legal
// if ( HD(TOKENS) == BACKARROW_SY ) { TOKENS = hold; } else
// {_;
check((token)';');
// {_;_;_; ...
do {
n = n + qualifier();
} while (have((token)';'));
// OK
plant1(FORMZF_C, (list)n);
// {_;_}
check((token)'}');
} else if (have((token)'\'')) {
// QUOTE_OP
// operator denotation -- `'#' [1,2,3]?`, `'\' (0==1)?`, `'+' 2 3?`
// '
if (have((token)'#')) {
// '#
plant1(LOAD_C, (list)LENGTH_OP);
} else if (have((token)'\\') || have((token)'~')) {
// '\
// '~
plant1(LOAD_C, (list)NOT_OP);
} else {
operator op = mkinfix((token)(HD(TOKENS)));
if (isinfix((list)op)) {
TOKENS = TL(TOKENS);
} else {
// missing infix or prefix operator
syntax();
}
plant1(LOAD_C, (list)QUOTE_OP);
plant1(LOAD_C, (list)op);
plant0(APPLY_C);
}
// '#', '\', '~', '+', ...
check((token)'\'');
} else
// missing identifier|constant|(|[|{
syntax();
}
static void compilename(atom n) {
word i = 0;
while (!(i > ENVP || ENV[i] == (list)n)) {
i = i + 1;
}
if (i > ENVP) {
plant1(LOAD_C, (list)n);
} else {
// OK
plant1(LOADARG_C, (list)i);
}
}
static word qualifier() {
// what about more general formals?
if (isgenerator(TL(TOKENS))) {
word n = 0;
do {
haveid();
// avoid global variables
// plant1(LOAD_C, (list)THE_ID;
plant1(LOAD_C, (list)the_id());
n = n + 1;
} while (have((token)','));
check(BACKARROW_SY);
expr(0);
plant1(APPLYINFIX_C, (list)GENERATOR);
if (n > 1) {
// OK
plant1(CONT_GENERATOR_C, (list)(n - 1));
}
return n;
} else {
expr(0);
return 1;
}
}
static void perform_alpha_conversions() {
list p = TOKENS;
while (!(HD(p) == (token)'}' || HD(p) == (token)']' || HD(p) == EOL)) {
if (HD(p) == (token)'[' || HD(p) == (token)'{') {
p = skipchunk(p);
continue;
}
// recognises the "such that" bar '|' and converts it to ';'
// to distinguish it from "or"
if (HD(p) == (token)'|' && isid(HD(TL(p))) && isgenerator(TL(TL(p)))) {
HD(p) = (token)';';
}
if (isid(HD(p)) && isgenerator(TL(p))) {
alpha_convert(HD(p), TL(p));
}
p = TL(p);
}
}
bool isid(list x) { return iscons(x) && HD(x) == IDENT; }
static bool isgenerator(list t) {
return !iscons(t) ? false
: HD(t) == BACKARROW_SY ||
(HD(t) == (token)',' && isid(HD(TL(t))) &&
isgenerator(TL(TL(t))));
}
static void alpha_convert(list var, list p) {
list t = TOKENS;
list var1 = cons((list)ALPHA, TL(var));
list edge = t;
while (!(HD(edge) == (token)';' || HD(edge) == BACKARROW_SY ||
HD(edge) == EOL)) {
edge = skipchunk(edge);
}
while (t != edge) {
conv1(t, var, var1);
t = TL(t);
}
t = p;
while (!(HD(t) == (token)';' || HD(t) == EOL)) {
t = skipchunk(t);
}
edge = t;
while (
!(HD(edge) == (token)'}' || HD(edge) == (token)']' || HD(edge) == EOL)) {
edge = skipchunk(edge);
}
while (t != edge) {
conv1(t, var, var1);
t = TL(t);
}
TL(var) = var1;
}
static list skipchunk(list p) {
// select a bracket
word ket = HD(p) == (token)'{' ? '}' : HD(p) == (token)'[' ? ']' : -1;
p = TL(p);
// NG
if (ket == -1) {
return p;
}
while (!(HD(p) == (list)ket || HD(p) == EOL)) {
p = skipchunk(p);
}
if (HD(p) != EOL) {
p = TL(p);
}
return (p);
}
static void conv1(list t, list var, list var1) {
if (equal(HD(t), var) && HD(t) != var) {
TL(HD(t)) = var1;
}
}
static list formal() {
if (haveid()) {
// avoid global variables
// return (list)THE_ID;
return (list)the_id();
} else if (haveconst()) {
// avoid global variables
// return internalise(THE_CONST);
return internalise(the_const());
} else if (have((token)'(')) {
list p = pattern();
check((token)')');
return p;
} else if (have((token)'[')) {
list plist = NIL;
list p = NIL;
if (have((token)']')) {
return NIL;
}
do {
plist = cons(pattern(), plist);
} while (have((token)','));
// note they are in reverse order
check((token)']');
while (plist != NIL) {
p = cons((token)COLON_OP, cons(HD(plist), p));
plist = TL(plist);
}
// now they are in correct order
return p;
} else if (have((token)'-') && havenum()) {
// avoid global variables
// THE_NUM = -THE_NUM;
// return stonum(THE_NUM);
negate_the_num();
return stonum(the_num());
} else {
// MISSING identifier|constant|(|[
syntax();
return NIL;
}
}
static list internalise(list val) {
// return val == TL(TRUTH)
// ? TRUTH
// : val == TL(FALSITY) ? FALSITY
// : isatom(val) ? cons((list)QUOTE, val) :
// val;
if (val == getval(TRUTH)) {
// TRUTH = (QUOTE . "TRUE")
return TRUTH;
} else if (val == getval(FALSITY)) {
// FALSITY = (QUOTE . "FALSE")
return FALSITY;
} else if (isatom(val)) {
// (QUOTE . atom)
return cons((list)QUOTE, val);
} else {
return val;
}
}
static list pattern() {
list p = formal();
if (have((token)':')) {
p = cons((list)COLON_OP, cons(p, pattern()));
}
return p;
}
static void compilelhs(list lhs, word nargs) {
ENVP = nargs - 1;
for (word i = 1; i <= nargs; i++) {
ENV[nargs - i] = TL(lhs);
lhs = HD(lhs);
}
for (word i = 0; i <= nargs - 1; i++) {
compileformal(ENV[i], i);
}
}
static void compileformal(list x, word i) {
// identifier
if (isatom(x)) {
word j = 0;
while (!(j >= i || ENV[j] == x)) {
// is this a repeated name?
j = j + 1;
}
if (j >= i) {
// no, no code compiled
return;
} else {
plant2(MATCHARG_C, (list)i, (list)j);
}
} else if (isnum(x) || x == NIL || (iscons(x) && HD(x) == (list)QUOTE)) {
plant2(MATCH_C, (list)i, x);
} else if (iscons(x) && HD(x) == (token)COLON_OP && iscons(TL(x))) {
// OK
plant1(MATCHPAIR_C, (list)i);
ENVP = ENVP + 2;
{
word a = ENVP - 1;
word b = ENVP;
ENV[a] = HD(TL(x));
ENV[b] = TL(TL(x));
compileformal(ENV[a], a);
compileformal(ENV[b], b);
}
} else {
bcpl_writes("Impossible event in \"compileformal\"\n");
}
}
// plant stores instructions and their operands in the code vector
// op is always an instruction code (*_C);
// a and b can be operators (*_op), INTs, CONSTs, IDs (names) or
// the address of a C function - all are mapped to list type.
// APPLY_C IF_C STOP_C
static void plant0(instruction op) {
// CODEV = (op . CODEV)
CODEV = cons((list)op, CODEV);
}
// everything else
static void plant1(instruction op, list a) {
// CODEV = (a . (op . CODEV))
CODEV = cons((list)op, CODEV);
CODEV = cons(a, CODEV);
}
// MATCH_C MATCHARG_C
static void plant2(instruction op, list a, list b) {
// CODEV = (b . (a . (op . CODEV)))
CODEV = cons((list)op, CODEV);
CODEV = cons(a, CODEV);
CODEV = cons(b, CODEV);
}
// flushes the code buffer
static list collectcode() {
list tmp = CODEV;
CODEV = NIL;
return reverse(tmp);
}
// mark elements in CODEV and ENV for preservation by the GC.
// this routine should be called by your bases() function.
void compiler_bases(void (*f)(list *)) {
f(&CODEV);
// ENVP indexes the last used element and starts as -1.
for (word i = 0; i <= ENVP; i++) {
f(&ENV[i]);
}
}
| 19.890656
| 80
| 0.506947
|
[
"vector"
] |
19c3276591815b0037fc386f4ccbf737c7baaf7a
| 1,143
|
h
|
C
|
include/Util/SimultaneousDiagonalization.h
|
roman-ellerbrock/QuTree
|
28c5b4eddf20e41cd015a03d33f31693eff17839
|
[
"MIT"
] | 6
|
2020-04-24T09:58:23.000Z
|
2022-02-06T03:40:55.000Z
|
include/Util/SimultaneousDiagonalization.h
|
roman-ellerbrock/QuTree
|
28c5b4eddf20e41cd015a03d33f31693eff17839
|
[
"MIT"
] | 1
|
2020-06-18T11:33:14.000Z
|
2020-06-18T11:35:23.000Z
|
include/Util/SimultaneousDiagonalization.h
|
roman-ellerbrock/QuTree
|
28c5b4eddf20e41cd015a03d33f31693eff17839
|
[
"MIT"
] | 1
|
2020-12-26T15:23:21.000Z
|
2020-12-26T15:23:21.000Z
|
#pragma once
#include "Core/Matrix.h"
#include "Core/Vector.h"
#include "Core/stdafx.h"
#include <random>
#include "JacobiRotationFramework.h"
using namespace JacobiRotationFramework;
/**
* \class SimultaneousDiagonalization
* \ingroup Util
* \brief This class performs a simulatneous diagonalization.
*
* Attempts to diagonalize a set of, potentially not commuting, matrices.
*/
class SimultaneousDiagonalization {
public:
SimultaneousDiagonalization() = default;
~SimultaneousDiagonalization() = default;
// Initialize Simultaneous Diagonalization
void initialization(vector<Matrixcd>& A, double eps);
// Perform the Simultaneous Diagonalization
void calculate(vector<Matrixcd>& A, Matrixcd& trafo);
protected:
// Perform a cycle of rotations over all matrices in A
void jacobiRotations(vector<Matrixcd>& A, Matrixcd& trafo);
// Measure off-Diagonality
double measureOffDiagonals(const vector<Matrixcd>& A);
// Measure Diagonality
double measureDiagonality(vector<Matrixcd>& A);
// Preconditioning of SD
void initialTransformation(vector<Matrixcd>& A, Matrixcd& trafo);
int dim_;
int nmat_;
double eps_;
};
| 24.319149
| 73
| 0.767279
|
[
"vector"
] |
19c3c15ce3cba1276febf810d02b7f21b6f8ba39
| 247
|
h
|
C
|
CPURenderer/pch.h
|
shamanDevel/IsosurfaceSuperresolution
|
0658e67b7ca9f633547c65e3e16f93d2e0c5a4a2
|
[
"MIT"
] | 7
|
2019-10-14T09:36:57.000Z
|
2022-02-27T05:13:28.000Z
|
CPURenderer/pch.h
|
shamanDevel/IsosurfaceSuperresolution
|
0658e67b7ca9f633547c65e3e16f93d2e0c5a4a2
|
[
"MIT"
] | null | null | null |
CPURenderer/pch.h
|
shamanDevel/IsosurfaceSuperresolution
|
0658e67b7ca9f633547c65e3e16f93d2e0c5a4a2
|
[
"MIT"
] | 3
|
2020-01-07T16:49:17.000Z
|
2021-06-23T14:21:00.000Z
|
#ifndef PCH_H
#define PCH_H
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <limits>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <openvdb/openvdb.h>
#endif //PCH_H
| 14.529412
| 28
| 0.732794
|
[
"vector"
] |
9fd8548f5c10e563503b90563b6e7c8d8e12d31b
| 819
|
h
|
C
|
src/asf_odl/include/Obj.h
|
glshort/MapReady
|
c9065400a64c87be46418ab32e3a251ca2f55fd5
|
[
"BSD-3-Clause"
] | 3
|
2017-12-31T05:33:28.000Z
|
2021-07-28T01:51:22.000Z
|
src/asf_odl/include/Obj.h
|
glshort/MapReady
|
c9065400a64c87be46418ab32e3a251ca2f55fd5
|
[
"BSD-3-Clause"
] | null | null | null |
src/asf_odl/include/Obj.h
|
glshort/MapReady
|
c9065400a64c87be46418ab32e3a251ca2f55fd5
|
[
"BSD-3-Clause"
] | 7
|
2017-04-26T18:18:33.000Z
|
2020-05-15T08:01:09.000Z
|
/*=============================================================================
| @(#)Obj.h 1.2 96/02/23 19:10:04
|
| Basic Object Class
| Copyright (C) Jet Propulsion Laboratory.
| Alaska SAR Facility (ASF) Project.
|
*============================================================================*/
#ifndef _OBJ_H_
#define _OBJ_H_
#include "Msg.h"
#ifdef NOSTDARG
typedef void* (*Method_t)();
#else
typedef void* (*Method_t)(Msg_t, ...);
#endif
typedef struct {
Method_t send;
} Obj_t;
#ifdef NOSTDARG
extern Obj_t* Obj();
#else
extern Obj_t* Obj(Msg_t, ...);
#endif
#ifdef _NO_PROTO
extern Method_t Type();
#else
extern Method_t Type(void* obj);
#endif
#ifndef NewObj
#define NewObj(_obj,_method) Obj(_Init,_obj,_method)
#endif
#ifndef NULL
#define NULL 0
#endif
#endif /*!_OBJ_H_ */
| 17.425532
| 80
| 0.542125
|
[
"object"
] |
9fef596912c1345fde1b0c5b1aba10f5da0af6e6
| 4,303
|
h
|
C
|
src/config.h
|
snauts/psychedelics
|
f4d2de8e818f19cd5cc79aa9aa1c007aa28827e1
|
[
"MIT"
] | null | null | null |
src/config.h
|
snauts/psychedelics
|
f4d2de8e818f19cd5cc79aa9aa1c007aa28827e1
|
[
"MIT"
] | null | null | null |
src/config.h
|
snauts/psychedelics
|
f4d2de8e818f19cd5cc79aa9aa1c007aa28827e1
|
[
"MIT"
] | null | null | null |
#ifndef GAME2D_CONFIG_H
#define GAME2D_CONFIG_H
#include "common.h"
/* Cached configuration (mostly read from config.lua). */
struct Config {
int debug;
int fullscreen;
int flip; /* True if device is flipped bottom up. */
int retina; /* True if retina (high-density) display. */
char device[32]; /* Internal device name. */
/*
* Pixel scale refers to texture pixels not mapping directly onto world
* coordinate space. If its value is 2, then a sprite of dimensions
* 50x30 will map to world size 100x60.
*
* This has been introduced due to iPhone retina display devices. If we
* want to stay compatible with older models (screen size 480x320),
* while not sacrificing any presicion on the retina iPhones, then we
* assume our world to have as many units as it would on the newer
* phones. For the non-retina iPhones however, sprites are automatically
* upscaled by a factor of 2.
*/
unsigned pixel_scale;
/*
* If true, application will dynamically update its data from online
* server.
*/
int download_update;
unsigned FPSUpdateInterval;
int gameSpeed;
uint32_t defaultShapeColor;
char version[10]; /* Engine version. */
char location[128]; /* User application location path. */
char name[16]; /* User application name. */
/*
* grid_expand Auto expand grid. Use when fine-tuning space
* partitioning.
* grid_info Print information about the grid when world is
* destroyed.
* grid_many How many objects in a cell are considered "many".
*/
int grid_expand;
int grid_info;
unsigned grid_many;
/* Virtual screen size used by scripts. */
unsigned screen_width;
unsigned screen_height;
int use_desktop; /* Use desktop size as window size. */
unsigned window_width;
unsigned window_height;
float w_t, w_b, w_l, w_r; /* Framebuffer quad coords. */
/*
* collision_dist Expand shape bounding box by `collision_dist`
* units to check for simultaneous collisions.
* cam_vicinity_factor Determines how far outside camera visibility
* bodies remain active.
*/
int collision_dist;
float cam_vicinity_factor;
/* Memory pool sizes. */
struct poolsize_t {
int world;
int body;
int tile;
int shape;
int group;
int camera;
int texture;
int spritelist;
int timer;
int gridcell;
int property;
int collision;
int touch;
int hackevent;
int bodytrace;
int tiletrace;
int shapetrace;
int sound;
int music;
} poolsize;
};
extern struct Config config;
int cfg_read(const char *source);
void cfg_close(void);
/* Retrieve configuration. */
float cfg_get_float(const char *key);
void cfg_get_cstr(const char *key, char *buf, unsigned bufsize);
uint32_t cfg_get_color(const char *key);
int cfg_get_int(const char *key);
int cfg_get_bool(const char *key);
int cfg_has_key(const char *key);
#define GET_CFG(key, method, default_value) \
(cfg_has_key(key) ? method(key) : (default_value))
/* Modify configuration. */
void cfg_set_str(const char *key, const char *value);
#endif /* GAME2D_CONFIG_H */
| 37.745614
| 81
| 0.506391
|
[
"shape"
] |
9ff78907130cf96dae284cea98c432afab1d1413
| 1,271
|
h
|
C
|
src/Capturer/Win32/DXGICapturer.h
|
gooer135/appveyor-test
|
626be99203ac67a1a7fb26b12e45d0b167ffbbde
|
[
"MIT"
] | null | null | null |
src/Capturer/Win32/DXGICapturer.h
|
gooer135/appveyor-test
|
626be99203ac67a1a7fb26b12e45d0b167ffbbde
|
[
"MIT"
] | null | null | null |
src/Capturer/Win32/DXGICapturer.h
|
gooer135/appveyor-test
|
626be99203ac67a1a7fb26b12e45d0b167ffbbde
|
[
"MIT"
] | null | null | null |
#ifndef _H_DXGICAPTURER_
#define _H_DXGICAPTURER_
#define __DXGI__
class DXGICapturer : public Capturer
{
private:
static DXGICapturer* instance;
public:
static DXGICapturer* getInstance(void);
private:
DXGICapturer(void);
DXGICapturer(DXGICapturer&) = delete;
~DXGICapturer(void);
public:
const std::vector<puff::type_helper::screen_t*>& getAvailableScreens(void) const;
public:
virtual bool isHWAccelerated(void) const override;
public:
bool capture(const SharableTarget* target, std::uint8_t** dstBuffer, std::size_t* byteWritten, PixelType* dstPixelType, const Area& originalArea) override;
private:
void release(void);
private:
ID3D11Device* device;
ID3D11DeviceContext* deviceContext;
IDXGIDevice* dxgiDevice;
IDXGIAdapter* dxgiAdapter;
IDXGIFactory2* dxgiFactory;
std::unordered_map<HMONITOR, IDXGIOutput*> output;
std::unordered_map<HMONITOR, IDXGIOutput1*> output1;
HMONITOR currentMonitor;
IDXGIOutputDuplication* duplication;
std::unordered_map<HMONITOR, ID3D11Texture2D*> cpuAccessTexture;
std::unordered_map<HMONITOR, puff::type_helper::screen_t*> screenInstances;
std::vector<puff::type_helper::screen_t*> availableScreens;
std::unordered_map<HMONITOR, bool> cachedDuplication;
uv_mutex_t mutex;
bool failed;
};
#endif
| 24.921569
| 156
| 0.79229
|
[
"vector"
] |
9ffcbcda8b4e7faddb8e1b28bd8126f4a71dbd2c
| 1,441
|
h
|
C
|
include/rustfp/all.h
|
guhwanbae/rustfp
|
5d89523f0f1373de5b87ea9a582a4882be99541e
|
[
"MIT"
] | 10
|
2018-10-05T22:31:10.000Z
|
2022-03-01T09:47:16.000Z
|
include/rustfp/all.h
|
guhwanbae/rustfp
|
5d89523f0f1373de5b87ea9a582a4882be99541e
|
[
"MIT"
] | 12
|
2017-08-26T03:27:14.000Z
|
2020-12-23T04:39:06.000Z
|
include/rustfp/all.h
|
guhwanbae/rustfp
|
5d89523f0f1373de5b87ea9a582a4882be99541e
|
[
"MIT"
] | 1
|
2022-03-02T13:16:20.000Z
|
2022-03-02T13:16:20.000Z
|
/**
* Contains Rust Iterator all equivalent implementation.
*
* all function:
* https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.all
*
* @author Chen Weiguang
* @version 0.1.0
*/
#pragma once
#include "traits.h"
#include "util.h"
#include <type_traits>
#include <utility>
namespace rustfp {
// declaration section
template <class F>
class AllOp {
public:
template <class Fx>
explicit AllOp(Fx &&f);
template <class Iterator>
auto operator()(Iterator &&it) && -> bool;
private:
F f;
};
/**
* fn all<F>(&mut self, f: F) -> bool
* where
* F: FnMut(Self::Item) -> bool,
*/
template <class F>
auto all(F &&f) -> AllOp<special_decay_t<F>>;
// implementation section
template <class F>
template <class Fx>
AllOp<F>::AllOp(Fx &&f) : f(std::forward<Fx>(f)) {
}
template <class F>
template <class Iterator>
auto AllOp<F>::operator()(Iterator &&it) && -> bool {
static_assert(
!std::is_lvalue_reference<Iterator>::value,
"all can only take rvalue ref object with Iterator traits");
while (true) {
auto next_opt = it.next();
if (next_opt.is_none()) {
break;
}
if (!f(std::move(next_opt).unwrap_unchecked())) {
return false;
}
}
return true;
}
template <class F>
auto all(F &&f) -> AllOp<special_decay_t<F>> {
return AllOp<special_decay_t<F>>(std::forward<F>(f));
}
} // namespace rustfp
| 18.474359
| 68
| 0.613463
|
[
"object"
] |
b002b75d1d858cd4945550471f4e3d7f1b85ba93
| 10,885
|
h
|
C
|
src/ComboBoxItem.h
|
TimoKunze/ComboListBoxControls
|
9dcad1f7452429fd91aa33fe3e5c13c827fbcabf
|
[
"MIT"
] | 2
|
2019-12-12T08:11:34.000Z
|
2020-10-02T09:57:12.000Z
|
src/ComboBoxItem.h
|
TimoKunze/ComboListBoxControls
|
9dcad1f7452429fd91aa33fe3e5c13c827fbcabf
|
[
"MIT"
] | null | null | null |
src/ComboBoxItem.h
|
TimoKunze/ComboListBoxControls
|
9dcad1f7452429fd91aa33fe3e5c13c827fbcabf
|
[
"MIT"
] | 2
|
2018-05-05T02:32:16.000Z
|
2021-12-09T18:21:23.000Z
|
//////////////////////////////////////////////////////////////////////
/// \class ComboBoxItem
/// \author Timo "TimoSoft" Kunze
/// \brief <em>Wraps an existing combo item</em>
///
/// This class is a wrapper around a combo box item that - unlike an item wrapped by
/// \c VirtualComboBoxItem - really exists in the control.
///
/// \if UNICODE
/// \sa CBLCtlsLibU::IComboBoxItem, VirtualComboBoxItem, ComboBoxItems, ComboBox
/// \else
/// \sa CBLCtlsLibA::IComboBoxItem, VirtualComboBoxItem, ComboBoxItems, ComboBox
/// \endif
//////////////////////////////////////////////////////////////////////
#pragma once
#include "res/resource.h"
#ifdef UNICODE
#include "CBLCtlsU.h"
#else
#include "CBLCtlsA.h"
#endif
#include "_IComboBoxItemEvents_CP.h"
#include "helpers.h"
#include "ComboBox.h"
class ATL_NO_VTABLE ComboBoxItem :
public CComObjectRootEx<CComSingleThreadModel>,
public CComCoClass<ComboBoxItem, &CLSID_ComboBoxItem>,
public ISupportErrorInfo,
public IConnectionPointContainerImpl<ComboBoxItem>,
public Proxy_IComboBoxItemEvents<ComboBoxItem>,
#ifdef UNICODE
public IDispatchImpl<IComboBoxItem, &IID_IComboBoxItem, &LIBID_CBLCtlsLibU, /*wMajor =*/ VERSION_MAJOR, /*wMinor =*/ VERSION_MINOR>
#else
public IDispatchImpl<IComboBoxItem, &IID_IComboBoxItem, &LIBID_CBLCtlsLibA, /*wMajor =*/ VERSION_MAJOR, /*wMinor =*/ VERSION_MINOR>
#endif
{
friend class ComboBox;
friend class ComboBoxItems;
friend class ClassFactory;
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
DECLARE_REGISTRY_RESOURCEID(IDR_COMBOBOXITEM)
BEGIN_COM_MAP(ComboBoxItem)
COM_INTERFACE_ENTRY(IComboBoxItem)
COM_INTERFACE_ENTRY(IDispatch)
COM_INTERFACE_ENTRY(ISupportErrorInfo)
COM_INTERFACE_ENTRY(IConnectionPointContainer)
END_COM_MAP()
BEGIN_CONNECTION_POINT_MAP(ComboBoxItem)
CONNECTION_POINT_ENTRY(__uuidof(_IComboBoxItemEvents))
END_CONNECTION_POINT_MAP()
DECLARE_PROTECT_FINAL_CONSTRUCT()
#endif
//////////////////////////////////////////////////////////////////////
/// \name Implementation of ISupportErrorInfo
///
//@{
/// \brief <em>Retrieves whether an interface supports the \c IErrorInfo interface</em>
///
/// \param[in] interfaceToCheck The IID of the interface to check.
///
/// \return \c S_OK if the interface identified by \c interfaceToCheck supports \c IErrorInfo;
/// otherwise \c S_FALSE.
///
/// \sa <a href="https://msdn.microsoft.com/en-us/library/ms221233.aspx">IErrorInfo</a>
virtual HRESULT STDMETHODCALLTYPE InterfaceSupportsErrorInfo(REFIID interfaceToCheck);
//@}
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// \name Implementation of IComboBoxItem
///
//@{
/// \brief <em>Retrieves the current setting of the \c Height property</em>
///
/// Retrieves the item's height in pixels.
///
/// \param[out] pValue The property's current setting.
///
/// \return An \c HRESULT error code.
///
/// \remarks If the \c OwnerDrawItems property is not set to \c odiOwnerDrawVariableHeight, this property
/// is read-only. Use the \c IComboBox::ItemHeight property instead.
///
/// \sa put_Height, GetRectangle, ComboBox::get_OwnerDrawItems, ComboBox::get_ItemHeight
virtual HRESULT STDMETHODCALLTYPE get_Height(OLE_YSIZE_PIXELS* pValue);
/// \brief <em>Sets the \c Height property</em>
///
/// Sets the item's height in pixels.
///
/// \param[in] newValue The setting to apply.
///
/// \return An \c HRESULT error code.
///
/// \remarks If the \c OwnerDrawItems property is not set to \c odiOwnerDrawVariableHeight, this property
/// is read-only. Use the \c IComboBox::ItemHeight property instead.
///
/// \sa get_Height, GetRectangle, ComboBox::put_OwnerDrawItems, ComboBox::put_ItemHeight
virtual HRESULT STDMETHODCALLTYPE put_Height(OLE_YSIZE_PIXELS newValue);
/// \brief <em>Retrieves the current setting of the \c ID property</em>
///
/// Retrieves an unique ID identifying this item.
///
/// \param[out] pValue The property's current setting.
///
/// \return An \c HRESULT error code.
///
/// \remarks An item's ID will never change.\n
/// This property is read-only.
///
/// \if UNICODE
/// \sa get_Index, CBLCtlsLibU::ItemIdentifierTypeConstants
/// \else
/// \sa get_Index, CBLCtlsLibA::ItemIdentifierTypeConstants
/// \endif
virtual HRESULT STDMETHODCALLTYPE get_ID(LONG* pValue);
/// \brief <em>Retrieves the current setting of the \c Index property</em>
///
/// Retrieves a zero-based index identifying this item.
///
/// \param[out] pValue The property's current setting.
///
/// \return An \c HRESULT error code.
///
/// \remarks Although adding or removing items changes other items' indexes, the index is the best
/// (and fastest) option to identify an index.\n
/// This property is read-only.
///
/// \if UNICODE
/// \sa get_ID, CBLCtlsLibU::ItemIdentifierTypeConstants
/// \else
/// \sa get_ID, CBLCtlsLibA::ItemIdentifierTypeConstants
/// \endif
virtual HRESULT STDMETHODCALLTYPE get_Index(LONG* pValue);
/// \brief <em>Retrieves the current setting of the \c ItemData property</em>
///
/// Retrieves the \c LONG value associated with the item. Use this property to associate any data
/// with the item.
///
/// \param[out] pValue The property's current setting.
///
/// \return An \c HRESULT error code.
///
/// \sa put_ItemData, ComboBox::Raise_FreeItemData
virtual HRESULT STDMETHODCALLTYPE get_ItemData(LONG* pValue);
/// \brief <em>Sets the \c ItemData property</em>
///
/// Sets the \c LONG value associated with the item. Use this property to associate any data
/// with the item.
///
/// \param[in] newValue The setting to apply.
///
/// \return An \c HRESULT error code.
///
/// \sa get_ItemData, ComboBox::Raise_FreeItemData
virtual HRESULT STDMETHODCALLTYPE put_ItemData(LONG newValue);
/// \brief <em>Retrieves the current setting of the \c Selected property</em>
///
/// Retrieves whether the item is the currently selected item. If this property is set to
/// \c VARIANT_TRUE, the item is selected; otherwise not.
///
/// \param[out] pValue The property's current setting.
///
/// \return An \c HRESULT error code.
///
/// \remarks This property is read-only.
///
/// \sa ComboBox::get_SelectedItem
virtual HRESULT STDMETHODCALLTYPE get_Selected(VARIANT_BOOL* pValue);
/// \brief <em>Retrieves the current setting of the \c Text property</em>
///
/// Retrieves the item's text.
///
/// \param[out] pValue The property's current setting.
///
/// \return An \c HRESULT error code.
///
/// \sa put_Text
virtual HRESULT STDMETHODCALLTYPE get_Text(BSTR* pValue);
/// \brief <em>Sets the \c Text property</em>
///
/// Sets the item's text.
///
/// \param[in] newValue The setting to apply.
///
/// \return An \c HRESULT error code.
///
/// \sa get_Text
virtual HRESULT STDMETHODCALLTYPE put_Text(BSTR newValue);
/// \brief <em>Retrieves the bounding rectangle of either the item or a part of it</em>
///
/// Retrieves the bounding rectangle (in pixels relative to the drop-down list box control's client area)
/// of either the item or a part of it.
///
/// \param[in] rectangleType The rectangle to retrieve. Any of the values defined by the
/// \c ItemRectangleTypeConstants enumeration is valid.
/// \param[out] PXLeft The x-coordinate (in pixels) of the bounding rectangle's left border
/// relative to the drop-down list box control's upper-left corner.
/// \param[out] pYTop The y-coordinate (in pixels) of the bounding rectangle's top border
/// relative to the drop-down list box control's upper-left corner.
/// \param[out] pXRight The x-coordinate (in pixels) of the bounding rectangle's right border
/// relative to the drop-down list box control's upper-left corner.
/// \param[out] pYBottom The y-coordinate (in pixels) of the bounding rectangle's bottom border
/// relative to the drop-down list box control's upper-left corner.
///
/// \return An \c HRESULT error code.
///
/// \if UNICODE
/// \sa get_Height, CBLCtlsLibU::ItemRectangleTypeConstants
/// \else
/// \sa get_Height, CBLCtlsLibA::ItemRectangleTypeConstants
/// \endif
virtual HRESULT STDMETHODCALLTYPE GetRectangle(ItemRectangleTypeConstants /*rectangleType*/, OLE_XPOS_PIXELS* pXLeft = NULL, OLE_YPOS_PIXELS* pYTop = NULL, OLE_XPOS_PIXELS* pXRight = NULL, OLE_YPOS_PIXELS* pYBottom = NULL);
//@}
//////////////////////////////////////////////////////////////////////
/// \brief <em>Attaches this object to a given item</em>
///
/// Attaches this object to a given item, so that the item's properties can be retrieved and set
/// using this object's methods.
///
/// \param[in] itemIndex The item to attach to.
/// \param[in] itemData Specifies the value that will be returned by the \c ItemData property, if the
/// specified item index is -1.
///
/// \sa Detach, get_ItemData
void Attach(int itemIndex, ULONG_PTR itemData = NULL);
/// \brief <em>Detaches this object from an item</em>
///
/// Detaches this object from the item it currently wraps, so that it doesn't wrap any item anymore.
///
/// \sa Attach
void Detach(void);
/// \brief <em>Writes this object's settings to a given target</em>
///
/// \param[in] pTarget The target to which to copy the settings.
///
/// \return An \c HRESULT error code.
HRESULT SaveState(VirtualComboBoxItem* pTarget);
/// \brief <em>Sets the owner of this item</em>
///
/// \param[in] pOwner The owner to set.
///
/// \sa Properties::pOwnerCBox
void SetOwner(__in_opt ComboBox* pOwner);
protected:
/// \brief <em>Holds the object's properties' settings</em>
struct Properties
{
/// \brief <em>The \c ComboBox object that owns this item</em>
///
/// \sa SetOwner
ComboBox* pOwnerCBox;
/// \brief <em>The index of the item wrapped by this object</em>
int itemIndex;
/// \brief <em>Specifies the value that will be returned by the \c ItemData property, if the specified item index is -1</em>
///
/// \sa get_ItemData
ULONG_PTR itemData;
Properties()
{
pOwnerCBox = NULL;
itemIndex = -2;
itemData = NULL;
}
~Properties();
/// \brief <em>Retrieves the owning combo box' window handle</em>
///
/// \return The window handle of the combo box that contains this item.
///
/// \sa pOwnerCBox, GetLBoxHWnd
HWND GetCBoxHWnd(void);
/// \brief <em>Retrieves the owning combo box' drop-down list box window handle</em>
///
/// \return The window handle of the drop-down list box of the combo box that contains this item.
///
/// \sa pOwnerCBox, GetCBoxHWnd
HWND GetLBoxHWnd(void);
} properties;
}; // ComboBoxItem
OBJECT_ENTRY_AUTO(__uuidof(ComboBoxItem), ComboBoxItem)
| 36.649832
| 224
| 0.674139
|
[
"object"
] |
b00b401aee26d7b7a7aa12421a5b7df0b00d682d
| 1,207
|
h
|
C
|
graph+/defs.h
|
lugt/cprogram-oj
|
6d2de77846a19270da83354486629ed6cba16e9d
|
[
"Apache-2.0"
] | 1
|
2018-10-10T13:39:22.000Z
|
2018-10-10T13:39:22.000Z
|
graph+/defs.h
|
lugt/cprogram-oj
|
6d2de77846a19270da83354486629ed6cba16e9d
|
[
"Apache-2.0"
] | null | null | null |
graph+/defs.h
|
lugt/cprogram-oj
|
6d2de77846a19270da83354486629ed6cba16e9d
|
[
"Apache-2.0"
] | null | null | null |
//
// Created by lugt on 2019/5/5.
//
#ifndef GRAPH_DEFS_H
#define GRAPH_DEFS_H
//
// Created by lugt on 2018/11/6.
//
// Kruskal
// Prim
#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <map>
#include "memory.h"
#include <cstring>
// STL Includings
using std::cout;
using std::cin;
using std::cout;
using std::cin;
using std::endl;
#define Is_Echo(cond, parm) if(cond) printf parm;
#define Is_True(cond, parm) /*if(!(cond)) {printf parm; getchar(); getchar(); getchar(); exit(1);}*/
typedef int INT;
typedef unsigned int UINT;
typedef long long int INT64;
typedef bool BOOL;
typedef long long unsigned int UINT64;
typedef double F8;
typedef char CHAR;
typedef char* CHPTR;
typedef char** CHPPTR;
typedef const char* CCHPTR;
typedef const char** CCHPPTR;
/*printf parm; getchar(); getchar(); getchar(); exit(1);*/
#define EXTERN extern
#define NULLPTR NULL
#define FALSE ((BOOL) 0)
#define TRUE ((BOOL) 1)
inline BOOL Echo(){
return FALSE;
}
inline BOOL EchoKrusKal() {
return FALSE;
}
#endif //GRAPH_DEFS_H
| 19.786885
| 100
| 0.617233
|
[
"vector"
] |
b013efbf2d24130d75edded6e63aff3ce594e68f
| 549
|
h
|
C
|
include/observer.h
|
phoemur/simple_pool
|
f19ff097569ada64ddece32f65af65b41b0acd81
|
[
"Unlicense"
] | 5
|
2018-12-28T15:04:40.000Z
|
2022-03-15T23:54:06.000Z
|
include/observer.h
|
phoemur/simple_pool
|
f19ff097569ada64ddece32f65af65b41b0acd81
|
[
"Unlicense"
] | null | null | null |
include/observer.h
|
phoemur/simple_pool
|
f19ff097569ada64ddece32f65af65b41b0acd81
|
[
"Unlicense"
] | 1
|
2021-05-17T02:28:18.000Z
|
2021-05-17T02:28:18.000Z
|
#ifndef OBSERVER_H
#define OBSERVER_H
#include <vector>
class Subject; // Forward declare to break circular includes
enum class Event {
SUBJECT_MOVED,
SUBJECT_WALL_COLLIDED,
SUBJECT_BALL_COLLIDED,
SUBJECT_POCKET_COLLIDED,
SUBJECT_CUE_COLLIDED
};
class Observer {
protected:
std::vector<Subject*> observed_;
public:
Observer();
virtual ~Observer() noexcept;
virtual void onNotify(Subject& entity, Event event) = 0;
void registerSub(Subject* s);
void unregisterSub(Subject* s);
};
#endif // OBSERVER_H
| 19.607143
| 60
| 0.721311
|
[
"vector"
] |
b026d920335ace035956a1ec83c09d323349ce4e
| 2,417
|
h
|
C
|
tools/network.h
|
codeplaysoftware/SYCL-DNN
|
db554c9592f86c58adddc01df101da591a61de51
|
[
"Apache-2.0"
] | 85
|
2018-06-04T08:07:20.000Z
|
2022-03-30T15:53:46.000Z
|
tools/network.h
|
codeplaysoftware/SYCL-DNN
|
db554c9592f86c58adddc01df101da591a61de51
|
[
"Apache-2.0"
] | 8
|
2019-07-19T11:10:43.000Z
|
2021-02-05T10:18:49.000Z
|
tools/network.h
|
codeplaysoftware/SYCL-DNN
|
db554c9592f86c58adddc01df101da591a61de51
|
[
"Apache-2.0"
] | 19
|
2018-12-28T12:09:22.000Z
|
2022-01-08T02:55:14.000Z
|
/*
* Copyright Codeplay Software Ltd
*
* 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
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "tools/layer.h"
#include <CL/sycl.hpp>
namespace sycldnn {
template <typename DType, typename Backend>
class Network {
using DeviceMem = typename Backend::template pointer_type<DType>;
std::vector<std::unique_ptr<Layer<DType, Backend>>> network_;
std::vector<DType>& output_;
Backend& backend_;
public:
Network(Backend& backend, std::vector<DType>& output)
: network_{}, output_{output}, backend_{backend} {}
// Layers are their own types, number of parameters differs between each
void add_layer(Layer<DType, Backend>* layer) { network_.emplace_back(layer); }
// Runs each layer, checks for exceptions after every layer
sycldnn::SNNStatus test() {
sycldnn::SNNStatus status;
for (auto& layer : network_) {
status = layer->run();
status.event.wait_and_throw();
}
return dump_network_output();
}
sycldnn::SNNStatus run() {
sycldnn::SNNStatus status;
for (auto& layer : network_) {
status = layer->run();
}
return status;
}
DeviceMem get_output() { return network_.back()->get_output(); }
DeviceMem get_output(int layer_number) {
return network_[layer_number]->get_output();
}
size_t get_network_size() const { return network_.size(); }
size_t get_output_size() const { return network_.back()->get_output_size(); }
sycldnn::SNNStatus dump_network_output() {
DeviceMem out = this->get_output();
auto count = this->get_output_size();
output_.resize(count);
auto buf_out = out.get_buffer();
auto event = backend_.get_queue().submit([&](cl::sycl::handler& cgh) {
auto acc_out =
buf_out.template get_access<cl::sycl::access::mode::read>(cgh);
cgh.copy(acc_out, output_.data());
});
return {event, sycldnn::StatusCode::OK};
}
};
} // namespace sycldnn
| 30.2125
| 80
| 0.690939
|
[
"vector"
] |
e5c9afcc36c8c0d57b53708216c0759741b9b2c2
| 4,308
|
c
|
C
|
src/execution/exe_run_query.c
|
lordpretzel/gprom
|
143b8e950a843ceac8585c31156ae174295a5315
|
[
"Apache-2.0"
] | 5
|
2017-02-01T16:27:47.000Z
|
2021-04-23T16:02:03.000Z
|
src/execution/exe_run_query.c
|
lordpretzel/gprom
|
143b8e950a843ceac8585c31156ae174295a5315
|
[
"Apache-2.0"
] | 82
|
2016-11-30T15:57:48.000Z
|
2022-03-04T21:35:03.000Z
|
src/execution/exe_run_query.c
|
lordpretzel/gprom
|
143b8e950a843ceac8585c31156ae174295a5315
|
[
"Apache-2.0"
] | 4
|
2017-02-09T20:53:13.000Z
|
2022-02-10T22:01:35.000Z
|
/*-----------------------------------------------------------------------------
*
* exe_run_query.c
*
*
* AUTHOR: lord_pretzel
*
*
*
*-----------------------------------------------------------------------------
*/
#include "common.h"
#include "log/logger.h"
#include "model/relation/relation.h"
#include "metadata_lookup/metadata_lookup.h"
#include "execution/exe_run_query.h"
#include "utility/string_utils.h"
#include "configuration/option.h"
#include "provenance_rewriter/game_provenance/gp_bottom_up_program.h"
static void outputResult(Relation *res);
static void printDBsample(List *stmts);
void
exeRunQuery (void *code)
{
Relation *res = NULL;
char *adaptedQuery;
boolean showResult = getBoolOption(OPTION_SHOW_QUERY_RESULT);
boolean showTime = getBoolOption(OPTION_TIME_QUERIES);
struct timeval st;
struct timeval et;
char *format = getStringOption(OPTION_TIME_QUERY_OUTPUT_FORMAT);
int repeats = getIntOption(OPTION_REPEAT_QUERY);
// replace \n with new line in format string
if (format != NULL)
format = replaceSubstr(format, "\\n", "\n");
if (getBoolOption(OPTION_INPUTDB))
{
List *codes = splitString(code, ";");
printDBsample(codes);
return;
}
// remove semicolon
adaptedQuery = replaceSubstr(code, ";", ""); //TODO not safe if ; in strings
// execute query
INFO_LOG("run query (show results: %s, time query: %s):\n%s", showResult ? "yes" : "no", showTime ? "yes" : "no", (char *) adaptedQuery);
for (int i = 0; i < repeats; i++)
{
if (showTime)
{
gettimeofday(&st, NULL);
}
if (showResult)
res = executeQuery((char *) adaptedQuery);
else
executeQueryIgnoreResult((char *) adaptedQuery);
if (showTime)
{
gettimeofday(&et, NULL);
}
if (showResult == TRUE)
{
outputResult(res);
}
if (showTime)
{
long usecDiff;
long secDiff;
double msecs;
secDiff = et.tv_sec - st.tv_sec;
usecDiff = et.tv_usec - st.tv_usec;
msecs = secDiff * 1000 + (((double) usecDiff) / 1000.0);
if (showResult)
printf("\n");
if (format != NULL)
printf(format, msecs);
else
printf("query took %12f msec\n", msecs);
fflush(stdout);
}
}
}
static void
printDBsample(List *stmts)
{
int s = 0;
Relation *res = NULL;
FOREACH(char,c, stmts)
{
if (FOREACH_HAS_MORE(c))
{
char *r = (char *) STRING_VALUE(MAP_GET_STRING(edbRels,gprom_itoa(++s)));
// printf("%s", CONCAT_STRINGS(r,gprom_itoa(s)));
printf("%s", r);
printf("\n");
res = executeQuery((char *) c);
outputResult(res);
}
}
}
static void
outputResult(Relation *res)
{
int *colSizes;
int numCol;
int totalSize = 0;
int i = 0;
int l = 0;
numCol = LIST_LENGTH(res->schema);
colSizes = MALLOC(numCol * sizeof(int));
// determine column sizes
i = 0;
FOREACH(char,a,res->schema)
{
colSizes[i++] = strlen(a) + 2;
}
FOREACH(List,t,res->tuples)
{
i = 0;
FOREACH(char,a,t)
{
int len = a ? strlen(a) : 4;
colSizes[i] = colSizes[i] < len + 2 ? len + 2 : colSizes[i];
i++;
}
}
for (i = 0; i < numCol; i++)
totalSize += colSizes[i] + 1;
// output columns
i = 0;
FOREACH(char,a,res->schema)
{
printf(" %s", a);
for(int j = strlen(a) + 1; j < colSizes[i]; j++)
printf(" ");
printf("|");
i++;
}
printf("\n");
for (int j = 0; j < totalSize; j++)
printf("-");
printf("\n");
// output results
FOREACH(List,t,res->tuples)
{
i = 0;
FOREACH(char,a,t)
{
char *out = a ? a : "NULL";
printf(" %s", out);
for(int j = strlen(out) + 1; j < colSizes[i]; j++)
printf(" ");
printf("|");
i++;
}
printf("\n");
if ((l++ % 1000) == 0)
fflush(stdout);
}
}
| 23.16129
| 141
| 0.496982
|
[
"model"
] |
e5d5a05367fa11474564bbfcfdc6c81270011b02
| 8,723
|
h
|
C
|
masters-thesis/processing/processing.h
|
jsimck/uni
|
42ea184ccf3d9ecbffdea19b74ed13f3bc583137
|
[
"MIT"
] | null | null | null |
masters-thesis/processing/processing.h
|
jsimck/uni
|
42ea184ccf3d9ecbffdea19b74ed13f3bc583137
|
[
"MIT"
] | null | null | null |
masters-thesis/processing/processing.h
|
jsimck/uni
|
42ea184ccf3d9ecbffdea19b74ed13f3bc583137
|
[
"MIT"
] | null | null | null |
#ifndef VSB_SEMESTRAL_PROJECT_PROCESSING_H
#define VSB_SEMESTRAL_PROJECT_PROCESSING_H
#include <opencv2/core/mat.hpp>
#include "../core/template.h"
#include "../core/match.h"
#include "../core/window.h"
namespace tless {
// Lookup tables
static const int NORMAL_LUT_SIZE = 20, DEPTH_LUT_SIZE = 5;
static const uchar DEPTH_LUT[DEPTH_LUT_SIZE] = {1, 2, 4, 8, 16};
static const uchar NORMAL_LUT[NORMAL_LUT_SIZE][NORMAL_LUT_SIZE] = {
{32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 128, 128, 128, 128},
{32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 128, 128, 128, 128, 128, 128},
{32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 128, 128, 128, 128, 128, 128},
{32, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 128, 128, 128, 128, 128, 128, 128},
{32, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 128, 128, 128, 128, 128, 128, 128},
{32, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 128, 128, 128, 128, 128, 128, 128},
{16, 32, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 128, 128, 128, 128, 128, 128, 128, 128},
{16, 16, 16, 32, 32, 32, 32, 32, 32, 64, 64, 64, 128, 128, 128, 128, 128, 128, 1, 1},
{16, 16, 16, 16, 16, 16, 32, 32, 32, 32, 64, 128, 128, 128, 128, 1, 1, 1, 1, 1},
{16, 16, 16, 16, 16, 16, 16, 16, 32, 32, 64, 128, 128, 1, 1, 1, 1, 1, 1, 1},
{16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{16, 16, 16, 16, 16, 16, 16, 16, 8, 8, 4, 2, 2, 1, 1, 1, 1, 1, 1, 1},
{16, 16, 16, 16, 16, 16, 8, 8, 8, 8, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1},
{16, 16, 16, 8, 8, 8, 8, 8, 8, 4, 4, 4, 2, 2, 2, 2, 2, 2, 1, 1},
{16, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2},
{8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2},
{8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2},
{8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2},
{8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2},
{8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2}
};
/**
* @brief Computes quantized surface normals from 16-bit depth image.
*
* https://github.com/opencv/opencv_contrib/blob/master/modules/rgbd/src/linemod.cpp#L632
*
* @param[in] src Source 16-bit depth image (in mm)
* @param[out] dst Destination 8-bit image, where each bit represents one bin of view cone
* @param[out] dstNormals 32-bit 3-channel destionation image of extracted 3D normals
* @param[in] fx Camera focal length in X direction
* @param[in] fy Camera focal length in Y direction
* @param[in] maxDepth Ignore pixels beyond this depth
* @param[in] maxDifference When computing surface normals, ignore contributions of
* pixels whose depth difference with central pixel is above this threshold
*/
void quantizedNormals(const cv::Mat &src, cv::Mat &dst, cv::Mat &dstNormals, float fx, float fy, int maxDepth, int maxDifference);
/**
* @brief Generates binary image of visible depth edgels, detected in depth image within (min, max) depths.
*
* @param[in] src Source 16-bit depth image (in mm)
* @param[out] dst 8-bit uchar binary image containing 1 where edgels arise in depth image
* @param[in] minDepth Ignore pixels with depth lower then this threshold
* @param[in] maxDepth Ignore pixels with depth higher then this threshold
* @param[in] minMag Ignore pixels with edge magnitude lower than this
* @param[in] lowValue Optional value used for non existing edgels in binary image
* @param[in] highValue Optional value used for edges in binary image
*/
void depthEdgels(const cv::Mat &src, cv::Mat &dst, int minDepth, int maxDepth,
int minMag, int lowValue = 0, int highValue = 1);
/**
* @brief Returns quantized depth into one of 5 bins defined in ranges.
*
* @param[in] depth Depth value (32-bit signed int)
* @param[in] ranges Vector of ranges defining bounds for each quantization bin
* @return Quantized depth (1 | 2 | 4 | 8 | 16)
*/
uchar quantizeDepth(int depth, const std::vector<cv::Range> &ranges);
/**
* @brief Remaps white and black colors of HSV image to yellow and blue for HSV recognition
*
* @param[in] src Input 8-bit HSV image to normalize
* @param[out] dst Normalized 8-bit 1-channel image containing hue values from HSV
* @param[in] value Value threshold, values below this threshold [blacks] are mapped to blue color
* @param[in] saturation Saturation threshold, values below this and above value threshold [white] are mapped to yellow color
*/
void normalizeHSV(const cv::Mat &src, cv::Mat &dst, uchar value = 30, uchar saturation = 40);
/**
* @brief Applies non-maxima suppression to matches, removing matches with large overlap and lower score.
*
* This function calculates overlap between each window, if the overlap is > than [maxOverlap]
* we only retain a match with higher score.
*
* @param[in,out] matches Input/output array of matches to apply non-maxima suppression on
* @param[in] maxOverlap Max allowed overlap between two matched bounding boxes
*/
void nms(std::vector<Match> &matches, float maxOverlap);
/**
* @brief Finds edges in gray image using sobel operator (applies erosion and gaussian blur in pre-processing).
*
* @param[in] src 8-bit gray source image
* @param[out] dst 8-bit image with detected edges
* @param[in] kSize Size of a kernel used in Gaussian blur in pre-processing
*/
void filterEdges(const cv::Mat &src, cv::Mat &dst, int kSize = 3);
/**
* @brief Computes and quantizes gradient orientations over RGB scene
*
* @param[in] src 8-bit gray image to compute gradients on
* @param[out] dst 8-bit image map of quantized gradient orientations
* @param[in] minMag Minimum edge magnitude to consider as valid and compute orientation for
*/
void quantizedGradients(const cv::Mat &src, cv::Mat &dst, float minMag);
/**
* @brief Quantizes orientation gradients into 5 bins (0-180deg) based on their angle
*
* @param[in] deg Degree of the gradient orientation
* @return One of quantized orientations 1, 2, 4, 8, 16
*/
uchar quantizeGradientOrientation(float deg);
/**
* @brief Spread quantized features in src image in TxT patch around every pixel
*
* @param[in] src 8-bit input image of quantized features
* @param[out] dst 8-bit spread feature version of input image
* @param[in] T Size of the patch TxT
*/
void spread(const cv::Mat& src, cv::Mat& dst, int T);
/**
* @brief Applies simple objectness detection on input depth image based on depth discontinuities.
*
* Depth discontinuities are areas where pixel arise on the edges of objects. Sliding window
* is used to slide through the scene and calculating amount of depth pixels in the scene.
* Window is classified as containing object if it contains at least [minEdgels] of edgels.
*
* @param[in] src Input 16-bit depth image
* @param[in,out] edgels Output 8-bit depth edgels image
* @param[in,out] windows Contains all window positions, that were classified as containing object
* @param[in] winSize Sliding window size
* @param[in] winStep Sliding window step
* @param[in] minDepth Ignore pixels with depth lower then this threshold (used for edgel detection)
* @param[in] maxDepth Ignore pixels with depth higher then this threshold (used for edgel detection)
* @param[in] minMag Ignore pixels with edge magnitude lower than this (used for edgel detection)
* @param[in] minEdgels Minimum number of edgels window can contain to be classified as containing object
*/
void objectness(const cv::Mat &src, cv::Mat &edgels, std::vector<Window> &windows, const cv::Size &winSize,
int winStep, int minDepth, int maxDepth, int minMag, int minEdgels);
}
#endif
| 57.388158
| 134
| 0.589705
|
[
"object",
"vector",
"3d"
] |
e5f107e88eb57665a4edca1a029245e53776e565
| 6,706
|
h
|
C
|
include/xr/com/unknown.h
|
RanXacT/xr
|
2db7e1954e119b94c73057b367b5207c6af9bc2e
|
[
"BSD-3-Clause"
] | 2
|
2016-06-05T17:07:54.000Z
|
2021-09-20T18:07:31.000Z
|
include/xr/com/unknown.h
|
RanXacT/xr
|
2db7e1954e119b94c73057b367b5207c6af9bc2e
|
[
"BSD-3-Clause"
] | null | null | null |
include/xr/com/unknown.h
|
RanXacT/xr
|
2db7e1954e119b94c73057b367b5207c6af9bc2e
|
[
"BSD-3-Clause"
] | null | null | null |
// ######################################################################################### - FILE
/*!
\page com COM Overview
The COM functionality of the system is basic but operable. The COM API
depends only on the platform headers and is easily included in DLL's etc.
\par
Generally speaking COM interfaces would derive from xr::COM::IUnknown and interface
implentations should derive from xr::Core::IUnknownRefCounted (which provides
AddRef / Release functions). Implementations must provide a QueryInterface
function, but macros are provided to make that easier.
\copydoc xr::COM::IUnknown
\file \copydoc com
\author Daniel Craig \par Copyright 2016, All Rights reserved.
*/
// ######################################################################################### - FILE
// ######################################################################################### - FILE
// Guard
// ######################################################################################### - FILE
#ifndef XR_COM_UNKNOWN_H
#define XR_COM_UNKNOWN_H
#if defined( _MSC_VER )
#pragma once
#endif
// ######################################################################################### - FILE
/* Public Includes */
// ######################################################################################### - FILE
#ifndef XR_DEFINES_H
#error "Must include xr/defines.h first!"
#endif
// ######################################################################################### - FILE
/* Public Macros */
// ######################################################################################### - FILE
// ######################################################################################### - FILE
/* Forward Declarations */
// ######################################################################################### - FILE
namespace xr { namespace Core {
// Forward declaration does not require actual use of Core Library
// it just allows optional use of xr::Core::intrusive_ptr.
template<typename T>
class intrusive_ptr;
}
}
// ######################################################################################### - FILE
/* Declarations */
// ######################################################################################### - FILE
namespace xr { namespace COM {
/// Typedef for COM InterfaceID's, this could be changed in the future
/// but should remain signed to deal inter operate with enums used to manage
/// static IID's.
typedef int32_t InterfaceID;
// ***************************************************************************************** - TYPE
/*! Basic COM interface.
IUknown is used to safely pass opaque types around at runtime. It allows
intermediaries to operate on objects with no compile time knowledge of
them. It allows also safe runtime type casting to interfaces. Generally
COM is used for high level API's to abstract implementation of an
interface from (direct or indirect) users of the interface. Indirect
users referencing the type as IUnknown and Direct users safely casting
to the desired interface when needed.
\par Differences with standard COM (Minor)
\li QueryInterface returns a void * (or nullptr)
\li Interface ID is smaller (it's size is easily changed).
\li AddRef / Release do not return the reference count. This is because
reference counts are generally not safe to use.
\li AddRef / Release are "const" functions. This is to help promote
const correctness.
\par Reference Counting.
Generally speaking users are intended to use xr::Core:RefCounted
or xr::Core::NonThreadSafeRefCounted to implement reference
counting. Also use of xr::Core::intrusive_ptr for references is
expected. These objects are designed to work together and make
COM implementation and usage simple.
\par Core functionality
The core library provides helper classes to make implementing com
objects quite trivial.
\sa xr::Core::IUnknownHelper0
\endcode
\sa http://en.wikipedia.org/wiki/IUnknown
*/
// ***************************************************************************************** - TYPE
class IUnknown {
public:
virtual ~IUnknown() {}
// ------------------------------------------------------------------------------------ MEMBER
/// This function returns
/// This function must internally call AddRef before returning the pointer.
/// The caller must then call Release() on the returned pointer once it
/// is done with it.
virtual xr::COM::IUnknown * QueryInterface(InterfaceID id) = 0;
// ------------------------------------------------------------------------------------ MEMBER
/// Add a reference to this object
virtual void AddRef() const = 0;
// ------------------------------------------------------------------------------------ MEMBER
/// Release a reference to this object (may delete the object)
virtual void Release() const = 0;
// ------------------------------------------------------------------------------------ MEMBER
/// static function to get the interface ID of this object
enum
{
kIID = 1
};
// ------------------------------------------------------------------------------------ MEMBER
/// Helper function for const correctness.
inline const xr::COM::IUnknown * QueryInterface(InterfaceID id) const
{
IUnknown* const_this = const_cast<IUnknown*>(this);
return const_this->QueryInterface(id);
}
// ------------------------------------------------------------------------------------ MEMBER
/// This helper does the type cast for you, but you still must
/// explicitly call Release(), or pass to intrusive_ptr without
/// it calling AddRef.
/// \sa xr::Core::intrusive_ptr
/// \sa xr::Core::intrusive_ptr::AssumeReference
/// \sa xr::Core::intrusive_ptr::intrusive_ptr
//@{
template<typename T>
T * interface_cast()
{
return static_cast<T*>( QueryInterface(T::kIID) );
}
template<typename T>
const T * interface_cast() const
{
return static_cast<const T*>( QueryInterface(T::kIID) );
}
//@}
// ------------------------------------------------------------------------------------ MEMBER
/// This function ensures proper reference counting is automatically.
/// maintained. No extra reference counts needed.
template<typename T>
void interface_cast(xr::Core::intrusive_ptr<T> &ip)
{
ip.AssumeReference( static_cast<T*>( QueryInterface(T::kIID)));
}
};
}} // namespace
#endif //#ifndef XR_COM_UNKNOWN_H
| 42.443038
| 99
| 0.495526
|
[
"object"
] |
e5f53e5530227e5993e1c05ba07009723827ff3b
| 3,764
|
h
|
C
|
jive/strings.h
|
JiveHelix/jive
|
4ef45b3c7b4723d0eedbd2a8b827ac18bd3ee79c
|
[
"MIT"
] | null | null | null |
jive/strings.h
|
JiveHelix/jive
|
4ef45b3c7b4723d0eedbd2a8b827ac18bd3ee79c
|
[
"MIT"
] | null | null | null |
jive/strings.h
|
JiveHelix/jive
|
4ef45b3c7b4723d0eedbd2a8b827ac18bd3ee79c
|
[
"MIT"
] | 1
|
2022-01-12T21:38:11.000Z
|
2022-01-12T21:38:11.000Z
|
/**
* @file strings.h
*
* @brief String manipulation utilities.
*
* @author Jive Helix ([email protected])
* @copyright 2011-2018 Jive Helix
*
* Licensed under the MIT license. See LICENSE file.
*/
#pragma once
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>
#include <initializer_list>
#include <numeric>
#include <cassert>
#undef str
#include <sstream>
#include <cstring>
#include <cstdarg>
#include "jive/detail/strings_detail.h"
namespace jive
{
namespace strings
{
/**
** Return a string with length up to any optional null character, or the full
** length of the input array if there is no null character.
**/
template<size_t N>
std::string Make(const char (&bytes)[N])
{
std::string result(bytes, N);
detail::ResizeToStrlen(result);
return result;
}
/**
** Return a string with length up to any optional null character, or
** maxByteCount if there is no null character.
**/
inline
std::string Make(const char *inArray, size_t maxByteCount)
{
std::string result(inArray, maxByteCount);
detail::ResizeToStrlen(result);
return result;
}
/**
** Remove all leading and trailing occurrences of specified
** characters.
** Defaults to whitespace characaters.
**/
inline
std::string Trim(
const std::string &inString,
const std::string &remove = " \t\r\n")
{
const auto begin = inString.find_first_not_of(remove);
if (begin == std::string::npos)
{
// All unwanted
return "";
}
const auto end = inString.find_last_not_of(remove);
const auto count = end - begin + 1;
return inString.substr(begin, count);
}
template<size_t count>
bool CharArrayEquals(
const char (&charArray)[count],
const char (&compare)[count])
{
return std::equal(&compare[0], &compare[0] + count, &charArray[0]);
}
template<typename TokenT>
std::vector<std::string> Split(
const std::string& input,
const TokenT &token,
int limit = -1)
{
return detail::SplitToContainer<std::vector<std::string>, TokenT>(
input,
token,
limit);
}
template<typename ContainerT = std::vector<std::string>>
ContainerT SplitOnWhiteSpace(const std::string &input);
/*
* Creates one string constructed by concatenating InputIterator with token
* inserted between. This is the complementary function to Split.
*
* @param InputIterator must dereference to a std::string or to any object that
* can be a right hand operand to ostream::operator<<
*/
template<typename InputIterator, typename TokenT>
std::string Join(
InputIterator first,
InputIterator last,
const TokenT &token);
template<typename TokenT>
std::string Join(
std::initializer_list<std::string> initializerList,
const TokenT &token);
/** Concatenate avoids the creation of intermediate strings by using += on the
** same result.
**/
#if __cplusplus >= 201703L
template<typename StringT, typename FirstT, typename... ArgsT>
StringT * Concatenate(StringT *ioResult, FirstT &&first, ArgsT&&... args);
#endif
/* Test whether a string is all digits */
inline
bool AllOfDigits(const std::string& s)
{
return std::all_of(
s.begin(),
s.end(),
[](char c)->bool { return isdigit(c); });
}
/* Test whether a string is all alpha numeric */
inline
bool AllOfAlphaNumerics(const std::string& s)
{
return std::all_of(
s.begin(),
s.end(),
[](char c)->bool { return isalnum(c); });
}
/* Test whether a string is all alpha */
inline
bool AllOfAlphas(const std::string& s)
{
return std::all_of(
s.begin(),
s.end(),
[](char c)->bool { return isalpha(c); });
}
} // end namespace strings
} // end namespace jive
#include "jive/detail/strings_impl.h"
| 21.632184
| 79
| 0.671892
|
[
"object",
"vector"
] |
e5fa108b9be3dbf85c13cda9df59150c96d7453d
| 976
|
h
|
C
|
xengine/src/game/layers.h
|
HyperdiXx/XEngine
|
93d1ec26956675daedb2c8fa68701dafaaa4a681
|
[
"MIT"
] | null | null | null |
xengine/src/game/layers.h
|
HyperdiXx/XEngine
|
93d1ec26956675daedb2c8fa68701dafaaa4a681
|
[
"MIT"
] | null | null | null |
xengine/src/game/layers.h
|
HyperdiXx/XEngine
|
93d1ec26956675daedb2c8fa68701dafaaa4a681
|
[
"MIT"
] | null | null | null |
#pragma once
#ifndef LAYERS_H
#define LAYERS_H
//#include "render_pass.h"
class Layer2D
{
public:
Layer2D() {};
~Layer2D() {};
void init();
void render();
void update(real32 dt);
void addEntity(Entity ent);
private:
std::vector<Entity> entities;
Entity main_ent;
};
class Layer3D
{
public:
Layer3D() {};
~Layer3D() {};
void init();
void render();
void update(real32 dt);
void addEntity(Entity ent);
private:
std::vector<Entity> entities;
//RenderPass *render_pass;
};
class GUILayer
{
public:
void init();
void render();
void update(real32 dt);
private:
};
struct LayerTest
{
enum class LayerType
{
LAYER_2D,
LAYER_3D,
GUI
};
LayerTest() {};
LayerTest(LayerTest &&test) {};
~LayerTest() {};
LayerType type;
union
{
Layer2D layer2D;
Layer3D layer3D;
GUILayer guiLayer;
};
};
#endif // !LAYERS_H
| 12.675325
| 35
| 0.574795
|
[
"render",
"vector"
] |
f91100cb7a075d504bc39af3d024b70015e64150
| 1,761
|
h
|
C
|
src/ballistica/python/python_context_call.h
|
Benefit-Zebra/ballistica
|
eb85df82cff22038e74a2d93abdcbe9cd755d782
|
[
"MIT"
] | 317
|
2020-04-04T00:33:10.000Z
|
2022-03-28T01:07:09.000Z
|
src/ballistica/python/python_context_call.h
|
Alshahriah/ballistica
|
326f6677a0118667e93ce9034849622ebef706fa
|
[
"MIT"
] | 315
|
2020-04-04T22:33:10.000Z
|
2022-03-31T22:50:02.000Z
|
src/ballistica/python/python_context_call.h
|
Alshahriah/ballistica
|
326f6677a0118667e93ce9034849622ebef706fa
|
[
"MIT"
] | 97
|
2020-04-04T01:32:17.000Z
|
2022-03-16T19:02:59.000Z
|
// Released under the MIT License. See LICENSE for details.
#ifndef BALLISTICA_PYTHON_PYTHON_CONTEXT_CALL_H_
#define BALLISTICA_PYTHON_PYTHON_CONTEXT_CALL_H_
#include <string>
#include "ballistica/core/context.h"
#include "ballistica/core/object.h"
#include "ballistica/python/python_ref.h"
namespace ballistica {
// A callable and context-state wrapped up in a convenient package.
// Handy for use with user-submitted callbacks, as it restores context
// state from when it was created and prints various useful bits of info
// on exceptions.
class PythonContextCall : public Object {
public:
static auto current_call() -> PythonContextCall* { return current_call_; }
PythonContextCall() = default;
~PythonContextCall() override;
/// Initialize from either a single callable object, or a tuple with a
/// callable and optionally args and keywords
explicit PythonContextCall(PyObject* callable);
void Run(PyObject* args = nullptr);
void Run(const PythonRef& args) { Run(args.get()); }
auto Exists() const -> bool { return object_.exists(); }
auto GetObjectDescription() const -> std::string override;
void MarkDead();
auto object() const -> const PythonRef& { return object_; }
auto file_loc() const -> const std::string& { return file_loc_; }
void LogContext();
private:
void GetTrace(); // we try to grab basic trace info
std::string file_loc_;
int line_{};
bool dead_ = false;
PythonRef object_;
Context context_;
#if BA_DEBUG_BUILD
ContextTarget* context_target_sanity_test_{};
#endif
static PythonContextCall* current_call_;
};
// FIXME: this should be static member var
extern PythonContextCall* g_current_python_call;
} // namespace ballistica
#endif // BALLISTICA_PYTHON_PYTHON_CONTEXT_CALL_H_
| 32.018182
| 76
| 0.754117
|
[
"object"
] |
f9142d24b7e844473167bdafb14f850f3b83b995
| 1,027
|
h
|
C
|
src/view/task/layertreemodel.h
|
panzergame/dxfplotter
|
95393027903c8e907c1d1ef7b4982d1aadc968c8
|
[
"MIT"
] | 19
|
2020-04-08T16:38:27.000Z
|
2022-03-30T19:53:18.000Z
|
src/view/task/layertreemodel.h
|
panzergame/dxfplotter
|
95393027903c8e907c1d1ef7b4982d1aadc968c8
|
[
"MIT"
] | 3
|
2020-10-27T05:50:37.000Z
|
2022-03-19T17:22:04.000Z
|
src/view/task/layertreemodel.h
|
panzergame/dxfplotter
|
95393027903c8e907c1d1ef7b4982d1aadc968c8
|
[
"MIT"
] | 6
|
2020-06-15T13:00:58.000Z
|
2022-02-09T13:18:04.000Z
|
#pragma once
#include <cassert>
#include <model/task.h>
#include <QAbstractItemModel>
#include <QItemSelectionModel>
namespace View::Task
{
class LayerTreeModel: public QAbstractItemModel
{
Q_OBJECT
private:
Model::Task &m_task;
public:
explicit LayerTreeModel(Model::Task &task, QObject *parent);
QVariant data(const QModelIndex &index, int role) const override;
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
QModelIndex parent(const QModelIndex &index) const override;
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
Qt::ItemFlags flags(const QModelIndex &index) const override;
void itemClicked(const QModelIndex &index);
void updateItemSelection(const Model::Path &path, QItemSelectionModel::SelectionFlag flag, QItemSelectionModel *selectionModel);
void selectionChanged(const QItemSelection &selected, const QItemSelection &deselected);
};
}
| 28.527778
| 129
| 0.78481
|
[
"model"
] |
f91d3acb5e7fff88ccbb2a3663f73880ee7da327
| 5,095
|
h
|
C
|
src/3d/geometry/voxel_map.h
|
wkrzemien/j-pet-mlem
|
4ed746f3fe79890e4141158cd49d1869938105de
|
[
"Apache-2.0"
] | null | null | null |
src/3d/geometry/voxel_map.h
|
wkrzemien/j-pet-mlem
|
4ed746f3fe79890e4141158cd49d1869938105de
|
[
"Apache-2.0"
] | 5
|
2018-08-08T08:26:04.000Z
|
2020-05-13T13:33:39.000Z
|
src/3d/geometry/voxel_map.h
|
wkrzemien/j-pet-mlem
|
4ed746f3fe79890e4141158cd49d1869938105de
|
[
"Apache-2.0"
] | 5
|
2018-06-04T21:04:29.000Z
|
2021-07-03T14:19:39.000Z
|
#pragma once
#if !__CUDACC__
#include <ostream>
#include "util/png_writer.h"
#include "util/nrrd_writer.h"
#include "util/bstream.h"
#endif
namespace PET3D {
/// Cubical map of voxels aka 3D image
////
/// Can be used to write voxels to PNG or generic stream
template <typename VoxelType, typename ValueType> class VoxelMap {
public:
using Voxel = VoxelType;
using S = typename Voxel::S;
using Size = typename Voxel::Size;
using Value = ValueType;
using iterator = Value*;
using const_iterator = const Value*;
/// Creates new voxel map of given dimensions initialized to zero
VoxelMap(S width, S height, S depth)
: size(static_cast<Size>(width) * height * depth),
width(width),
height(height),
depth(depth),
data(new Value[size]()),
owning(true) {}
/// Creates new voxel map of given dimensions and default value
VoxelMap(S width, S height, S depth, const Value& value)
: size(static_cast<Size>(width) * height * depth),
width(width),
height(height),
depth(depth),
data(new Value[size]),
owning(true) {
assign(value);
}
/// Creates new voxel map of given dimensions and existing data
VoxelMap(S width, S height, S depth, Value* data)
: size(static_cast<Size>(width) * height * depth),
width(width),
height(height),
depth(depth),
data(data),
owning(false) {}
/// Copy constructor
VoxelMap(const VoxelMap& other)
: size(other.size),
width(other.width),
height(other.height),
depth(other.depth),
data(other.owning ? new Value[size] : other.data),
owning(other.owning) {
if (owning) {
memcpy(data, other.data, size * sizeof(Value));
}
}
/// Move constructor
VoxelMap(VoxelMap&& other)
: size(other.size),
width(other.width),
height(other.height),
depth(other.depth),
data(other.data),
owning(other.owning) {
// make other object not to release its memory
other.owning = false;
}
/// Destroys underlying data (only if it is managed)
~VoxelMap() {
if (owning && data) {
delete[] data;
}
}
Value& operator[](const Voxel& voxel) {
return data[voxel.index(width, height)];
}
const Value& operator[](const Voxel& voxel) const {
return data[voxel.index(width, height)];
}
Value& operator[](Size index) { return data[index]; }
const Value& operator[](Size index) const { return data[index]; }
/// Increments atomically value
void increment(const Voxel& voxel) {
#if _OPENMP && !_MSC_VER
// FIXME: on MSVC it does not work
__atomic_add_fetch(&data[voxel.index(width, height)], 1, __ATOMIC_SEQ_CST);
#else
data[voxel.index(width, height)]++;
#endif
}
void assign(const Value& value) {
for (auto& element : *this) {
element = value;
}
}
/// Extract from other voxel map at source origin relative to source center
void copy(const VoxelMap& source, const Voxel origin) {
Voxel translation(source.width, source.height, source.depth);
translation -= Voxel(width, height, depth);
translation.x /= 2, translation.y /= 2, translation.z /= 2;
translation += origin;
for (S z = 0; z < depth; ++z) {
for (S y = 0; y < height; ++y) {
for (S x = 0; x < width; ++x) {
Voxel voxel(x, y, z);
(*this)[voxel] = source[voxel + translation];
}
}
}
}
iterator begin() { return data; }
const_iterator begin() const { return data; }
iterator end() { return &data[size]; }
const_iterator end() const { return &data[size]; }
const Size size;
const S width;
const S height;
const S depth;
Value* const data;
#if !__CUDACC__
friend util::png_writer& operator<<(util::png_writer& png,
const VoxelMap& map) {
png.write(map.width, map.height * map.depth, map.data);
return png;
}
friend util::nrrd_writer& operator<<(util::nrrd_writer& nrrd,
const VoxelMap& map) {
size_t dimensions[3] = {
(size_t)map.width, (size_t)map.height, (size_t)map.depth
};
nrrd.write_header<ValueType, 3>(dimensions);
return nrrd;
}
friend std::istream& operator>>(std::istream& in, VoxelMap& map) {
for (auto voxel : map) {
in >> voxel;
}
return in;
}
friend std::ostream& operator<<(std::ostream& out, const VoxelMap& map) {
auto it = map.begin();
auto end = map.end();
auto width = map.width;
for (int c = 1; it != end; ++it, ++c) {
out << *it;
if (c % width == 0) {
out << "\n";
} else {
out << " ";
}
}
return out;
}
friend util::ibstream& operator>>(util::ibstream& in, VoxelMap& map) {
in.read(map.data, map.size);
return in;
}
friend util::obstream& operator<<(util::obstream& out, const VoxelMap& map) {
out.write(map.data, map.size);
return out;
}
#endif
private:
bool owning; ///< are we owning the data pointer?
};
} // PET2D
| 26.675393
| 79
| 0.600196
|
[
"object",
"3d"
] |
f92bc403f8a0a0f312686ed17179095841bf02c5
| 771
|
h
|
C
|
2/1/OOP/IPW2/ipw2/Source/UFS/UFS.h
|
xdegtyarev/bsuir
|
e7d6073629ff57912f4e70894f2a539c5063bfd0
|
[
"MIT"
] | 2
|
2021-11-28T10:57:37.000Z
|
2021-11-29T04:28:31.000Z
|
2/1/OOP/IPW2/ipw2/Source/UFS/UFS.h
|
xdegtyarev/bsuir
|
e7d6073629ff57912f4e70894f2a539c5063bfd0
|
[
"MIT"
] | null | null | null |
2/1/OOP/IPW2/ipw2/Source/UFS/UFS.h
|
xdegtyarev/bsuir
|
e7d6073629ff57912f4e70894f2a539c5063bfd0
|
[
"MIT"
] | 2
|
2019-01-11T20:46:33.000Z
|
2021-08-24T08:47:14.000Z
|
//
// UFS.h
// Lab2
//
// Created by Alexander Degtyarev on 11/25/13.
// Copyright (c) 2013 Alexander Degtyarev. All rights reserved.
//
#ifndef __Lab2__UFS__
#define __Lab2__UFS__
#include <iostream>
#include "IVFS.h"
#include "UFSFile.h"
#include "UFSDirectory.h"
class UFS: public IVFS{
public:
UFS();
static UFS& GetInstance();
virtual IDirectory* GetRoot();
virtual const char* GetDriverName();
virtual const char* GetFileNameEncodingInfo();
virtual void Mount(IMountablePoint *mountablePoint);
virtual void Unmount(IMountablePoint *mountablePoint);
virtual std::vector<IMountablePoint*> *GetMountedPoints();
private:
IDirectory* root;
IDirectory* mountRoot;
std::vector<IMountablePoint*> mounted;
public:
};
#endif /* defined(__Lab2__UFS__) */
| 22.676471
| 64
| 0.741894
|
[
"vector"
] |
f9373b59a388985d98b3c47e030855f57636229c
| 1,772
|
h
|
C
|
Data-structures-Algorithms-course/Homework-3/Homework 3, DSA/TrieNode.h
|
pepincho/FMI
|
23de10e0057bb98b5093b68cab859b9eef5109a1
|
[
"MIT"
] | 2
|
2016-02-26T11:19:15.000Z
|
2016-10-11T14:09:19.000Z
|
Data-structures-Algorithms-course/Homework-3/Homework 3, DSA/TrieNode.h
|
pepincho/C-plus-plus-Courses-FMI
|
23de10e0057bb98b5093b68cab859b9eef5109a1
|
[
"MIT"
] | null | null | null |
Data-structures-Algorithms-course/Homework-3/Homework 3, DSA/TrieNode.h
|
pepincho/C-plus-plus-Courses-FMI
|
23de10e0057bb98b5093b68cab859b9eef5109a1
|
[
"MIT"
] | 1
|
2020-07-13T04:09:05.000Z
|
2020-07-13T04:09:05.000Z
|
#pragma once
#include "Vector.h"
//#include <vector>
class TrieNode {
private:
char value;
bool _isFinal;
Vector<TrieNode*> children;
//unsigned long _size;
int counter;
private:
void copy(const TrieNode & other);
public:
TrieNode();
TrieNode(char _val, bool flag, int counter);
~TrieNode();
TrieNode(const TrieNode & other);
TrieNode& operator=(const TrieNode & other);
public:
void addChild(TrieNode* child) { children.push_back(child); };
//unsigned long size();
TrieNode* findChild(char key) const;
void markNode() { _isFinal = true; }
void setValue(char _val) { value = _val; }
void updateCounter() { counter++; }
bool isFinal() { return _isFinal; }
int getCounter() { return counter; }
};
TrieNode::TrieNode() : value('\0'), _isFinal(false), counter(0) {
}
TrieNode::TrieNode(char _val, bool flag, int _cntr) :
value(_val), _isFinal(flag), counter(_cntr) {
}
TrieNode::~TrieNode() {
for (int i = 0; i < children.size(); i++)
delete children.at(i);
}
///
/// Binary search to find the child - O(logn)
///
TrieNode* TrieNode::findChild(char key) const {
TrieNode* temp;
int start = 0;
int end = children.size() - 1;
int middle;
while (start <= end) {
middle = (start + end) / 2;
temp = children.at(middle);
if (temp->value == key)
return temp;
if (temp->value > key)
end = middle - 1;
if (temp->value < key)
start = middle + 1;
}
return NULL;
}
void TrieNode::copy(const TrieNode & other) {
this->value = other.value;
this->_isFinal = other._isFinal;
this->counter = other.counter;
this->children = other.children;
}
TrieNode::TrieNode(const TrieNode & other) {
copy(other);
}
TrieNode& TrieNode::operator=(const TrieNode & other) {
if (this != &other) {
copy(other);
}
return *this;
}
| 18.652632
| 65
| 0.656321
|
[
"vector"
] |
f94d993ef2dd62793022105b1774ca1e01ed165f
| 7,299
|
h
|
C
|
qt-creator-opensource-src-4.6.1/src/tools/clangrefactoringbackend/source/macropreprocessorcallbacks.h
|
kevinlq/Qt-Creator-Opensource-Study
|
b8cadff1f33f25a5d4ef33ed93f661b788b1ba0f
|
[
"MIT"
] | 5
|
2018-12-22T14:49:13.000Z
|
2022-01-13T07:21:46.000Z
|
qt-creator-opensource-src-4.6.1/src/tools/clangrefactoringbackend/source/macropreprocessorcallbacks.h
|
kevinlq/Qt-Creator-Opensource-Study
|
b8cadff1f33f25a5d4ef33ed93f661b788b1ba0f
|
[
"MIT"
] | null | null | null |
qt-creator-opensource-src-4.6.1/src/tools/clangrefactoringbackend/source/macropreprocessorcallbacks.h
|
kevinlq/Qt-Creator-Opensource-Study
|
b8cadff1f33f25a5d4ef33ed93f661b788b1ba0f
|
[
"MIT"
] | 8
|
2018-07-17T03:55:48.000Z
|
2021-12-22T06:37:53.000Z
|
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include "sourcelocationsutils.h"
#include <filepathcachingfwd.h>
#include <sourcelocationscontainer.h>
#include <clang/Basic/SourceManager.h>
#include <clang/Lex/PPCallbacks.h>
#include <clang/Lex/Preprocessor.h>
#include <clang/Lex/MacroInfo.h>
#include <QDebug>
namespace ClangBackEnd {
struct MacroDirectiveToken
{
MacroDirectiveToken(const clang::MacroDirective *macroDirective,
const clang::Token &token)
: macroDirective(macroDirective),
token(token)
{}
const clang::MacroDirective *macroDirective;
const clang::Token token;
};
class MacroPreprocessorCallbacks : public clang::PPCallbacks
{
public:
MacroPreprocessorCallbacks(SourceLocationsContainer &m_sourceLocationsContainer,
Utils::SmallString &m_symbolName,
clang::Preprocessor &m_preprocessor,
FilePathCachingInterface &filePathCache,
uint m_line,
uint m_column);
void FileChanged(clang::SourceLocation location,
FileChangeReason reason,
clang::SrcMgr::CharacteristicKind /*fileType*/,
clang::FileID /*previousFileIdentifier*/) final
{
if (!m_isMainFileEntered) {
updateLocations();
updateIsMainFileEntered(location, reason);
}
}
void MacroDefined(const clang::Token &token, const clang::MacroDirective *macroDirective) final
{
if (isInMainFile(token)) {
if (includesCursorPosition(token)) {
m_sourceLocations.push_back(token.getLocation());
m_cursorMacroDirective = macroDirective;
m_symbolName = Utils::SmallString(token.getIdentifierInfo()->getNameStart(),
token.getIdentifierInfo()->getLength());
}
}
}
void MacroExpands(const clang::Token &token,
const clang::MacroDefinition ¯oDefinition,
clang::SourceRange /*sourceRange*/,
const clang::MacroArgs * /*macroArguments*/) final
{
if (includesCursorPosition(token)) {
appendSourceLocations(token, macroDefinition);
m_cursorMacroDirective = macroDefinition.getLocalDirective();
m_symbolName = Utils::SmallString(token.getIdentifierInfo()->getNameStart(),
token.getIdentifierInfo()->getLength());
} else if (isCurrentTokenExpansion(macroDefinition)) {
m_sourceLocations.push_back(token.getLocation());
} else if (isBeforeCursorSourceLocation()) {
m_preCursorMacroDirectiveTokens.emplace_back(macroDefinition.getLocalDirective(), token);
}
}
void EndOfMainFile() final
{
appendSourceLocationsToSourceLocationsContainer(m_sourceLocationsContainer,
m_sourceLocations,
sourceManager(),
m_filePathCache);
}
private:
void appendSourceLocations(const clang::Token &token,
const clang::MacroDefinition ¯oDefinition)
{
m_sourceLocations.push_back(macroDefinition.getLocalDirective()->getLocation());
for (const auto ¯oDirectiveToken : m_preCursorMacroDirectiveTokens) {
if (macroDirectiveToken.macroDirective == macroDefinition.getLocalDirective())
m_sourceLocations.push_back(macroDirectiveToken.token.getLocation());
}
m_sourceLocations.push_back(token.getLocation());
}
void updateLocations()
{
if (m_mainFileSourceLocation.isInvalid()) {
m_mainFileSourceLocation = sourceManager().getLocForStartOfFile(sourceManager().getMainFileID());
m_cursorSourceLocation = sourceManager().translateLineCol(sourceManager().getMainFileID(),
m_line,
m_column);
}
}
void updateIsMainFileEntered(clang::SourceLocation location, FileChangeReason reason)
{
if (location == m_mainFileSourceLocation && reason == PPCallbacks::EnterFile)
m_isMainFileEntered = true;
}
const clang::SourceManager &sourceManager() const
{
return m_preprocessor.getSourceManager();
}
bool isInMainFile(const clang::Token &token)
{
return m_isMainFileEntered && sourceManager().isWrittenInMainFile(token.getLocation());
}
bool includesCursorPosition(const clang::Token &token)
{
auto start = token.getLocation();
auto end = token.getEndLoc();
return m_cursorSourceLocation == start
|| m_cursorSourceLocation == end
|| (sourceManager().isBeforeInTranslationUnit(start, m_cursorSourceLocation) &&
sourceManager().isBeforeInTranslationUnit(m_cursorSourceLocation, end));
}
bool isCurrentTokenExpansion(const clang::MacroDefinition ¯oDefinition)
{
return m_cursorMacroDirective
&& m_cursorMacroDirective == macroDefinition.getLocalDirective();
}
bool isBeforeCursorSourceLocation() const
{
return !m_cursorMacroDirective;
}
private:
std::vector<clang::SourceLocation> m_sourceLocations;
std::vector<MacroDirectiveToken> m_preCursorMacroDirectiveTokens;
SourceLocationsContainer &m_sourceLocationsContainer;
Utils::SmallString &m_symbolName;
clang::Preprocessor &m_preprocessor;
const clang::MacroDirective *m_cursorMacroDirective = nullptr;
clang::SourceLocation m_mainFileSourceLocation;
clang::SourceLocation m_cursorSourceLocation;
FilePathCachingInterface &m_filePathCache;
uint m_line;
uint m_column;
bool m_isMainFileEntered = false;
};
} // namespace ClangBackEnd
| 38.824468
| 109
| 0.632141
|
[
"vector"
] |
f94efc01d0a497bf03136cd3ad9d0607540c2142
| 2,746
|
c
|
C
|
third_party/Phigs/OpenPhigs/phigs-prototype-src/phigs/src/libphigs/cb_wst.c
|
n1ckfg/Telidon
|
f4e2c693ec7d67245974b73a602d5d40df6a6d69
|
[
"MIT"
] | 18
|
2017-07-08T02:34:02.000Z
|
2022-01-08T03:42:48.000Z
|
third_party/Phigs/OpenPhigs/phigs-prototype-src/phigs/src/libphigs/cb_wst.c
|
n1ckfg/Telidon
|
f4e2c693ec7d67245974b73a602d5d40df6a6d69
|
[
"MIT"
] | null | null | null |
third_party/Phigs/OpenPhigs/phigs-prototype-src/phigs/src/libphigs/cb_wst.c
|
n1ckfg/Telidon
|
f4e2c693ec7d67245974b73a602d5d40df6a6d69
|
[
"MIT"
] | 3
|
2018-02-03T04:44:00.000Z
|
2020-08-05T15:31:18.000Z
|
/******************************************************************************
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER
*
* This file is part of Open PHIGS
* Copyright (C) 2014 Surplus Users Ham Society
*
* Open PHIGS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 2.1 of the License, or
* (at your option) any later version.
*
* Open PHIGS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Open PHIGS. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <phigs/phg.h>
#include <phigs/css.h>
#include <phigs/private/phgP.h>
/*******************************************************************************
* pinq_ws_cat
*
* DESCR: Get workstation category
* RETURNS: N/A
*/
void pinq_ws_cat(
Pint ws_type,
Pint *err_ind,
Pws_cat *cat
)
{
Wst *wst;
if (!phg_entry_check(0, Pfn_INQUIRY)) {
*err_ind = ERR2;
}
else {
wst = phg_wst_find(&PHG_WST_LIST, ws_type);
if (wst == NULL) {
*err_ind = ERR52;
}
else {
*err_ind = 0;
*cat = wst->desc_tbl.phigs_dt.ws_category;
}
}
}
/*******************************************************************************
* pinq_disp_space_size3
*
* DESCR: Get display size 3D
* RETURNS: N/A
*/
void pinq_disp_space_size3(
Pint ws_type,
Pint *err_ind,
Pdisp_space_size3 *size
)
{
Wst *wst;
Wst_phigs_dt *dt;
ERR_SET_CUR_FUNC(PHG_ERH, Pfn_INQUIRY);
wst = phg_wst_find(&PHG_WST_LIST, ws_type);
if (wst == NULL) {
*err_ind = ERR52;
}
else {
dt = &wst->desc_tbl.phigs_dt;
if (dt->ws_category == PCAT_MI) {
*err_ind = ERR57;
}
else {
*err_ind = 0;
if (wst->bound_status != WST_BOUND) {
size->dc_units = dt->dev_coord_units;
size->size_raster.size_x = dt->dev_addrs_units[0];
size->size_raster.size_y = dt->dev_addrs_units[1];
size->size_raster.size_z = dt->dev_addrs_units[2];
size->size_dc.size_x = dt->dev_coords[0];
size->size_dc.size_y = dt->dev_coords[1];
size->size_dc.size_z = dt->dev_coords[2];
}
}
}
}
| 27.737374
| 80
| 0.544064
|
[
"3d"
] |
f9572af9f0a7cc6c147ed8322eccfd570228cf3a
| 1,788
|
h
|
C
|
Djinn/core/log_sink.h
|
grandmaster789/Djinn
|
cfec71b99be399f76b22200a8afa84875cfb0888
|
[
"MIT"
] | 2
|
2019-01-15T14:55:40.000Z
|
2021-05-07T05:24:32.000Z
|
Djinn/core/log_sink.h
|
grandmaster789/Djinn
|
cfec71b99be399f76b22200a8afa84875cfb0888
|
[
"MIT"
] | null | null | null |
Djinn/core/log_sink.h
|
grandmaster789/Djinn
|
cfec71b99be399f76b22200a8afa84875cfb0888
|
[
"MIT"
] | null | null | null |
#pragma once
#include "log_message.h"
#include "preprocessor.h"
#include <filesystem>
#include <memory>
namespace djinn::core {
// Type-erased interface
//
// this will accept any type of backend that has implemented
// ::operator()(const LogMessage::MetaInfo&, const std::string)
class LogSink {
public:
template <typename T>
LogSink(T&& impl);
// contains a std::unique_ptr, so move-only
LogSink(const LogSink& sink) = delete;
LogSink& operator=(const LogSink& sink) = delete;
LogSink(LogSink&& sink) noexcept;
LogSink& operator=(LogSink&& sink) noexcept;
bool operator==(
const LogSink& sink) const; // implemented so that Logger can detect duplicate sinks
void write(const LogMessage::MetaInfo& metaInfo, const std::string& message);
private:
struct Concept {
virtual ~Concept() = default;
virtual void write(const LogMessage::MetaInfo& metaInfo, const std::string& message)
= 0;
};
template <typename T>
struct Model: Concept {
Model(T impl);
virtual void
write(const LogMessage::MetaInfo& metaInfo, const std::string& message) override;
T m_Impl;
};
std::unique_ptr<Concept> m_Wrapper;
};
// [logLevel] [message][\n] ~~> std::cout
LogSink makeConsoleSink();
// [timestamp] [loglevel] [message] ([sourcefile]:[linenumber])[\n] ~~> file path
LogSink makeFileSink(const std::filesystem::path& path);
#if DJINN_PLATFORM == DJINN_PLATFORM_WINDOWS
// [logLevel] [message][\n] ~~> OutputDebugStringA
LogSink makeWindowsConsoleSink();
#endif
} // namespace djinn::core
#include "log_sink.inl"
| 28.380952
| 97
| 0.618568
|
[
"model"
] |
f957538e83484cbd1fdbc383e918d4bcb07cfa2c
| 2,441
|
h
|
C
|
includes/parse.h
|
gmzorz/MiniRT
|
ce87cd1745036391f54503f25eb815273918d7e6
|
[
"MIT"
] | 10
|
2021-04-13T15:48:34.000Z
|
2022-03-10T19:16:24.000Z
|
includes/parse.h
|
gmzorz/MiniRT
|
ce87cd1745036391f54503f25eb815273918d7e6
|
[
"MIT"
] | null | null | null |
includes/parse.h
|
gmzorz/MiniRT
|
ce87cd1745036391f54503f25eb815273918d7e6
|
[
"MIT"
] | null | null | null |
/* ************************************************************************** */
/* */
/* :::::::: */
/* parse.h :+: :+: */
/* +:+ */
/* By: goosterl <[email protected]> +#+ */
/* +#+ */
/* Created: 2020/11/27 15:00:55 by goosterl #+# #+# */
/* Updated: 2021/04/13 00:06:45 by goosterl ######## odam.nl */
/* */
/* ************************************************************************** */
#ifndef PARSE_H
# define PARSE_H
# if IS_BONUS == 1
# include <parse_bonus.h>
# endif
# include <alias.h>
# include <scene.h>
# define RT_SAVE_SS "--save"
t_bool parse_to_scene(t_scene *scene, const char *rt_file);
t_bool parse_failure(void *freeable);
char *parse_id(char **line);
t_bool parse_real(char **line, t_real *in);
t_bool parse_unit(char **line, t_real *in, t_bool sign);
t_bool parse_int(char **line, int *in);
t_bool parse_unused(char **line);
t_bool parse_eol(char **line);
t_bool parse_skip(char **line, const char *delim, int skip_count);
t_bool parse_vector(char **line, t_vec3 *vector);
t_bool parse_normal(char **line, t_vec3 *normal);
t_bool parse_color(char **line, t_rgb *color);
t_bool parse_material(t_scene *scene, char **line, t_material *mat);
t_bool parse_resolution(t_scene *scene, char **line);
t_bool parse_ambience(t_scene *scene, char **line);
t_bool parse_camera(t_scene *scene, char **line);
t_bool parse_light(t_scene *scene, char **line);
t_bool parse_shape(t_scene *scene, char **line);
t_bool parse_light(t_scene *scene, char **line);
t_bool parse_sphere(t_scene *scene, char **line);
t_bool parse_plane(t_scene *scene, char **line);
t_bool parse_square(t_scene *scene, char **line);
t_bool parse_cylinder(t_scene *scene, char **line);
t_bool parse_triangle(t_scene *scene, char **line);
t_bool shape_push_back(t_shapes **list, void *shape, t_material mat,
t_shapetype type);
t_bool light_push_back(t_lights **list, t_lights *light);
t_bool cam_push_back(t_camlist **list, t_camera *cam, int id);
#endif
| 46.942308
| 80
| 0.520688
|
[
"shape",
"vector"
] |
f959da795597c35e4523ea03b0c45566c1d793cc
| 778
|
h
|
C
|
include/XS4GCR/spallation/spallation.h
|
carmeloevoli/D2XSECS
|
8c12bce59bce2f51555bd15f0824f9a8c056bd7e
|
[
"MIT"
] | 2
|
2018-05-24T14:57:56.000Z
|
2018-12-13T13:35:20.000Z
|
include/XS4GCR/spallation/spallation.h
|
cosmicrays/D2XSECS
|
8c12bce59bce2f51555bd15f0824f9a8c056bd7e
|
[
"MIT"
] | null | null | null |
include/XS4GCR/spallation/spallation.h
|
cosmicrays/D2XSECS
|
8c12bce59bce2f51555bd15f0824f9a8c056bd7e
|
[
"MIT"
] | 1
|
2021-07-03T01:15:29.000Z
|
2021-07-03T01:15:29.000Z
|
// Copyright (c) 2017 Carmelo Evoli - MIT License
#ifndef INCLUDE_XS4GCR_SPALLATION_SPALLATION_H_
#define INCLUDE_XS4GCR_SPALLATION_SPALLATION_H_
#include <cassert>
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "XS4GCR/pid.h"
namespace XS4GCR {
class Spallation {
public:
virtual void print() = 0;
virtual std::shared_ptr<Spallation> clone() = 0;
virtual double get(const channel& ch, const TARGET& target, const double& T_n,
bool do_ghosts = true) = 0;
inline void set_model_name(const std::string& m) { model_name = m; }
virtual ~Spallation() {}
protected:
std::string model_name;
};
} // namespace XS4GCR
#endif // INCLUDE_XS4GCR_SPALLATION_SPALLATION_H_
| 22.882353
| 82
| 0.703085
|
[
"vector"
] |
c3bfe36be80cfeddcb3a29bf717af17b5559050b
| 597
|
h
|
C
|
DDAnalytics/DDAnalytics/Classes/DDAlayticsM/DDAnalyticsCDM.h
|
syedqamara/Dastak
|
e4016e0d43cfd782f99708339331c8ed37eaaf5e
|
[
"MIT"
] | null | null | null |
DDAnalytics/DDAnalytics/Classes/DDAlayticsM/DDAnalyticsCDM.h
|
syedqamara/Dastak
|
e4016e0d43cfd782f99708339331c8ed37eaaf5e
|
[
"MIT"
] | null | null | null |
DDAnalytics/DDAnalytics/Classes/DDAlayticsM/DDAnalyticsCDM.h
|
syedqamara/Dastak
|
e4016e0d43cfd782f99708339331c8ed37eaaf5e
|
[
"MIT"
] | null | null | null |
//
// DDAnalyticsM.h
// DDAnalytics
//
// Created by Syed Qamar Abbas on 19/05/2020.
//
#import <CoreData/CoreData.h>
#import "DDAnalyticsM.h"
NS_ASSUME_NONNULL_BEGIN
@interface DDAnalyticsCDM : NSManagedObject
@property (strong, nonatomic) NSString *identifier;
@property (strong, nonatomic) NSString *company_key;
@property (strong, nonatomic) NSString *session_id;
@property (strong, nonatomic) NSString *event_name;
@property (strong, nonatomic) NSString *event_description;
@property (strong, nonatomic) NSDictionary *event_content;
-(DDAnalyticsM *)model;
@end
NS_ASSUME_NONNULL_END
| 23.88
| 58
| 0.773869
|
[
"model"
] |
c3cd6dd90b95fd5be18ea5836f58be38fc26e891
| 11,556
|
h
|
C
|
NativeLibraries/iOS/HERE_iOS_SDK_Premium_v3.15.2_92/framework/NMAKit.framework/Headers/NMAPlatformDataItem.h
|
KarinBerg/Xamarin.HEREMaps
|
87927ba567892528d1251ee83ffaab34fe201899
|
[
"MIT"
] | 15
|
2020-07-06T00:42:33.000Z
|
2022-02-23T21:55:05.000Z
|
NativeLibraries/iOS/HERE_iOS_SDK_Premium_v3.15.2_92/framework/NMAKit.framework/Headers/NMAPlatformDataItem.h
|
KarinBerg/Xamarin.HEREMaps
|
87927ba567892528d1251ee83ffaab34fe201899
|
[
"MIT"
] | 1
|
2021-09-22T05:48:37.000Z
|
2021-09-29T20:35:43.000Z
|
NativeLibraries/iOS/HERE_iOS_SDK_Premium_v3.15.2_92/framework/NMAKit.framework/Headers/NMAPlatformDataItem.h
|
KarinBerg/Xamarin.HEREMaps
|
87927ba567892528d1251ee83ffaab34fe201899
|
[
"MIT"
] | 3
|
2020-08-09T06:06:40.000Z
|
2021-11-14T12:23:32.000Z
|
/*
* Copyright (c) 2011-2020 HERE Global B.V. and its affiliate(s).
* All rights reserved.
* The use of this software is conditional upon having a separate agreement
* with a HERE company for the use or utilization of this software. In the
* absence of such agreement, the use of the software is not allowed.
*/
@class NMAGeoCoordinates;
/**
* Type of the condition entity as described by the CONDITION_TYPE field.
*/
typedef NS_ENUM(NSUInteger, NMAPlatformDataConditionType) {
/** Indicates that the condition type is undefined. */
NMAPlatformDataConditionTypeUndefined NS_SWIFT_NAME(undefined) = 0,
/** Indicates toll structure. */
NMAPlatformDataConditionTypeTollStructure NS_SWIFT_NAME(tollStructure) = 1,
/** Indicates construction status closed. */
NMAPlatformDataConditionTypeConstructionStatusClosed NS_SWIFT_NAME(constructionStatusClosed) = 3,
/** Indicates gates. */
NMAPlatformDataConditionTypeGates NS_SWIFT_NAME(gates) = 4,
/** Indicates direction of travel. */
NMAPlatformDataConditionTypeDirectionOfTravel NS_SWIFT_NAME(directionOfTravel) = 5,
/** Indicates restricted driving manoeuvre. */
NMAPlatformDataConditionTypeRestrictedDrivingManoeuvre NS_SWIFT_NAME(restrictedDrivingManoeuvre)= 7,
/** Indicates access restriction. */
NMAPlatformDataConditionTypeAccessRestriction NS_SWIFT_NAME(accessRestriction) = 8,
/** Indicates special explication. */
NMAPlatformDataConditionTypeSpecialExplication NS_SWIFT_NAME(specialExplication) = 9,
/** Indicates special speed situation. */
NMAPlatformDataConditionTypeSpecialSpeedSituation NS_SWIFT_NAME(specialSpeedSituation) = 10,
/** Indicates variable speed sign. */
NMAPlatformDataConditionTypeVariableSpeedSign NS_SWIFT_NAME(variableSpeedSign) = 11,
/** Indicates usage fee required. */
NMAPlatformDataConditionTypeUsageFeeRequired NS_SWIFT_NAME(usageFeeRequired) = 12,
/** Indicates lane traversal. */
NMAPlatformDataConditionTypeLaneTraversal NS_SWIFT_NAME(laneTraversal) = 13,
/** Indicates through route. */
NMAPlatformDataConditionTypeThroughRoute NS_SWIFT_NAME(throughRoute) = 14,
/** Indicates traffic signal. */
NMAPlatformDataConditionTypeTrafficSignal NS_SWIFT_NAME(trafficSignal) = 16,
/** Indicates traffic sign. */
NMAPlatformDataConditionTypeTrafficSign NS_SWIFT_NAME(trafficSign) = 17,
/** Indicates railway crossing. */
NMAPlatformDataConditionTypeRailwayCrossing NS_SWIFT_NAME(railwayCrossing) = 18,
/** Indicates no overtaking. */
NMAPlatformDataConditionTypeNoOvertaking NS_SWIFT_NAME(noOvertaking) = 19,
/** Indicates junction view. */
NMAPlatformDataConditionTypeJunctionView NS_SWIFT_NAME(junctionView) = 20,
/** Indicates protected overtaking. */
NMAPlatformDataConditionTypeProtectedOvertaking NS_SWIFT_NAME(protectedOvertaking) = 21,
/** Indicates evacuation route. */
NMAPlatformDataConditionTypeEvacuationRoute NS_SWIFT_NAME(evacuationRoute) = 22,
/** Indicates transport access restriction. */
NMAPlatformDataConditionTypeTransportAccessRestriction NS_SWIFT_NAME(transportAccessRestriction)= 23,
/** Indicates transport special speed situation. */
NMAPlatformDataConditionTypeTransportSpclSpdSituation NS_SWIFT_NAME(transportSpclSpdSituation) = 25,
/** Indicates transport restricted driving manoeuvre. */
NMAPlatformDataConditionTypeTransportRdm NS_SWIFT_NAME(transportRdm) = 26,
/** Indicates transport preferred route. */
NMAPlatformDataConditionTypeTransportPreferredRoute NS_SWIFT_NAME(transportPreferredRoute) = 27,
/** Indicates calculated restricted driving manoeuvre. */
NMAPlatformDataConditionTypeCalculatedRestrictedDrivingManoeuvre NS_SWIFT_NAME(calculatedRestrictedDrivingManoeuvre) = 30,
/** Indicates parking information. */
NMAPlatformDataConditionTypeParkingInformation NS_SWIFT_NAME(parkingInformation) = 31,
/** Indicates environmental zone. */
NMAPlatformDataConditionTypeEnvironmentalZone NS_SWIFT_NAME(environmentalZone) = 34,
/** Indicates blackspot. */
NMAPlatformDataConditionTypeBlackspot NS_SWIFT_NAME(blackspot) = 38,
/** Indicates permitted driving manoeuvre. */
NMAPlatformDataConditionTypePermittedDrivingManoeuvre NS_SWIFT_NAME(permittedDrivingManoeuvre) = 39,
/** Indicates variable speed limit. */
NMAPlatformDataConditionTypeVariableSpeedLimit NS_SWIFT_NAME(variableSpeedLimit) = 40,
/** Indicates short construction warning. */
NMAPlatformDataConditionTypeShortConstructionWarning NS_SWIFT_NAME(shortConstructionWarning) = 41
};
/**
* The possible vehicle types that are allowed on a link
* as described by the VEHICLE_TYPES field.
*/
typedef NS_OPTIONS(NSUInteger, NMAPlatformDataVehicleType) {
/** Indicates that the vehicle type is undefined. */
NMAPlatformDataVehicleTypeUndefined NS_SWIFT_NAME(undefined)= 0,
/** Indicates automobiles. */
NMAPlatformDataVehicleTypeAutomobiles NS_SWIFT_NAME(automobiles)= 1 << 0,
/** Indicates buses. */
NMAPlatformDataVehicleTypeBuses NS_SWIFT_NAME(buses)= 1 << 1,
/** Indicates taxis. */
NMAPlatformDataVehicleTypeTaxis NS_SWIFT_NAME(taxis)= 1 << 2,
/** Indicates car pools. */
NMAPlatformDataVehicleTypeCarPools NS_SWIFT_NAME(carPools)= 1 << 3,
/** Indicates pedestrians. */
NMAPlatformDataVehicleTypePedestrians NS_SWIFT_NAME(pedestrians)= 1 << 4,
/** Indicates trucks. */
NMAPlatformDataVehicleTypeTrucks NS_SWIFT_NAME(trucks)= 1 << 5,
/** Indicates deliveries. */
NMAPlatformDataVehicleTypeDeliveries NS_SWIFT_NAME(deliveries)= 1 << 6,
/** Indicates emergency vehicles. */
NMAPlatformDataVehicleTypeEmergencyVehicles NS_SWIFT_NAME(emergencyVehicles)= 1 << 7,
/** Indicates through traffic.*/
NMAPlatformDataVehicleTypeThroughTraffic NS_SWIFT_NAME(throughTraffic)= 1 << 8,
/** Indicates motorcycles. */
NMAPlatformDataVehicleTypeMotorcycles NS_SWIFT_NAME(motorcycles)= 1 << 9,
/** Indicates road trains. */
NMAPlatformDataVehicleTypeRoadTrains NS_SWIFT_NAME(roadTrains)= 1 << 10,
/** Indicates all the above types. */
NMAPlatformDataVehicleTypeAll NS_SWIFT_NAME(all)= 0x7FF
};
/**
* After a Platform Data Request run, each layer data is returned with objects
* of this class. The properties are just helper shortcuts for the most used fields.
* That is for any data not accessed via the properties, the users can access them
* directly. For example, assume item is an object of NMAPlatformDataItem type.
* Then, item[@"COUNTRY_ID"] returns the COUNTRY_ID string and nil if the item has
* no such data.
*/
@interface NMAPlatformDataItem : NSObject <NSCopying>
/**
* Do not directly instantiate an instance of this class.
*/
- (nonnull instancetype)init NS_UNAVAILABLE;
/**
* Instances of this class should not be initialized directly
*/
+ (nonnull instancetype)new NS_UNAVAILABLE;
#pragma mark - Shortcut properties
/**
* LINK_ID data.
*
* Positive 64 bit Integer that globally identifies the road, carto or buildin footprint link,
* also across map releases. Link IDs are never reused.
*
* However, it is returned as an NString object. It can be converted to numeric value via the
* [NString longLongValue] method.
*
* @note It is nil if not set.
*/
@property (nullable, nonatomic, weak, readonly) NSString *linkId;
/**
* LAT & LON data.
*
* Latitude & longitude coordinates [10^-5 degree WGS84] along the polyline or of the reference node
* and the non reference node. Comma separated. Each value is relative to the previous.
*
* The LAT & LON strings are converted into an NSArray of NMAGeoCoordinates.
*
* @note It is nil if not set.
*/
@property (nullable, nonatomic, weak, readonly) NSArray<NMAGeoCoordinates*> *coordinates;
/**
* LINK_LENGTH data.
*
* The link length in meter. This attribute publishes the whole link length, no matter whether the link
* spans across several tiles. The link length is computed by straight lines between subsequent shape
* points, no splines or other smoothing functions or geodesic computations are used.
*
* @note It is -1.0f if not set.
*/
@property (nonatomic, readonly) float linkLengthMeter;
/**
* LINK_IDS data.
*
* Comma separated list of Permanent link IDs that describe a route path. A negative sign means that
* this link was driven towards reference node. If the list contains only one link, then a 'B' prefix
* tells that it applies for both driving directions. Each link ID is a positive 64 bit Integer that
* globally identifies the road link, also across map releases. Link IDs are never reused.
*
* @note It is nil if not set.
*/
@property (nullable, nonatomic, weak, readonly) NSArray <NSString*> *linkIds;
/**
* CONDITION_TYPE data.
*
* Type of the condition entity.
*
* @note It is NMAPlatformDataConditionTypeUndefined if not set.
*
* See also `NMAPlatformDataConditionType`
*/
@property (nonatomic, readonly) NMAPlatformDataConditionType conditionType;
/**
* VEHICLE_TYPES data.
*
* Access Characteristics identify the vehicle types that are allowed on a link, allowed on a lane or to which
* condition applies.
*
* 16 bit bitmask of affected vehicle types or functions. Sum of: Automobiles (1), buses (2), taxis (4), car
* pools (8), pedestrians (16), trucks (32), deliveries (64), emergency vehicles (128), through traffic (256),
* motorcycles (512) and road trains (1024).
*
* @note It is NMAPlatformDataVehicleTypeUndefined if not set.
*
* See also `NMAPlatformDataVehicleType`
*/
@property (nonatomic, readonly) NMAPlatformDataVehicleType vehicleTypes;
/**
* DTM_AVG_HEIGHT data.
*
* The average height [cm above WGS84 ellipsoid] along the link.
*
* @note It is NSIntegerMax if not set.
*/
@property (nonatomic, readonly) NSInteger averageHeightCm;
#pragma mark - Methods
/**
* Returns the data associated with a given key.
*
* @param key The key for the data requested.
*
* @return The associated data or nil if the key isn't
* found in result.
*/
- (nullable NSString *)objectForKeyedSubscript:(nonnull NSString *)key;
/**
* Returns all the key strings.
*
* @return The array of all the keys.
*/
- (nullable NSArray<NSString *> *)allKeys;
/**
* Returns the all the value strings.
*
* @return All the value strings contained in the item.
*/
- (nullable NSArray<NSString *> *)allValues;
/**
* Applies a given block object to the entries in the item.
*/
- (void)enumerateKeysAndObjectsUsingBlock:(void (^_Nonnull)(NSString * _Nonnull key, NSString * _Nonnull obj, BOOL * _Nonnull stop))block;
/**
* Extracts the data contained into a dictionary.
*
* @return A dictionary of the string key/value pairs.
*/
- (nullable NSDictionary<NSString *, NSString *> *)extract;
/**
* The number of entries in the item.
*/
@property (readonly) NSUInteger count;
@end
| 37.764706
| 138
| 0.709675
|
[
"object",
"shape"
] |
c3d96b6d8b5d01be4950f018f1af48eac1fc8b65
| 4,515
|
h
|
C
|
ruy/frontend.h
|
GeorgeARM/ruy
|
4790797d11a81f96baf24f3731fd3ca44c2c5f8b
|
[
"Apache-2.0"
] | null | null | null |
ruy/frontend.h
|
GeorgeARM/ruy
|
4790797d11a81f96baf24f3731fd3ca44c2c5f8b
|
[
"Apache-2.0"
] | null | null | null |
ruy/frontend.h
|
GeorgeARM/ruy
|
4790797d11a81f96baf24f3731fd3ca44c2c5f8b
|
[
"Apache-2.0"
] | 1
|
2021-06-24T15:28:20.000Z
|
2021-06-24T15:28:20.000Z
|
/* Copyright 2019 Google LLC. All Rights Reserved.
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
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// Implementation of MulFrontEnd, the front-end part of ruy.
// This is what the ruy::Mul entry point calls, and this ends in a call to
// TrMul, at which point we enter the middle-end.
// The front-end work includes parameter validation (Validate), detemplatization
// and resolution of the specific code path to take (CreateTrMulParams), and
// any additional logic best done upfront before entering the middle-end
// (e.g. HandlePrepackedCaching).
// The call to CreateTrMulParams is an important watershed in this code's
// structure: code before it needs to be templatized like the ruy::Mul entry
// point, code after it is un-templatized.
#ifndef RUY_RUY_FRONTEND_H_
#define RUY_RUY_FRONTEND_H_
#include "ruy/create_trmul_params.h"
#include "ruy/ctx.h"
#include "ruy/profiler/instrumentation.h"
#include "ruy/trmul_params.h"
#include "ruy/validate.h"
namespace ruy {
// The first half of front-end work, up to the point where we have TrMulParams.
// In other words, this is the part of the front-end work that needs to be
// templatized like the entry point, and that performs the initial work that
// requires this templatization, and the de-templatization. The output of this
// function is the TrMulParams, which contain enough information to allow the
// un-templatized code to take over from there.
template <Path CompiledPaths, typename LhsScalar, typename RhsScalar,
typename AccumScalar, typename DstScalar>
void MulFrontEndUpToCreateTrMulParams(
const Mat<LhsScalar>& lhs, const Mat<RhsScalar>& rhs,
const Mat<DstScalar>& dst,
const MulParams<AccumScalar, DstScalar>& mul_params, Ctx* ctx,
TrMulParams* params) {
static_assert(CompiledPaths != Path::kNone, "Must compile at least one Path");
static_assert(
(CompiledPaths & ~kAllPathsIncludingInternalVariants) == Path::kNone,
"CompiledPaths must be a subset of "
"ruy::kAllPathsIncludingInternalVariants");
// Perform validation of parameters early so that failures are easier to map
// to user errors. In particular, perform this validation before the
// transposition.
Validate(lhs, rhs, dst);
// De-templatize this Mul call by creating a TrMulParams structure.
// This is also where the specific kernel and pack code paths corresponding to
// `the_path` are selected, among all the code paths in `CompiledPaths`, and
// recorded as function pointers in the TrMulParams.
// The Transpose(lhs) here is where we switch from 'Mul' to 'TrMul'.
CreateTrMulParams<CompiledPaths>(Transpose(lhs), rhs, dst, mul_params, ctx,
params);
}
// The second part of the front-end work, starting from where we have freshly
// created TrMulParams, performing any remaining front-end work and entering the
// middle-end.
void MulFrontEndFromTrMulParams(Ctx* ctx, TrMulParams* params);
// Top-level function orchestrating the two halves of front-end work:
// before and after we have detemplatized the call by creating TrMulParams.
template <Path CompiledPaths, typename LhsScalar, typename RhsScalar,
typename AccumScalar, typename DstScalar>
void MulFrontEnd(const Mat<LhsScalar>& lhs, const Mat<RhsScalar>& rhs,
const MulParams<AccumScalar, DstScalar>& mul_params, Ctx* ctx,
Mat<DstScalar>* dst) {
profiler::ScopeLabel mul_label("Mul");
profiler::ScopeLabel shape_specific_label("matmul shape: %dx%dx%d",
lhs.layout.rows, lhs.layout.cols,
rhs.layout.cols);
ctx->clear_performance_advisories();
TrMulParams params;
MulFrontEndUpToCreateTrMulParams<CompiledPaths>(lhs, rhs, *dst, mul_params,
ctx, ¶ms);
MulFrontEndFromTrMulParams(ctx, ¶ms);
}
} // namespace ruy
#endif // RUY_RUY_FRONTEND_H_
| 46.546392
| 80
| 0.716058
|
[
"shape"
] |
c3de3bc0b75aa0907310c66b4b4ec377611c1cb2
| 35,660
|
h
|
C
|
contrib/gitian-builder/inputs/MacOSX.sdk/System/Library/Frameworks/AppKit.framework/Versions/C/Headers/NSImage.h
|
Phikzel2/haroldcoin-main-MacOS
|
15c949c8f722d424fd9603fab3c49ec4b2b720eb
|
[
"MIT"
] | null | null | null |
contrib/gitian-builder/inputs/MacOSX.sdk/System/Library/Frameworks/AppKit.framework/Versions/C/Headers/NSImage.h
|
Phikzel2/haroldcoin-main-MacOS
|
15c949c8f722d424fd9603fab3c49ec4b2b720eb
|
[
"MIT"
] | null | null | null |
contrib/gitian-builder/inputs/MacOSX.sdk/System/Library/Frameworks/AppKit.framework/Versions/C/Headers/NSImage.h
|
Phikzel2/haroldcoin-main-MacOS
|
15c949c8f722d424fd9603fab3c49ec4b2b720eb
|
[
"MIT"
] | 1
|
2021-08-13T21:12:07.000Z
|
2021-08-13T21:12:07.000Z
|
/*
NSImage.h
Application Kit
Copyright (c) 1994-2018, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSObject.h>
#import <Foundation/NSArray.h>
#import <Foundation/NSDictionary.h>
#import <Foundation/NSGeometry.h>
#import <Foundation/NSBundle.h>
#import <AppKit/NSGraphics.h>
#import <AppKit/NSBitmapImageRep.h>
#import <AppKit/NSPasteboard.h>
#import <AppKit/NSLayoutConstraint.h>
#import <ApplicationServices/ApplicationServices.h>
NS_ASSUME_NONNULL_BEGIN
@class NSColor, NSImageRep, NSGraphicsContext, NSURL;
@protocol NSImageDelegate;
typedef NSString * NSImageName NS_SWIFT_BRIDGED_TYPEDEF;
APPKIT_EXTERN NSImageHintKey const NSImageHintCTM NS_AVAILABLE_MAC(10_6); // value is NSAffineTransform
APPKIT_EXTERN NSImageHintKey const NSImageHintInterpolation NS_AVAILABLE_MAC(10_6); // value is NSNumber with NSImageInterpolation enum value
APPKIT_EXTERN NSImageHintKey const NSImageHintUserInterfaceLayoutDirection NS_AVAILABLE_MAC(10_12); // value is NSNumber with NSUserInterfaceLayoutDirection enum value
typedef NS_ENUM(NSUInteger, NSImageLoadStatus) {
NSImageLoadStatusCompleted,
NSImageLoadStatusCancelled,
NSImageLoadStatusInvalidData,
NSImageLoadStatusUnexpectedEOF,
NSImageLoadStatusReadError
};
typedef NS_ENUM(NSUInteger, NSImageCacheMode) {
NSImageCacheDefault, // unspecified. use image rep's default
NSImageCacheAlways, // always generate a cache when drawing
NSImageCacheBySize, // cache if cache size is smaller than original data
NSImageCacheNever // never cache, always draw direct
};
typedef NS_ENUM(NSInteger, NSImageResizingMode) {
NSImageResizingModeStretch,
NSImageResizingModeTile
} NS_AVAILABLE_MAC(10_10);
@class _NSImageAuxiliary;
@interface NSImage : NSObject <NSCopying, NSSecureCoding, NSPasteboardReading, NSPasteboardWriting>
{
/*All instance variables are private*/
NSImageName _name APPKIT_IVAR;
NSSize _size APPKIT_IVAR;
struct __imageFlags {
unsigned int scalable:1;
unsigned int dataRetained:1;
unsigned int uniqueWindow:1;
unsigned int sizeWasExplicitlySet:1;
unsigned int builtIn:1;
unsigned int needsToExpand:1;
unsigned int useEPSOnResolutionMismatch:1;
unsigned int matchesOnlyOnBestFittingAxis:1;
unsigned int colorMatchPreferred:1;
unsigned int multipleResolutionMatching:1;
unsigned int focusedWhilePrinting:1;
unsigned int archiveByName:1;
unsigned int unboundedCacheDepth:1;
unsigned int flipped:1;
unsigned int aliased:1;
unsigned int dirtied:1;
unsigned int cacheMode:2;
unsigned int sampleMode:3;
unsigned int resMatchPreferred:1;
unsigned int isTemplate:1;
unsigned int failedToExpand:1;
unsigned int reserved1:8;
} _flags APPKIT_IVAR;
volatile id _reps APPKIT_IVAR;
_NSImageAuxiliary *_imageAuxiliary APPKIT_IVAR;
}
+ (nullable NSImage *)imageNamed:(NSImageName)name; /* If this finds & creates the image, only name is saved when archived */
- (instancetype)initWithSize:(NSSize)size NS_DESIGNATED_INITIALIZER;
- (instancetype)initWithCoder:(NSCoder *)coder NS_DESIGNATED_INITIALIZER;
- (nullable instancetype)initWithData:(NSData *)data; /* When archived, saves contents */
- (nullable instancetype)initWithContentsOfFile:(NSString *)fileName; /* When archived, saves contents */
- (nullable instancetype)initWithContentsOfURL:(NSURL *)url; /* When archived, saves contents */
- (nullable instancetype)initByReferencingFile:(NSString *)fileName; /* When archived, saves fileName */
- (instancetype)initByReferencingURL:(NSURL *)url; /* When archived, saves url, supports progressive loading */
- (instancetype)initWithIconRef:(IconRef)iconRef NS_AVAILABLE_MAC(10_5);
- (nullable instancetype)initWithPasteboard:(NSPasteboard *)pasteboard;
// not for general use, but useful for compatibility with old NSImage behavior. Ignore exif orientation tags in JPEG and such. See AppKit release notes.
- (nullable instancetype)initWithDataIgnoringOrientation:(NSData *)data NS_AVAILABLE_MAC(10_6);
// Note that the block passed to the below method may be invoked whenever and on whatever thread the image itself is drawn on. Care should be taken to ensure that all state accessed within the drawingHandler block is done so in a thread safe manner.
+ (instancetype)imageWithSize:(NSSize)size flipped:(BOOL)drawingHandlerShouldBeCalledWithFlippedContext drawingHandler:(BOOL (^)(NSRect dstRect))drawingHandler NS_AVAILABLE_MAC(10_8);
@property NSSize size;
- (BOOL)setName:(nullable NSImageName)string;
- (nullable NSImageName)name;
@property (copy) NSColor *backgroundColor;
@property BOOL usesEPSOnResolutionMismatch;
@property BOOL prefersColorMatch;
@property BOOL matchesOnMultipleResolution;
@property BOOL matchesOnlyOnBestFittingAxis NS_AVAILABLE_MAC(10_7); // Available in MacOSX 10.7.4 // Available in MacOSX 10.7.4
- (void)drawAtPoint:(NSPoint)point fromRect:(NSRect)fromRect operation:(NSCompositingOperation)op fraction:(CGFloat)delta;
- (void)drawInRect:(NSRect)rect fromRect:(NSRect)fromRect operation:(NSCompositingOperation)op fraction:(CGFloat)delta;
- (void)drawInRect:(NSRect)dstSpacePortionRect fromRect:(NSRect)srcSpacePortionRect operation:(NSCompositingOperation)op fraction:(CGFloat)requestedAlpha respectFlipped:(BOOL)respectContextIsFlipped hints:(nullable NSDictionary<NSImageHintKey, id> *)hints NS_AVAILABLE_MAC(10_6);
- (BOOL)drawRepresentation:(NSImageRep *)imageRep inRect:(NSRect)rect;
/* This is exactly equivalent to calling -[image drawInRect:rect fromRect:NSZeroRect operation:NSCompositeSourceOver fraction:1 respectFlipped:YES hints:nil].
*/
- (void)drawInRect:(NSRect)rect NS_AVAILABLE_MAC(10_9);
- (void)recache;
@property (nullable, readonly, strong) NSData *TIFFRepresentation;
- (nullable NSData *)TIFFRepresentationUsingCompression:(NSTIFFCompression)comp factor:(float)factor;
@property (readonly, copy) NSArray<NSImageRep *> *representations;
- (void)addRepresentations:(NSArray<NSImageRep *> *)imageReps;
- (void)addRepresentation:(NSImageRep *)imageRep;
- (void)removeRepresentation:(NSImageRep *)imageRep;
@property (getter=isValid, readonly) BOOL valid;
- (void)lockFocus;
- (void)lockFocusFlipped:(BOOL)flipped NS_AVAILABLE_MAC(10_6);
- (void)unlockFocus;
// use -[NSImage bestRepresentationForRect:context:hints:] instead. Any deviceDescription dictionary is also a valid hints dictionary.
- (null_unspecified NSImageRep *)bestRepresentationForDevice:(null_unspecified NSDictionary *)deviceDescription NS_DEPRECATED_MAC(10_0, 10_6);
@property (nullable, weak) id<NSImageDelegate> delegate;
/* These return union of all the types registered with NSImageRep.
*/
+ (NSArray<NSString *> *)imageUnfilteredFileTypes NS_DEPRECATED_MAC(10_0, 10_10, "Use +imageUnfilteredTypes instead");
+ (NSArray<NSPasteboardType> *)imageUnfilteredPasteboardTypes NS_DEPRECATED_MAC(10_0, 10_10, "Use +imageUnfilteredTypes instead");
+ (NSArray<NSString *> *)imageFileTypes NS_DEPRECATED_MAC(10_0, 10_10, "Use +imageTypes instead");
+ (NSArray<NSPasteboardType> *)imagePasteboardTypes NS_DEPRECATED_MAC(10_0, 10_10, "Use +imageTypes instead");
@property (class, readonly, copy) NSArray<NSString *> *imageTypes NS_AVAILABLE_MAC(10_5);
@property (class, readonly, copy) NSArray<NSString *> *imageUnfilteredTypes NS_AVAILABLE_MAC(10_5);
+ (BOOL)canInitWithPasteboard:(NSPasteboard *)pasteboard;
- (void)cancelIncrementalLoad;
@property NSImageCacheMode cacheMode;
/* The alignmentRect of an image is metadata that a client may use to help determine layout. The bottom of the rect gives the baseline of the image. The other edges give similar information in other directions.
A 20x20 image of a phone icon with a glow might specify an alignmentRect of {{2,2},{16,16}} that excludes the glow. NSButtonCell can take advantage of the alignmentRect to place the image in the same visual location as an 16x16 phone icon without the glow. A 5x5 star that should render high when aligned with text might specify a rect of {{0,-7},{5,12}}.
The alignmentRect of an image has no effect on methods such as drawInRect:fromRect:operation:Fraction: or drawAtPoint:fromRect:operation:fraction:. It is the client's responsibility to take the alignmentRect into account where applicable.
The default alignmentRect of an image is {{0,0},imageSize}. The rect is adjusted when setSize: is called.
*/
@property NSRect alignmentRect NS_AVAILABLE_MAC(10_5);
/* The 'template' property is metadata that allows clients to be smarter about image processing. An image should be marked as a template if it is basic glpyh-like black and white art that is intended to be processed into derived images for use on screen.
NSButtonCell applies effects to images based on the state of the button. For example, images are shaded darker when the button is pressed. If a template image is set on a cell, the cell can apply more sophisticated effects. For example, it may be processed into an image that looks engraved when drawn into a cell whose interiorBackgroundStyle is NSBackgroundStyleRaised, like on a textured button.
*/
#if defined(__cplusplus)
- (BOOL)isTemplate NS_AVAILABLE_MAC(10_5);
- (void)setTemplate:(BOOL)isTemplate NS_AVAILABLE_MAC(10_5);
#else
@property (getter=isTemplate) BOOL template NS_AVAILABLE_MAC(10_5);
#endif
/* An accessibility description can be set on an image. This description will be used automatically by interface elements that display images. Like all accessibility descriptions, the string should be a short localized string that does not include the name of the interface element. For instance, "delete" rather than "delete button".
*/
@property (nullable, copy) NSString *accessibilityDescription NS_AVAILABLE_MAC(10_6);
/* Make an NSImage referencing a CGImage. The client should not assume anything about the image, other than that drawing it is equivalent to drawing the CGImage.
If size is NSZeroSize, the pixel dimensions of cgImage are the returned image's size.
This is not a designated initializer.
Size of an NSImage is distinct from pixel dimensions. If an NSImage is placed in an NSButton, it will be drawn in a rect with the provided size in the ambient coordinate system.
*/
- (instancetype)initWithCGImage:(CGImageRef)cgImage size:(NSSize)size NS_AVAILABLE_MAC(10_6);
/* Returns a CGImage capturing the drawing of the receiver. This method returns an existing CGImage if one is available, or creates one if not. It behaves the same as drawing the image with respect to caching and related behaviors. This method is typically called, not overridden.
An NSImage is potentially resolution independent, and may have representations that allow it to draw well in many contexts. A CGImage is more like a single pixel-based representation. This method produces a snapshot of how the NSImage would draw if it was asked to draw in *proposedDestRect in the passed context. Producing this snapshot may be more expensive than just drawing the NSImage, so prefer to use -[NSImage drawInRect:fromRect:operation:fraction:] unless you require a CGImage.
The return value in *proposedDestRect tells the client where to draw the CGImage. This rect may be outset from the requested rect, because a CGImage must have pixel-integral dimensions while an NSImage need not.
All input parameters are optional. They provide hints for how to choose among existing CGImages, or how to create one if there isn't already a CGImage available. The parameters are _only_ hints. Any CGImage is a valid return.
If proposedDestRect is NULL, it defaults to the smallest pixel-integral rectangle containing {{0,0}, [self size]}. The proposedDestRect is in user space in the reference context.
If referenceContext is nil, the method behaves as if a window context scaled by the default user space scaling factor was passed, though no context is actually created. The properties of the context are used as hints for choosing the best representation and for creating a CGImage if creation is necessary. It also provides the coordinate space in which the proposedDestRect is interpreted. Only the snapshotted state of the context at the moment its passed to this method is relevant. Future changes to the context have no bearing on image behavior.
The hints provide more context for selecting or generating a CGImage, and may override properties of the referenceContext. Hints may be nil. Any entries in a device description dictionary (see NSScreen) are valid, as are all CIContext creation options, plus a few extra hints defined below. Unrecognized hints are ignored, but passed down to image reps (see -[NSImageRep CGImageForProposedRect:context:hints:]). Explicit hints are particularly useful when it is not draw time and you don't have a context to pass in. For example, if you want to pass a rect in pixels for proposedDestRect, you should pass a dictionary with the identity transform for NSImageHintCTM.
This method will always return a valid CGImage provided the NSImage is able to draw. If the receiver is unable to draw for whatever reason, the error behavior is the same as when drawing the image.
The CGImageRef returned is guaranteed to live as long as the current autorelease pool. The caller should not release the CGImage. This is the standard Cocoa convention, but people may not realize that it applies to CFTypes.
*/
- (nullable CGImageRef)CGImageForProposedRect:(nullable NSRect *)proposedDestRect context:(nullable NSGraphicsContext *)referenceContext hints:(nullable NSDictionary<NSImageHintKey, id> *)hints NS_AVAILABLE_MAC(10_6) CF_RETURNS_NOT_RETAINED;
/* Select best representation. The parameters have the same meaning and behavior as in -CGImageForProposedRect:context:hints:.
*/
- (nullable NSImageRep *)bestRepresentationForRect:(NSRect)rect context:(nullable NSGraphicsContext *)referenceContext hints:(nullable NSDictionary<NSImageHintKey, id> *)hints NS_AVAILABLE_MAC(10_6);
/* Answers the question, "If you were to draw the image in the passed destination rect in the passed context respecting the passed flippedness with the passed hints, would the test rect in the context intersect a non-transparent portion of the image?"
*/
- (BOOL)hitTestRect:(NSRect)testRectDestSpace withImageDestinationRect:(NSRect)imageRectDestSpace context:(nullable NSGraphicsContext *)context hints:(nullable NSDictionary<NSImageHintKey, id> *)hints flipped:(BOOL)flipped NS_AVAILABLE_MAC(10_6);
- (CGFloat)recommendedLayerContentsScale:(CGFloat)preferredContentsScale NS_AVAILABLE_MAC(10_7);
- (id)layerContentsForContentsScale:(CGFloat)layerContentsScale NS_AVAILABLE_MAC(10_7);
@property NSEdgeInsets capInsets NS_AVAILABLE_MAC(10_10);
@property NSImageResizingMode resizingMode NS_AVAILABLE_MAC(10_10);
@end
@protocol NSImageDelegate <NSObject>
@optional
- (nullable NSImage *)imageDidNotDraw:(NSImage *)sender inRect:(NSRect)rect;
- (void)image:(NSImage *)image willLoadRepresentation:(NSImageRep *)rep;
- (void)image:(NSImage *)image didLoadRepresentationHeader:(NSImageRep *)rep;
- (void)image:(NSImage *)image didLoadPartOfRepresentation:(NSImageRep *)rep withValidRows:(NSInteger)rows;
- (void)image:(NSImage *)image didLoadRepresentation:(NSImageRep *)rep withStatus:(NSImageLoadStatus)status;
@end
@interface NSBundle(NSBundleImageExtension)
- (nullable NSImage *)imageForResource:(NSImageName)name NS_AVAILABLE_MAC(10_7); /* May return nil if no file found */
/* Neither of the following methods can return images with multiple representations in different files (for example, MyImage.png and [email protected].) The above method is generally prefered.
*/
- (nullable NSString *)pathForImageResource:(NSImageName)name; /* May return nil if no file found */
- (nullable NSURL *)URLForImageResource:(NSImageName)name NS_AVAILABLE_MAC(10_6); /* May return nil if no file found */
@end
@interface NSImage (NSDeprecated)
// the concept of flippedness for NSImage is deprecated. Please see the AppKit 10.6 release notes for a discussion of why, and for how to replace existing usage.
- (void)setFlipped:(BOOL)flag NS_DEPRECATED_MAC(10_0, 10_6);
- (BOOL)isFlipped NS_DEPRECATED_MAC(10_0, 10_6);
// these methods have surprising semantics. Prefer to use the 'draw' methods (and note the new draw method taking respectContextIsFlipped as a parameter). Please see the AppKit 10.6 release notes for exactly what's going on.
- (void)dissolveToPoint:(NSPoint)point fraction:(CGFloat)fraction NS_DEPRECATED_MAC(10_0, 10_6, "Use -drawAtPoint:... or -drawInRect:... methods instead");
- (void)dissolveToPoint:(NSPoint)point fromRect:(NSRect)rect fraction:(CGFloat)fraction NS_DEPRECATED_MAC(10_0, 10_6, "Use -drawAtPoint:... or -drawInRect:... methods instead");
- (void)compositeToPoint:(NSPoint)point operation:(NSCompositingOperation)op NS_DEPRECATED_MAC(10_0, 10_6, "Use -drawAtPoint:... or -drawInRect:... methods instead");
- (void)compositeToPoint:(NSPoint)point fromRect:(NSRect)rect operation:(NSCompositingOperation)op NS_DEPRECATED_MAC(10_0, 10_6, "Use -drawAtPoint:... or -drawInRect:... methods instead");
- (void)compositeToPoint:(NSPoint)point operation:(NSCompositingOperation)op fraction:(CGFloat)delta NS_DEPRECATED_MAC(10_0, 10_6, "Use -drawAtPoint:... or -drawInRect:... methods instead");
- (void)compositeToPoint:(NSPoint)point fromRect:(NSRect)rect operation:(NSCompositingOperation)op fraction:(CGFloat)delta NS_DEPRECATED_MAC(10_0, 10_6, "Use -drawAtPoint:... or -drawInRect:... methods instead");
// this method doesn't do what people expect. See AppKit 10.6 release notes. Briefly, you can replace invocation of this method with code that locks focus on the image and then draws the rep in the image.
- (void)lockFocusOnRepresentation:(null_unspecified NSImageRep *)imageRepresentation NS_DEPRECATED_MAC(10_0, 10_6, "Use -lockFocus followed by -[NSImageRep drawInRect:] instead. See documentation for more info.");
// these methods have to do with NSImage's caching behavior. You should be able to remove use of these methods without any replacement. See 10.6 AppKit release notes for details.
- (void)setScalesWhenResized:(BOOL)flag NS_DEPRECATED_MAC(10_0, 10_6);
- (BOOL)scalesWhenResized NS_DEPRECATED_MAC(10_0, 10_6);
- (void)setDataRetained:(BOOL)flag NS_DEPRECATED_MAC(10_0, 10_6);
- (BOOL)isDataRetained NS_DEPRECATED_MAC(10_0, 10_6);
- (void)setCachedSeparately:(BOOL)flag NS_DEPRECATED_MAC(10_0, 10_6);
- (BOOL)isCachedSeparately NS_DEPRECATED_MAC(10_0, 10_6);
- (void)setCacheDepthMatchesImageDepth:(BOOL)flag NS_DEPRECATED_MAC(10_0, 10_6);
- (BOOL)cacheDepthMatchesImageDepth NS_DEPRECATED_MAC(10_0, 10_6);
@end
#pragma mark - Standard images
/* Standard images.
Most images are named by a specific function or situation where they are intended to be used. In some cases, the artwork may be more generic than the name. For example, the image for NSImageNameInvalidDataFreestandingTemplate is an arrow in 10.5. Please do not use an image outside of the function for which it is intended - the artwork can change between releases. The invalid data image could change to a yellow exclamation-point-in-triangle icon. If there is no image available for the situation you're interested in, please file a bug report, and use your own custom art in the meantime.
The size of an image is also not guaranteed to be the same (or maintain the same aspect ratio) between releases, so you should explcitly size the image appropriately for your use.
Constants that end in the word "Template" name black and clear images that return YES for isTemplate. These images can be processed into variants appropriate for different situations. For example, these images can invert in a selected table view row. See -[NSImage setTemplate:] for more comments. These images are inappropriate for display without further processing, but NSCell and its subclasses will perform the processing.
Some images also contain the word "Freestanding". This indicates that an image is appropriate for use as a borderless button - it doesn't need any extra bezel artwork behind it. For example, Safari uses NSImageNameStopProgressTemplate as the stop button in a button on its toolbar, while it uses NSImageNameStopProgressFreestandingTemplate in the downloads window where it appears inline with a progress indicator.
The string value of each symbol is typically the same as the constant name without the "ImageName" part. For example, NSImageNameBonjour is @"NSBonjour". This is documented so that images can be used by name in Interface Builder.
*/
APPKIT_EXTERN NSImageName const NSImageNameAddTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameBluetoothTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameBonjour NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameBookmarksTemplate NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameCaution NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameComputer NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameEnterFullScreenTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameExitFullScreenTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameFolder NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameFolderBurnable NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameFolderSmart NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameFollowLinkFreestandingTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameHomeTemplate NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameIChatTheaterTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameLockLockedTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameLockUnlockedTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameNetwork NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNamePathTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameQuickLookTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameRefreshFreestandingTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameRefreshTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameRemoveTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameRevealFreestandingTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameShareTemplate NS_AVAILABLE_MAC(10_8);
APPKIT_EXTERN NSImageName const NSImageNameSlideshowTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameStatusAvailable NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameStatusNone NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameStatusPartiallyAvailable NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameStatusUnavailable NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameStopProgressFreestandingTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameStopProgressTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameTrashEmpty NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameTrashFull NS_AVAILABLE_MAC(10_6);
/* This image is appropriate on an 'action' button. An action button is a popup that has the same contents as the contextual menu for a related control.
*/
APPKIT_EXTERN NSImageName const NSImageNameActionTemplate NS_AVAILABLE_MAC(10_5);
/* This image can be used as a badge for a 'smart' item. In 10.5, this and the 'action' image are both gears. Please avoid using a gear for other situations, and if you do, use custom art.
*/
APPKIT_EXTERN NSImageName const NSImageNameSmartBadgeTemplate NS_AVAILABLE_MAC(10_5);
/* These images are intended for use in a segmented control for switching view interfaces for another part of the window.
*/
APPKIT_EXTERN NSImageName const NSImageNameIconViewTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameListViewTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameColumnViewTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameFlowViewTemplate NS_AVAILABLE_MAC(10_5);
/* Place this image to the right of invalid data. For example, use it if the user tries to commit a form when it's missing a required name field.
*/
APPKIT_EXTERN NSImageName const NSImageNameInvalidDataFreestandingTemplate NS_AVAILABLE_MAC(10_5);
/* Use these images for "go forward" or "go back" functions, as seen in Safari's toolbar. These images will automatically mirror when the user interface layout direction is right to left.
*/
APPKIT_EXTERN NSImageName const NSImageNameGoForwardTemplate NS_AVAILABLE_MAC(10_12);
APPKIT_EXTERN NSImageName const NSImageNameGoBackTemplate NS_AVAILABLE_MAC(10_12);
/* These images are like GoForward and GoBack except that they always point in the specified direction regardless of layout direction. See also the right and left facing triangle images.
*/
APPKIT_EXTERN NSImageName const NSImageNameGoRightTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameGoLeftTemplate NS_AVAILABLE_MAC(10_5);
/* Prefer the GoForward and GoBack or GoLeft and GoRight images for situations where they apply. These generic triangles aren't endorsed for any particular use, but you can use them if you don't have any better art.
*/
APPKIT_EXTERN NSImageName const NSImageNameRightFacingTriangleTemplate NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameLeftFacingTriangleTemplate NS_AVAILABLE_MAC(10_5);
/* NSImageNameDotMac will continue to work for the forseeable future, and will return the same image as NSImageNameMobileMe.
*/
APPKIT_EXTERN NSImageName const NSImageNameDotMac NS_DEPRECATED_MAC(10_5, 10_7);
APPKIT_EXTERN NSImageName const NSImageNameMobileMe NS_AVAILABLE_MAC(10_6);
/* This image is appropriate as a drag image for multiple items.
*/
APPKIT_EXTERN NSImageName const NSImageNameMultipleDocuments NS_AVAILABLE_MAC(10_5);
/* These images are intended for use in toolbars in preference windows.
*/
APPKIT_EXTERN NSImageName const NSImageNameUserAccounts NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNamePreferencesGeneral NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameAdvanced NS_AVAILABLE_MAC(10_5);
/* These images are intended for use in other toolbars.
*/
APPKIT_EXTERN NSImageName const NSImageNameInfo NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameFontPanel NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameColorPanel NS_AVAILABLE_MAC(10_5);
/* These images are appropriate for use in sharing or permissions interfaces.
*/
APPKIT_EXTERN NSImageName const NSImageNameUser NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameUserGroup NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameEveryone NS_AVAILABLE_MAC(10_5);
APPKIT_EXTERN NSImageName const NSImageNameUserGuest NS_AVAILABLE_MAC(10_6);
/* These images are the default state images used by NSMenuItem. Drawing these outside of menus is discouraged.
*/
APPKIT_EXTERN NSImageName const NSImageNameMenuOnStateTemplate NS_AVAILABLE_MAC(10_6);
APPKIT_EXTERN NSImageName const NSImageNameMenuMixedStateTemplate NS_AVAILABLE_MAC(10_6);
/* The name @"NSApplicationIcon" has been available since Mac OS X 10.0. The symbol NSImageNameApplicationIcon is new in 10.6.
*/
APPKIT_EXTERN NSImageName const NSImageNameApplicationIcon NS_AVAILABLE_MAC(10_6);
#pragma mark - NSTouchBar images
/* These images are appropriate for use only in NSTouchBar.
*/
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAddDetailTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAddTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAlarmTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAudioInputMuteTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAudioInputTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAudioOutputMuteTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAudioOutputVolumeHighTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAudioOutputVolumeLowTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAudioOutputVolumeMediumTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarAudioOutputVolumeOffTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarBookmarksTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarColorPickerFill NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarColorPickerFont NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarColorPickerStroke NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarCommunicationAudioTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarCommunicationVideoTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarComposeTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarDeleteTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarDownloadTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarEnterFullScreenTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarExitFullScreenTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarFastForwardTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarFolderCopyToTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarFolderMoveToTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarFolderTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarGetInfoTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarGoBackTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarGoDownTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarGoForwardTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarGoUpTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarHistoryTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarIconViewTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarListViewTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarMailTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarNewFolderTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarNewMessageTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarOpenInBrowserTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarPauseTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarPlayPauseTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarPlayTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarQuickLookTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarRecordStartTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarRecordStopTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarRefreshTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarRemoveTemplate NS_AVAILABLE_MAC(10_13);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarRewindTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarRotateLeftTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarRotateRightTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSearchTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarShareTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSidebarTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSkipAhead15SecondsTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSkipAhead30SecondsTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSkipAheadTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSkipBack15SecondsTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSkipBack30SecondsTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSkipBackTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSkipToEndTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSkipToStartTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarSlideshowTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTagIconTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextBoldTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextBoxTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextCenterAlignTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextItalicTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextJustifiedAlignTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextLeftAlignTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextListTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextRightAlignTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextStrikethroughTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarTextUnderlineTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarUserAddTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarUserGroupTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarUserTemplate NS_AVAILABLE_MAC(10_12_2);
/* If you have a volume indicator, use NSImageNameTouchBarAudioOutputVolume{Off,Low,Medium,High}Template, which align the speaker correctly. For volume controls, use NSImageNameTouchBarVolume{Down,Up}Template.
*/
APPKIT_EXTERN NSImageName const NSImageNameTouchBarVolumeDownTemplate NS_AVAILABLE_MAC(10_12_2);
APPKIT_EXTERN NSImageName const NSImageNameTouchBarVolumeUpTemplate NS_AVAILABLE_MAC(10_12_2);
/* If you have an NSTouchBarItem with a seekable media control, NSImageNameTouchBarPlayheadTemplate is suitable for use in displaying the playhead.
*/
APPKIT_EXTERN NSImageName const NSImageNameTouchBarPlayheadTemplate NS_AVAILABLE_MAC(10_12_2);
NS_ASSUME_NONNULL_END
| 73.07377
| 673
| 0.834549
|
[
"render",
"transform"
] |
7f1605a78c800f2dbf14ba2962ac36729a0edd25
| 1,527
|
h
|
C
|
Engine/src/Models.h
|
IvanSoar/OpenGL
|
428a7472f36ef6583df2cf819fe22b7d2882c10b
|
[
"Apache-2.0"
] | null | null | null |
Engine/src/Models.h
|
IvanSoar/OpenGL
|
428a7472f36ef6583df2cf819fe22b7d2882c10b
|
[
"Apache-2.0"
] | null | null | null |
Engine/src/Models.h
|
IvanSoar/OpenGL
|
428a7472f36ef6583df2cf819fe22b7d2882c10b
|
[
"Apache-2.0"
] | null | null | null |
#pragma once
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <vector>
#include <string>
class rawModel {
protected:
std::vector<float> vertexData;
std::vector<unsigned int> indexData;
unsigned int vertexCount;
unsigned int indexCount;
friend class Models;
public:
rawModel(std::vector<float> vertex, std::vector<unsigned int> index, unsigned int vCount, unsigned int iCount)
: vertexData(vertex), indexData(index), vertexCount(vCount), indexCount(iCount) {}
};
class Model {
private:
unsigned int VAO;
unsigned int vertexCount;
unsigned int indexCount;
protected:
glm::vec3 position = glm::vec3(0.0f);
glm::vec3 rotation = glm::vec3(0.0f);
glm::vec3 scaleFactor = glm::vec3(1.0f);
friend class Render;
public:
Model(unsigned int vao, unsigned int vCount, unsigned int iCount)
: VAO(vao), vertexCount(vCount), indexCount(iCount) {}
void move(float dx, float dy, float dz);
void rotate(float dx, float dy, float dz);
void scale(float value);
void scale(float dx, float dy, float dz);
void setPosition(float dx, float dy, float dz);
void setRotation(float dx, float dy, float dz);
unsigned int getVAO();
unsigned int getVertexCount();
unsigned int getIndexCount();
};
class Models {
private:
std::vector<Model*> modelsList;
private:
Models() {}
static Models& get();
rawModel loadModel(const std::string& filepath);
public:
static Model* addObjModel(const std::string& filepath);
static std::vector<Model*> getModels();
};
| 22.791045
| 112
| 0.726916
|
[
"render",
"vector",
"model"
] |
7f18ae12a0956344f9b7023fa50d86a6a373d954
| 27,519
|
c
|
C
|
released_plugins/v3d_plugins/neurontracing_neutube/src_neutube/neurolabi/gui/mylib/fct.min.c
|
zzhmark/vaa3d_tools
|
3ca418add85a59ac7e805d55a600b78330d7e53d
|
[
"MIT"
] | 6
|
2017-10-25T01:15:13.000Z
|
2021-03-02T23:06:06.000Z
|
released_plugins/v3d_plugins/neurontracing_neutube/src_neutube/neurolabi/gui/mylib/fct.min.c
|
zzhmark/vaa3d_tools
|
3ca418add85a59ac7e805d55a600b78330d7e53d
|
[
"MIT"
] | 1
|
2018-07-12T11:53:54.000Z
|
2018-10-19T21:37:25.000Z
|
released_plugins/v3d_plugins/neurontracing_neutube/src_neutube/neurolabi/gui/mylib/fct.min.c
|
zzhmark/vaa3d_tools
|
3ca418add85a59ac7e805d55a600b78330d7e53d
|
[
"MIT"
] | 2
|
2018-03-20T10:49:58.000Z
|
2019-07-10T13:32:39.000Z
|
#ifdef _MSC_VER
#pragma warning( disable:4996 )
#ifndef __cplusplus
#define inline __inline
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
// WINDOW pthreads "LIBRARY"
// Mutex macros
typedef SRWLOCK pthread_mutex_t;
#define PTHREAD_MUTEX_INITIALIZER RTL_SRWLOCK_INIT
#define pthread_mutex_lock(m) AcquireSRWLockExclusive(m)
#define pthread_mutex_unlock(m) ReleaseSRWLockExclusive(m)
// Condition variable macros
typedef CONDITION_VARIABLE pthread_cond_t;
#define PTHREAD_COND_INITIALIZER RTL_CONDITION_VARIABLE_INIT
#define pthread_cond_signal(c) WakeConditionVariable(c)
#define pthread_cond_broadcast(c) WakeAllConditionVariable(c)
#define pthread_cond_wait(c,m) SleepConditionVariableSRW(c,m,INFINITE,0)
// Simple thread support
typedef struct
{ HANDLE *handle;
void *(*fct)(void *);
void *arg;
void *retval;
int id;
} Mythread;
typedef Mythread *pthread_t;
static DWORD WINAPI MyStart(void *arg)
{ Mythread *tv = (Mythread *) arg;
tv->retval = tv->fct(tv->arg);
return (0);
}
static int pthread_create(pthread_t *thread, void *attr,
void *(*fct)(void *), void *arg)
{ Mythread *tv;
if (attr != NULL)
{ fprintf(stderr,"Do not support thread attributes\n");
exit (1);
}
tv = (Mythread *) malloc(sizeof(Mythread));
if (tv == NULL)
{ fprintf(stderr,"pthread_create: Out of memory.\n");
exit (1);
};
tv->fct = fct;
tv->arg = arg;
tv->handle = CreateThread(NULL,0,MyStart,tv,0,&tv->id);
if (tv->handle == NULL)
return (EAGAIN);
else
return (0);
}
static int pthread_join(pthread_t t, void **ret)
{ Mythread *tv = (Mythread *) t;
WaitForSingleObject(tv->handle,INFINITE);
if (ret != NULL)
*ret = tv->retval;
CloseHandle(tv->handle);
free(tv);
return (0);
}
typedef int pthread_id;
static pthread_id pthread_tag()
{ return (GetCurrentThreadId()); }
static int pthread_is_this(pthread_id id)
{ return (GetCurrentThreadId() == id); }
#else // Small extension to pthreads!
#include <pthread.h>
typedef pthread_t pthread_id;
#define pthread_tag() pthread_self()
static inline int pthread_is_this(pthread_id id)
{ return (pthread_equal(pthread_self(),id)); }
#endif
/*****************************************************************************************\
* *
* Function minimization routines for 1 and multiple dimensions *
* *
* Author: Gene Myers *
* Date : May 2007 *
* *
* (c) June 19, '09, Dr. Gene Myers and Howard Hughes Medical Institute *
* Copyrighted as per the full copy in the associated 'README' file *
* *
\*****************************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>
#include "utilities.h"
#include "fct.min.h"
#undef SHOW_MINIMIZATION
#undef SHOW_MULTI_MIN
#define ITMAX 100 // Maximum # of iterations
#define CGOLD 0.381966011250105 // The Golden Ratio (to DBL_DIG = 15 digits)
#define TINY 1e-20 // Minimum fractional accuracy
#define RND 1.00000001 // Rounding error in a half precision add
#define TOL .00000001 // For doubles, cannot generally hope for more
// than half-precision = 7.5 digits
/* ONE-DIMENSIONAL MINIMIZATION:
Find_Min_Bracket: find a bracket enclosing a minimum
find_min_bracket: find a bracket enclosing a minimum (takes argument bundle)
Minimize_Function: general entry point for finding a minimum
min_fct_nod: find a minimum using parabolic acceleration of Golden sections
min_fct_wd: find a minimum using derivative driven bisection
*/
typedef struct
{ double (*f)(double);
double (*df)(double);
} Pack1;
static double f1(double x, void *pack)
{ return (((Pack1 *) pack)->f(x)); }
static double df1(double x, void *pack)
{ return (((Pack1 *) pack)->df(x)); }
static Minimum_Bundle *find_min_bracket(Minimum_Bundle *R(M(brack)), double p, double s,
double (*f)(double,void *), void *pack)
{ double a, b, c, u;
double fa, fb, fc, fu;
double gstep, gratio;
int swap, iter;
a = p;
b = p + s;
fa = (*f)(a,pack); // Swap a and b if necessary so that b is downhill of a
fb = (*f)(b,pack);
if (fb >= fa)
{ u = a; fu = fa;
a = b; fa = fb;
b = u; fb = fu;
}
swap = (b < a); // Have to reverse a,b,c in final answer?
gratio = 2.-CGOLD;
gstep = gratio * (b-a); // Always keep track of the last (and largest Golden ratio step)
c = b + gstep; // Take a first step
fc = (*f)(c,pack);
#ifdef SHOW_MINIMIZATION
printf("\n 0: % 17.14e % 17.14e % 17.14e\n",a,b,c);
printf(" % 17.14e > % 17.14e > % 17.14e\n",fa,fb,fc);
#endif
for (iter = 1; iter < 100; iter++)
if (fc > fb) // If f(a) > f(b) < f(c) then your done
{ if (swap)
{ brack->lft = c;
brack->rgt = a;
}
else
{ brack->lft = a;
brack->rgt = c;
}
brack->mid = b;
return (brack);
}
else
{ double r, q, p;
int gold;
#ifdef SHOW_MINIMIZATION
printf("\n%3d: % 17.14e % 17.14e % 17.14e\n",iter,a,b,c);
printf(" % 17.14e > % 17.14e > % 17.14e\n",fa,fb,fc);
#endif
gold = 0;
r = (b-a)*(fb-fc); // NB: r and q have the same sign
q = (b-c)*(fb-fa);
#ifdef SHOW_MINIMIZATION
printf("\n q = %17.14e, r = %17.14e\n",q,r);
#endif
if ((q-r)/q > TOL) // => |q| > |r| (so parabolic step finds a minimum in correct
{ p = (b-a)*r - (b-c)*q; // direction) and cancelation in denominator is under control
q = 2.0*(q-r);
u = b + p/q; // u is the parabolic step for a,b,c
fu = (*f)(u,pack);
#ifdef SHOW_MINIMIZATION
printf(" p/q = %17.14e, u = %17.14e, fu = %17.14e\n",p/q,u,fu);
#endif
if ((b < u) == (u < c)) // u is between b and c?
{ if (fu < fc) // [b,u,c] is a bracket
{ a = b; fa = fb;
b = u; fb = fu;
#ifdef SHOW_MINIMIZATION
printf(" f(b) > f(u) < f(c)\n");
#endif
}
else if (fu > fb) // [a,b,u] is a bracket
{ c = u; fu = fc;
#ifdef SHOW_MINIMIZATION
printf(" f(a) > f(b) < f(u)\n");
#endif
}
else // No luck, take a Golden ratio step
gold = 1;
}
else if ((c < u) == (u < c + 100.*(c-b))) // u is between c and jump limit?
{ if (fu >= fc) // [b,c,u] is a bracket
{ a = b; fa = fb;
b = c; fb = fc;
c = u; fc = fu;
#ifdef SHOW_MINIMIZATION
printf(" f(b) > f(c) < f(u)\n");
#endif
}
else // try [c,u,u+gstep] as the next bracket
{ a = c; fa = fc; // note carefully that we only project forward
b = u; fb = fu; // gstep beyond the potential minimum u as we
c = u+gstep; // may otherwise overshoot by starting to use
fc = (*f)(c,pack); // too big a step size
#ifdef SHOW_MINIMIZATION
printf(" Jump to u + gstep(%17.14e)\n",gstep);
#endif
}
}
else // jump is too big or parabolic step not possible:
gold = 1; // take a Golden ratio step
}
else
gold = 1;
if (gold) // Actually take a Golden ratio step
{ gstep = gratio * (c-b);
a = b; fa = fb;
b = c; fb = fc;
c = b + gstep;
fc = (*f)(c,pack);
#ifdef SHOW_MINIMIZATION
printf(" Gold: c = %17.14e, fc = %17.14e\n",c,fc);
#endif
}
}
fprintf(stderr,"Warning: Find_Min_Bracket did not find a bracket in %d iteratios\n",ITMAX);
return (NULL);
}
Minimum_Bundle *Find_Min_Bracket(Minimum_Bundle *R(M(brack)),
double p, double s, double (*f)(double))
{ Pack1 pack;
pack.f = f;
find_min_bracket(brack,p,s,f1,&pack);
return (brack);
}
static double min_fct_nod(Minimum_Bundle *brack, double (*f)(double, void *),
double *xmin, void *pack)
{
double a, c; // Current bracket [a,c]
double x, y, z; // Lowest f(x) < f(y) < f(z) with x in [a,c]
double fx, fy, fz; // function values at x, y, and z
double d, e; // step in iteration (d), and the one before (e)
int iter;
a = brack->lft;
c = brack->rgt;
x = y = z = brack->mid; // 1st two iterations will be Golden ratio divisions, so y and z
fx = fy = fz = (*f)(x,pack); // will not be used, nor will e or d, until they have been set
d = e = 0.;
for (iter = 1; iter <= ITMAX; iter++)
{ double rel, rle;
double u, fu;
int gold;
#ifdef SHOW_MINIMIZATION
printf("\n%3d: [ % 17.14e , % 17.14e ]\n",iter,a,c);
printf(" % 17.14e % 17.14e % 17.14e\n",x,y,z);
printf(" % 17.14e < % 17.14e < % 17.14e\n",fx,fy,fz);
#endif
rel = TOL*fabs(x) + TINY; // Absolute error
rle = RND*rel;
if (x-a <= rle && c-x <= rle) // Termination: bracket within absolute error of x
{ *xmin = x; // on both sides.
return (fx);
}
gold = 1;
if (iter > 2 && fabs(e) > rle) // Try parabolic fit only if displacement will be
{ double p, q, r; // larger than rel and initialization is over
r = (x-y)*(fx-fz);
q = (x-z)*(fx-fy);
p = (x-z)*q - (x-y)*r;
q = 2.0*(r-q); // Parabolic displacement is p/q if q is not 0.
#ifdef SHOW_MINIMIZATION
printf("\n p/q = %17.14e, |q/r| = %17.14e, |e| = %17.14e\n",
p/q,fabs(q/r),fabs(e));
#endif
if (fabs(q/r) >= TOL) // Not nearly colinear, can try parabolic
{ r = d;
d = p/q;
u = x+d;
if (fabs(d/e) < 0.5 && a < u && u < c) // Point is inside bracket and
{ double drl = 2.0*rel; // step size is converging
#ifdef SHOW_MINIMIZATION
q = d;
#endif
gold = 0; // If x and the bracket point in the direction of the
if (d < 0) // jump are less than rel apart then jump rel the
{ p = x-a; // *other* way, if they are less than 2*rel apart then
if (p < rel) // jump half-way between, and otherwise make sure the
d = rel; // new point is at least rel from both x and the bracket.
else if (p < drl)
d = -p/2.0;
else if (u < a+rel)
d = rel - p;
else if (d > -rel)
d = -rel;
}
else
{ p = c-x;
if (p < rel)
d = -rel;
else if (p < drl)
d = p/2.0;
else if (u > c-rel)
d = p - rel;
else if (d < rel)
d = rel;
}
u = x+d;
e = r;
#ifdef SHOW_MINIMIZATION
if (q != d)
printf(" Adjusted d from %17.14e to %17.14e\n",q,d);
printf(" QUAD STEP: %17.14e\n",d);
#endif
}
}
}
if (gold) // Golden ratio division
{ u = x-a;
e = c-x;
if (u >= e)
e = -u;
d = CGOLD*e;
u = x+d;
#ifdef SHOW_MINIMIZATION
printf(" GOLD STEP: %17.14e\n",d);
#endif
}
fu = (*f)(u,pack);
#ifdef SHOW_MINIMIZATION
printf(" u = %17.14e, fu = %17.14e\n",u,fu);
#endif
if (fu <= fx) // Update bracket [a,x,c], and 3 minimums, x,y,z, and their values
{ if (u >= x) // fx,fy,fz with respect to the new point u.
a = x;
else
c = x;
z = y; fz = fy;
y = x; fy = fx;
x = u; fx = fu;
#ifdef SHOW_MINIMIZATION
printf(" Shift z <- y <- x <- u\n");
#endif
}
else
{ if (u < x)
a = u;
else
c = u;
if (iter <= 1 || fu <= fy)
{ z = y; fz = fy;
y = u; fy = fu;
#ifdef SHOW_MINIMIZATION
printf(" Shift z <- y <- u\n");
#endif
}
else if (iter <= 2 || fu <= fz)
{ z = u; fz = fu;
#ifdef SHOW_MINIMIZATION
printf(" Shift z <- u\n");
#endif
}
}
}
fprintf(stderr,"Warning: Too many iterations (%d) in Minimize_Fct (no derivative)\n",ITMAX);
*xmin = x;
return (fx);
}
static double min_fct_wd(Minimum_Bundle *brack, double (*f)(double, void *),
double (*df)(double, void *), double *xmin, void *pack)
{
double a, c; // Current bracket [a,c]
double x, y, z; // Lowest f(x) < f(y) < f(z) with x in [a,c]
double fx, fy, fz; // function values at x, y, and z
double dx, dy, dz; // derivative values at fx, fy, and fz
double d, e; // step in iteration (d), and the one before (e)
double fatstep;
int iter;
a = brack->lft;
c = brack->rgt;
x = y = z = brack->mid; // 1st two iterations will be Golden ratio divisions, so y and z
fx = fy = fz = (*f)(x,pack); // will not be used, nor will e or d, until they have been set
dx = dy = dz = (*df)(x,pack);
fatstep = 2.0*(c-a);
d = e = 0.;
for (iter = 1; iter <= ITMAX; iter++)
{ double rel, rle;
double u, fu, du;
int bisect;
#ifdef SHOW_MINIMIZATION
printf("\n%3d: [ % 17.14e , % 17.14e ]\n",iter,a,c);
printf(" % 17.14e % 17.14e % 17.14e\n",x,y,z);
printf(" % 17.14e < % 17.14e < % 17.14e\n",fx,fy,fz);
#endif
rel = TOL*fabs(x) + TINY; // Absolute error
rle = RND*rel;
if (x-a <= rle && c-x <= rle) // Termination: bracket within absolute error of x
{ *xmin = x; // on both sides.
return (fx);
}
bisect = 1;
if (iter > 2 && fabs(e) > rle) // Try secant method only if displacement will be
{ double d1, d2; // larger than rel and initialization is over
int ok1, ok2;
d1 = d2 = fatstep;
if (dy != dx)
d1 = (y-x)*dx/(dx-dy);
if (dz != dx)
d2 = (z-x)*dx/(dx-dz);
if (dx < 0)
{ ok1 = (d1 >= 0.0 && x + d1 <= c);
ok2 = (d2 >= 0.0 && x + d2 <= c);
}
else
{ ok1 = (d1 <= 0.0 && x + d1 >= a);
ok2 = (d2 <= 0.0 && x + d2 >= a);
}
#ifdef SHOW_MINIMIZATION
printf("\n d1 = %17.14e(%d), d2 = %17.14e(%d)\n",d1,ok1,d2,ok2);
#endif
if (ok1 || ok2)
{ double r, p;
r = d;
if (fabs(d1/d2) < 1.0)
d = d1;
else
d = d2;
if (fabs(d/e) <= 0.5)
{ double drl = 2.0*rel;
#ifdef SHOW_MINIMIZATION
double q = d;
#endif
u = x+d;
bisect = 0; // If x and the bracket point in the direction of the
if (d < 0) // jump are less than rel apart then jump rel the
{ p = x-a; // *other* way, if they are less than 2*rel apart then
if (p < rel) // jump half-way between, and otherwise make sure the
d = rel; // new point is at least rel from both x and the bracket.
else if (p < drl)
d = -p/2.0;
else if (u < a+rel)
d = rel - p;
else if (d > -rel)
d = -rel;
}
else
{ p = c-x;
if (p < rel)
d = -rel;
else if (p < drl)
d = p/2.0;
else if (u > c-rel)
d = p - rel;
else if (d < rel)
d = rel;
}
u = x+d;
e = r;
#ifdef SHOW_MINIMIZATION
if (q != d)
printf(" Adjusted d from %17.14e to %17.14e\n",q,d);
printf(" DERIVATIVE STEP: %17.14e\n",d);
#endif
}
}
}
if (bisect) // Bisection based on derivative dx
{ e = c-x;
if (dx >= 0 || e < rel) // Careful do not bisect something too small!
e = a-x;
d = 0.5*e;
u = x+d;
#ifdef SHOW_MINIMIZATION
printf(" BISECTION STEP: %17.14e\n",d);
#endif
}
fu = (*f)(u,pack); // Update bracket [a,x,c], and 3 minimums, x,y,z, and their values
du = (*df)(u,pack); // fx,fy,fz and derivatives dx,dy,dz with respect to the new point u.
#ifdef SHOW_MINIMIZATION
printf(" u = %17.14e, fu = %17.14e, du = %17.14e\n",u,fu,du);
#endif
if (fu <= fx)
{ if (u >= x)
a = x;
else
c = x;
z = y; fz = fy; dz = dy;
y = x; fy = fx; dy = dx;
x = u; fx = fu; dx = du;
#ifdef SHOW_MINIMIZATION
printf(" Shift z <- y <- x <- u\n");
#endif
}
else
{ if (u < x)
a = u;
else
c = u;
if (iter <= 1 || fu <= fy)
{ z = y; fz = fy; dz = dy;
y = u; fy = fu; dy = du;
#ifdef SHOW_MINIMIZATION
printf(" Shift z <- y <- u\n");
#endif
}
else if (iter <= 2 || fu <= fz)
{ z = u; fz = fu; dz = du;
#ifdef SHOW_MINIMIZATION
printf(" Shift z <- u\n");
#endif
}
}
}
fprintf(stderr,"Warning: Too many iterations (%d) in Minimize_Fct (with derivative)\n",ITMAX);
*xmin = x;
return (fx);
}
double Minimize_Fct(Minimum_Bundle *brack, double (*f)(double), double (*df)(double))
{ Pack1 pack;
double a;
pack.f = f;
pack.df = df;
if (df == NULL)
min_fct_nod(brack,f1,&a,&pack);
else
min_fct_wd(brack,f1,df1,&a,&pack);
return (a);
}
/* LINE MINIMIZATION ROUTINES:
init_line_min: Setup storage and global vars for dimension, function, and gradient thereof
line_min_nod: Do a line minimization without derivative
line_min_wd: Do a line minimization with derivative
f1dim: Evaluate function at scalar position along current line
df1dim: Evaluate derivative at scalar position along current line in direction of said
*/
#ifdef SHOW_MULTI_MIN
static void print_vector(Dimn_Type n, double *vec)
{ Dimn_Type j;
printf("(%.14g",vec[0]);
for (j = 1; j < n; j++)
printf(",%.14g",vec[j]);
printf(")");
}
#endif
// Global vars for tricking 1d routines into minimizing along a line
typedef struct
{ double (*f)(double *);
double *(*df)(double *, double *);
int n;
double *pl;
double *gl;
double *dir;
double *pc;
} PackN;
static double f1dim(double x, void *pack) // evaluate pack->f at pack->pc + x*pack->dir
{ PackN *p = (PackN *) pack;
int i;
for (i = 0; i < p->n; i++)
p->pl[i] = p->pc[i] + x*p->dir[i];
return ((*p->f)(p->pl));
}
static double df1dim(double x, void *pack) // evaluate d(pack->f)/d(pack->dir)
{ PackN *p = (PackN *) pack; // at pack->pc + x*pack->dir
double *gd, df;
int i;
(void) x; // x is ignored, always the same as last call to f1dim!
gd = (*p->df)(p->pl,p->gl);
df = 0.;
for (i = 0; i < p->n; i++)
df += gd[i]*p->dir[i];
return (df);
}
/* MULTI-DIMENSIONAL MINIMIZATION:
Powell_Minimizer: find a multi-dimensional min using line minimization on a set of
direction vectors that are evolved to be mutually conjugate
Polak_Rabier_Minimizer: find a multi-dimensional min using conjugate gradient descent
*/
Double_Vector *Powell_Minimizer(Double_Vector *R(M(xinit)), double step, double (*f)(double *))
{ double Fvec[ 40], *vec;
double Fmat[100], *mat;
double *Fdir[ 10], **dir;
PackN pack;
double *av, *pi, *pe, *pl;
double *pc;
double fi, fc, fe;
int iter;
Dimn_Type n;
n = xinit->dims[0];
if (xinit->type != FLOAT64_TYPE || xinit->ndims != 1)
{ fprintf(stderr,"xinit is not a 1D double array (Powell_Minimizer)\n");
exit (1);
}
if (n > 10)
{ vec = (double *) Guarded_Malloc((sizeof(double)*((size_t) (4+n)) + sizeof(double *)) *
((size_t) n),"Powell_Minimizer");
mat = vec + 4*n;
dir = (double **) (mat + n*n);
}
else
{ vec = Fvec;
mat = Fmat;
dir = Fdir;
}
pi = vec;
pe = pi+n;
av = pe+n;
pl = av+n;
{ double *d; // make a matrix of initial direction vectors of size step
Indx_Type i, s;
s = n*n;
d = mat;
for (i = 0; i < s; i++)
d[i] = 0.;
for (i = 0; i < s; i += n+1)
d[i] = step;
for (i = 0; i < n; i++)
{ dir[i] = d;
d += n;
}
}
pc = AFLOAT64(xinit);
fc = (*f)(pc);
#ifdef SHOW_MULTI_MIN
printf(" FC");
print_vector(n,pc);
printf(" = %.14g\n",fc);
#endif
pack.f = f;
pack.n = n;
pack.pc = pc;
pack.pl = pl;
for (iter = 1; iter <= ITMAX; iter++)
{ double dmax;
Dimn_Type imax;
Dimn_Type i;
for (i = 0; i < n; i++)
pi[i] = pc[i];
fi = fc;
#ifdef SHOW_MULTI_MIN
printf("\n");
#endif
imax = 0;
dmax = 0.0;
for (i = 0; i < n; i++)
{ double fn, xmin, *e;
Minimum_Bundle brack;
Dimn_Type j;
pack.dir = e = dir[i];
find_min_bracket(&brack,0.0,0.1,f1dim,&pack); // This could fail!
fn = min_fct_nod(&brack,f1dim,&xmin,&pack);
for (j = 0; j < n; j++)
pc[j] = pc[j] + xmin*e[j];
#ifdef SHOW_MULTI_MIN
printf(" MIN %d ",i);
print_vector(n,dir[i]);
printf(" -> ");
print_vector(n,pc);
printf(" f = %.14g\n",fn);
#endif
if (fc-fn > dmax)
{ dmax = fc-fn;
imax = i;
}
fc = fn;
}
#ifdef SHOW_MULTI_MIN
printf(" dmax = %.14g(%d)\n",dmax,imax);
#endif
if (fi-fc <= TOL*fabs(fc)+TINY)
{ if (n > 10)
free(vec);
return (xinit);
}
for (i = 0; i < n; i++)
{ pe[i] = 2.0*pc[i] - pi[i];
av[i] = pc[i] - pi[i];
}
fe = (*f)(pe);
#ifdef SHOW_MULTI_MIN
printf(" FE");
print_vector(n,pe);
printf(" = %.14g\n",fe);
#endif
if (fe < fi && dmax > (n+1.0)*(fi-fc)/(2.0*n) && (fc-fe) < 0.25*(fi-fc))
{ double *tmp, xmin;
Minimum_Bundle brack;
Dimn_Type j;
pack.dir = av;
find_min_bracket(&brack,0.0,0.1,f1dim,&pack); // This could fail!
fc = min_fct_nod(&brack,f1dim,&xmin,&pack);
for (j = 0; j < n; j++)
pc[j] = pc[j] + xmin*av[j];
#ifdef SHOW_MULTI_MIN
printf(" AV_MIN ");
print_vector(n,av);
printf(" -> ");
print_vector(n,pc);
printf(" f = %.14g\n",fc);
#endif
tmp = dir[imax];
dir[imax] = dir[n-1];
dir[n-1] = av;
av = tmp;
}
}
fprintf(stderr,"Warning: Too many iterations (%d) in Powell_Minimizer\n",ITMAX);
if (n > 10)
free(vec);
return (xinit);
}
Double_Vector *Polak_Rabier_Minimizer(Double_Vector *R(M(xinit)),
double (*f) (double *x),
double *(*df)(double *, double *R(O(g))))
{ double Fh[40], *h, *g, *pl, *gl;
PackN pack;
double *pc;
double fc;
double *dc;
int iter;
Dimn_Type j, n;
n = xinit->dims[0];
if (xinit->type != FLOAT64_TYPE || xinit->ndims != 1)
{ fprintf(stderr,"xinit is not a 1D double array (Powell_Minimizer)\n");
exit (1);
}
if (n > 10)
h = (double *) Guarded_Malloc(sizeof(double)*4*((size_t) n),"Polak_Rabier_Minimizer");
else
h = Fh;
g = h+n;
pl = g+n;
gl = pl+n;
pc = AFLOAT64(xinit);
fc = (*f)(pc);
dc = (*df)(pc,gl);
for (j = 0; j < n; j++)
h[j] = g[j] = -dc[j];
#ifdef SHOW_MULTI_MIN
printf(" FC");
print_vector(n,pc);
printf(" = %.14g (",fc);
print_vector(n,dc);
printf("\n");
#endif
pack.f = f;
pack.df = df;
pack.n = n;
pack.pc = pc;
pack.pl = pl;
pack.gl = gl;
pack.dir = h;
for (iter = 1; iter <= ITMAX; iter++)
{ double fn, xmin;
Minimum_Bundle brack;
Dimn_Type j;
double num, den, gam;
find_min_bracket(&brack,0.0,0.1,f1dim,&pack); // This could fail!
fn = min_fct_wd(&brack,f1dim,df1dim,&xmin,&pack);
for (j = 0; j < n; j++)
pc[j] = pc[j] + xmin*h[j];
#ifdef SHOW_MULTI_MIN
printf(" MIN %d ",iter);
print_vector(n,h);
printf(" -> ");
print_vector(n,pc);
printf(" f = %.14g\n",fn);
#endif
if (fn-fc <= TOL*fabs(fc)+TINY)
{ if (n > 10)
free(h);
return (xinit);
}
fc = fn;
dc = (*df)(pc,gl);
num = den = 0.;
for (j = 0; j < n; j++)
{ num += g[j] * g[j];
den += h[j] * (h[j] + g[j]);
}
if (den == 0.0)
{ if (n > 10)
free(h);
return (xinit);
}
gam = num/den;
for (j = 0; j < n; j++)
{ g[j] = -dc[j];
h[j] = g[j] + gam*h[j];
}
}
fprintf(stderr,"Warning: Too many iterations (%d) in Polak_Ribier_Minimzer\n",ITMAX);
if (n > 10)
free(h);
return (xinit);
}
| 29.495177
| 100
| 0.455431
|
[
"3d"
] |
7f1ac48426f7a67920f6ce6cd1bf87a1dae66162
| 672,455
|
c
|
C
|
decompiled_scripts/bj.c
|
fangshun2004/GTA-V-Decompiled-Scripts
|
5451d210700c06e9e9749e9ead2332965ddcb6b0
|
[
"Unlicense"
] | 1
|
2022-03-08T06:03:34.000Z
|
2022-03-08T06:03:34.000Z
|
decompiled_scripts/bj.c
|
fangshun2004/GTA-V-Decompiled-Scripts
|
5451d210700c06e9e9749e9ead2332965ddcb6b0
|
[
"Unlicense"
] | null | null | null |
decompiled_scripts/bj.c
|
fangshun2004/GTA-V-Decompiled-Scripts
|
5451d210700c06e9e9749e9ead2332965ddcb6b0
|
[
"Unlicense"
] | null | null | null |
#region Local Var
var uLocal_0 = 0;
var uLocal_1 = 0;
int iLocal_2 = 0;
int iLocal_3 = 0;
int iLocal_4 = 0;
int iLocal_5 = 0;
int iLocal_6 = 0;
int iLocal_7 = 0;
int iLocal_8 = 0;
int iLocal_9 = 0;
int iLocal_10 = 0;
int iLocal_11 = 0;
var uLocal_12 = 0;
var uLocal_13 = 0;
float fLocal_14 = 0f;
var uLocal_15 = 0;
var uLocal_16 = 0;
int iLocal_17 = 0;
var uLocal_18 = 0;
var uLocal_19 = 0;
char* sLocal_20 = NULL;
float fLocal_21 = 0f;
struct<3> Local_22 = { 0, 0, 0 } ;
float fLocal_25 = 0f;
float fLocal_26 = 0f;
var uLocal_27 = 0;
int iLocal_28 = 0;
var uLocal_29 = 0;
var uLocal_30 = 0;
float fLocal_31 = 0f;
float fLocal_32 = 0f;
float fLocal_33 = 0f;
var uLocal_34 = 0;
var uLocal_35 = 0;
var uLocal_36 = 0;
var uLocal_37 = 0;
var uLocal_38 = 0;
int iLocal_39 = 0;
int iLocal_40 = 0;
int iLocal_41 = 0;
int iLocal_42 = 0;
int iLocal_43 = 0;
int iLocal_44 = 0;
var uLocal_45 = 0;
var uLocal_46 = 0;
var uLocal_47 = 0;
var uLocal_48 = 0;
var uLocal_49 = 0;
var uLocal_50 = 0;
var uLocal_51 = 0;
var uLocal_52 = 0;
var uLocal_53 = 0;
var uLocal_54 = 0;
var uLocal_55 = 0;
var uLocal_56 = 0;
var uLocal_57 = 0;
var uLocal_58 = 0;
var uLocal_59 = 0;
var uLocal_60 = 0;
var uLocal_61 = 0;
var uLocal_62 = 0;
var uLocal_63 = 0;
float fLocal_64 = 0f;
var uLocal_65 = 0;
var uLocal_66 = 0;
var uLocal_67 = 0;
struct<68> Local_68 = { 0, 0, 1132396544, 1132396544, 1132396544, 0, -1082130432, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 1092616192 } ;
var uLocal_136 = 0;
var uLocal_137 = 0;
struct<3> Local_138 = { 0, 0, 0 } ;
var uLocal_141 = 0;
var uLocal_142 = 0;
var uLocal_143 = 0;
var uLocal_144 = 3;
var uLocal_145 = 0;
var uLocal_146 = 0;
var uLocal_147 = 0;
var uLocal_148 = 0;
var uLocal_149 = 0;
var uLocal_150 = 0;
var uLocal_151 = 0;
var uLocal_152 = 0;
var uLocal_153 = 0;
var uLocal_154 = 0;
var uLocal_155 = 0;
var uLocal_156 = 0;
var uLocal_157 = 0;
var uLocal_158 = 0;
var uLocal_159 = 0;
var uLocal_160 = 0;
var uLocal_161 = 0;
var uLocal_162 = 0;
var uLocal_163 = 0;
var uLocal_164 = 0;
var uLocal_165 = 0;
var uLocal_166 = 0;
var uLocal_167 = 0;
var uLocal_168 = 0;
var uLocal_169 = 0;
var uLocal_170 = 0;
var uLocal_171 = 0;
var uLocal_172 = 0;
var uLocal_173 = 0;
var uLocal_174 = 0;
var uLocal_175 = 0;
var uLocal_176 = 0;
var uLocal_177 = 0;
var uLocal_178 = 0;
var uLocal_179 = 0;
var uLocal_180 = 0;
var uLocal_181 = 0;
var uLocal_182 = 0;
var uLocal_183 = 0;
var uLocal_184 = 0;
var uLocal_185 = 0;
var uLocal_186 = 0;
var uLocal_187 = 0;
var uLocal_188 = 0;
var uLocal_189 = 0;
var uLocal_190 = 0;
var uLocal_191 = 0;
var uLocal_192 = 4;
var uLocal_193 = 0;
var uLocal_194 = 0;
var uLocal_195 = 0;
var uLocal_196 = 0;
var uLocal_197 = 0;
var uLocal_198 = 0;
var uLocal_199 = 0;
var uLocal_200 = 0;
var uLocal_201 = 0;
var uLocal_202 = 0;
var uLocal_203 = 0;
var uLocal_204 = 0;
var uLocal_205 = 0;
var uLocal_206 = 0;
var uLocal_207 = 0;
var uLocal_208 = 0;
var uLocal_209 = 0;
var uLocal_210 = 0;
var uLocal_211 = 0;
var uLocal_212 = 0;
var uLocal_213 = 0;
var uLocal_214 = 0;
var uLocal_215 = 0;
var uLocal_216 = 0;
var uLocal_217 = 0;
var uLocal_218 = 0;
var uLocal_219 = 0;
var uLocal_220 = 0;
var uLocal_221 = 0;
var uLocal_222 = 0;
var uLocal_223 = 0;
var uLocal_224 = 0;
var uLocal_225 = 0;
var uLocal_226 = 0;
var uLocal_227 = 0;
var uLocal_228 = 0;
var uLocal_229 = 0;
var uLocal_230 = 0;
var uLocal_231 = 0;
var uLocal_232 = 0;
var uLocal_233 = 0;
var uLocal_234 = 0;
var uLocal_235 = 0;
var uLocal_236 = 0;
var uLocal_237 = 0;
var uLocal_238 = 0;
var uLocal_239 = 0;
var uLocal_240 = 0;
var uLocal_241 = 0;
var uLocal_242 = 0;
var uLocal_243 = 0;
var uLocal_244 = 0;
var uLocal_245 = 0;
var uLocal_246 = 0;
var uLocal_247 = 0;
var uLocal_248 = 0;
var uLocal_249 = 0;
var uLocal_250 = 0;
var uLocal_251 = 0;
var uLocal_252 = 0;
var uLocal_253 = 0;
var uLocal_254 = 0;
var uLocal_255 = 0;
var uLocal_256 = 0;
var uLocal_257 = 2;
var uLocal_258 = 0;
var uLocal_259 = 4;
var uLocal_260 = 0;
var uLocal_261 = 0;
var uLocal_262 = 0;
var uLocal_263 = 0;
var uLocal_264 = 0;
var uLocal_265 = 0;
var uLocal_266 = 0;
var uLocal_267 = 0;
var uLocal_268 = 0;
var uLocal_269 = 0;
var uLocal_270 = 0;
var uLocal_271 = 0;
var uLocal_272 = 0;
var uLocal_273 = 0;
var uLocal_274 = 0;
var uLocal_275 = 0;
var uLocal_276 = 0;
var uLocal_277 = 0;
var uLocal_278 = 0;
var uLocal_279 = 0;
var uLocal_280 = 0;
var uLocal_281 = 0;
var uLocal_282 = 0;
var uLocal_283 = 0;
var uLocal_284 = 0;
var uLocal_285 = 0;
var uLocal_286 = 0;
var uLocal_287 = 0;
var uLocal_288 = 0;
var uLocal_289 = 0;
var uLocal_290 = 0;
var uLocal_291 = 0;
var uLocal_292 = 0;
var uLocal_293 = 0;
var uLocal_294 = 0;
var uLocal_295 = 0;
var uLocal_296 = 0;
var uLocal_297 = 0;
var uLocal_298 = 0;
var uLocal_299 = 0;
var uLocal_300 = 0;
var uLocal_301 = 0;
var uLocal_302 = 0;
var uLocal_303 = 0;
var uLocal_304 = 0;
var uLocal_305 = 0;
var uLocal_306 = 0;
var uLocal_307 = 0;
var uLocal_308 = 0;
var uLocal_309 = 0;
var uLocal_310 = 0;
var uLocal_311 = 0;
var uLocal_312 = 0;
var uLocal_313 = 0;
var uLocal_314 = 0;
var uLocal_315 = 0;
var uLocal_316 = 0;
var uLocal_317 = 0;
var uLocal_318 = 0;
var uLocal_319 = 0;
var uLocal_320 = 0;
var uLocal_321 = 0;
var uLocal_322 = 0;
var uLocal_323 = 0;
var uLocal_324 = 0;
var uLocal_325 = 4;
var uLocal_326 = 0;
var uLocal_327 = 0;
var uLocal_328 = 0;
var uLocal_329 = 0;
var uLocal_330 = 0;
var uLocal_331 = 0;
var uLocal_332 = 0;
var uLocal_333 = 0;
var uLocal_334 = 0;
var uLocal_335 = 0;
var uLocal_336 = 0;
var uLocal_337 = 0;
var uLocal_338 = 0;
var uLocal_339 = 0;
var uLocal_340 = 0;
var uLocal_341 = 0;
var uLocal_342 = 0;
var uLocal_343 = 0;
var uLocal_344 = 0;
var uLocal_345 = 0;
var uLocal_346 = 0;
var uLocal_347 = 0;
var uLocal_348 = 0;
var uLocal_349 = 0;
var uLocal_350 = 0;
var uLocal_351 = 0;
var uLocal_352 = 0;
var uLocal_353 = 0;
var uLocal_354 = 0;
var uLocal_355 = 0;
var uLocal_356 = 0;
var uLocal_357 = 0;
var uLocal_358 = 0;
var uLocal_359 = 0;
var uLocal_360 = 0;
var uLocal_361 = 0;
var uLocal_362 = 0;
var uLocal_363 = 0;
var uLocal_364 = 0;
var uLocal_365 = 0;
var uLocal_366 = 0;
var uLocal_367 = 0;
var uLocal_368 = 0;
var uLocal_369 = 0;
var uLocal_370 = 0;
var uLocal_371 = 0;
var uLocal_372 = 0;
var uLocal_373 = 0;
var uLocal_374 = 0;
var uLocal_375 = 0;
var uLocal_376 = 0;
var uLocal_377 = 0;
var uLocal_378 = 0;
var uLocal_379 = 0;
var uLocal_380 = 0;
var uLocal_381 = 0;
var uLocal_382 = 0;
var uLocal_383 = 0;
var uLocal_384 = 0;
var uLocal_385 = 0;
var uLocal_386 = 0;
var uLocal_387 = 0;
var uLocal_388 = 0;
var uLocal_389 = 0;
var uLocal_390 = 0;
var uLocal_391 = 0;
var uLocal_392 = 0;
var uLocal_393 = 0;
var uLocal_394 = 0;
var uLocal_395 = 0;
var uLocal_396 = 12;
var uLocal_397 = 0;
var uLocal_398 = 0;
var uLocal_399 = 0;
var uLocal_400 = 0;
var uLocal_401 = 0;
var uLocal_402 = 0;
var uLocal_403 = 0;
var uLocal_404 = 0;
var uLocal_405 = 0;
var uLocal_406 = 0;
var uLocal_407 = 0;
var uLocal_408 = 0;
var uLocal_409 = 0;
var uLocal_410 = 0;
var uLocal_411 = 0;
var uLocal_412 = 0;
var uLocal_413 = 0;
var uLocal_414 = 0;
var uLocal_415 = 0;
var uLocal_416 = 0;
var uLocal_417 = 0;
var uLocal_418 = 0;
var uLocal_419 = 0;
var uLocal_420 = 0;
var uLocal_421 = 0;
var uLocal_422 = 0;
var uLocal_423 = 0;
var uLocal_424 = 0;
var uLocal_425 = 0;
var uLocal_426 = 0;
var uLocal_427 = 0;
var uLocal_428 = 0;
var uLocal_429 = 0;
var uLocal_430 = 0;
var uLocal_431 = 0;
var uLocal_432 = 0;
var uLocal_433 = 0;
var uLocal_434 = 0;
var uLocal_435 = 0;
var uLocal_436 = 0;
var uLocal_437 = 0;
var uLocal_438 = 0;
var uLocal_439 = 0;
var uLocal_440 = 0;
var uLocal_441 = 0;
var uLocal_442 = 0;
var uLocal_443 = 0;
var uLocal_444 = 0;
var uLocal_445 = 0;
var uLocal_446 = 0;
var uLocal_447 = 0;
var uLocal_448 = 0;
var uLocal_449 = 0;
var uLocal_450 = 0;
var uLocal_451 = 0;
var uLocal_452 = 0;
var uLocal_453 = 0;
var uLocal_454 = 0;
var uLocal_455 = 0;
var uLocal_456 = 0;
var uLocal_457 = 0;
var uLocal_458 = 0;
var uLocal_459 = 0;
var uLocal_460 = 0;
var uLocal_461 = 0;
var uLocal_462 = 0;
var uLocal_463 = 0;
var uLocal_464 = 0;
var uLocal_465 = 0;
var uLocal_466 = 0;
var uLocal_467 = 0;
var uLocal_468 = 0;
var uLocal_469 = 0;
var uLocal_470 = 0;
var uLocal_471 = 0;
var uLocal_472 = 0;
var uLocal_473 = 0;
var uLocal_474 = 0;
var uLocal_475 = 0;
var uLocal_476 = 0;
var uLocal_477 = 0;
var uLocal_478 = 0;
var uLocal_479 = 0;
var uLocal_480 = 0;
var uLocal_481 = 0;
var uLocal_482 = 0;
var uLocal_483 = 0;
var uLocal_484 = 0;
var uLocal_485 = 0;
var uLocal_486 = 0;
var uLocal_487 = 0;
var uLocal_488 = 0;
var uLocal_489 = 0;
var uLocal_490 = 0;
var uLocal_491 = 0;
var uLocal_492 = 0;
var uLocal_493 = 0;
var uLocal_494 = 0;
var uLocal_495 = 0;
var uLocal_496 = 0;
var uLocal_497 = 0;
var uLocal_498 = 0;
var uLocal_499 = 0;
var uLocal_500 = 0;
var uLocal_501 = 0;
var uLocal_502 = 0;
var uLocal_503 = 0;
var uLocal_504 = 0;
var uLocal_505 = 0;
var uLocal_506 = 0;
var uLocal_507 = 0;
var uLocal_508 = 0;
var uLocal_509 = 0;
var uLocal_510 = 0;
var uLocal_511 = 0;
var uLocal_512 = 0;
var uLocal_513 = 0;
var uLocal_514 = 0;
var uLocal_515 = 0;
var uLocal_516 = 0;
var uLocal_517 = 0;
var uLocal_518 = 0;
var uLocal_519 = 0;
var uLocal_520 = 0;
var uLocal_521 = 0;
var uLocal_522 = 0;
var uLocal_523 = 0;
var uLocal_524 = 0;
var uLocal_525 = 0;
var uLocal_526 = 0;
var uLocal_527 = 0;
var uLocal_528 = 0;
var uLocal_529 = 0;
var uLocal_530 = 0;
var uLocal_531 = 0;
var uLocal_532 = 0;
var uLocal_533 = 0;
var uLocal_534 = 0;
var uLocal_535 = 0;
var uLocal_536 = 0;
var uLocal_537 = 0;
var uLocal_538 = 0;
var uLocal_539 = 0;
var uLocal_540 = 0;
var uLocal_541 = 0;
var uLocal_542 = 0;
var uLocal_543 = 0;
var uLocal_544 = 0;
var uLocal_545 = 0;
var uLocal_546 = 0;
var uLocal_547 = 0;
var uLocal_548 = 0;
var uLocal_549 = 0;
var uLocal_550 = 0;
var uLocal_551 = 0;
var uLocal_552 = 0;
var uLocal_553 = 0;
var uLocal_554 = 0;
var uLocal_555 = 0;
var uLocal_556 = 0;
var uLocal_557 = 0;
var uLocal_558 = 0;
var uLocal_559 = 0;
var uLocal_560 = 0;
var uLocal_561 = 0;
var uLocal_562 = 0;
var uLocal_563 = 0;
var uLocal_564 = 0;
var uLocal_565 = 0;
var uLocal_566 = 0;
var uLocal_567 = 0;
var uLocal_568 = 0;
var uLocal_569 = 0;
var uLocal_570 = 0;
var uLocal_571 = 0;
var uLocal_572 = 0;
var uLocal_573 = 0;
var uLocal_574 = 0;
var uLocal_575 = 0;
var uLocal_576 = 0;
var uLocal_577 = 3;
var uLocal_578 = 0;
var uLocal_579 = 0;
var uLocal_580 = 0;
int iLocal_581 = 0;
int iLocal_582 = 0;
int iLocal_583 = 0;
int* iLocal_584 = NULL;
var uLocal_585 = 0;
var uLocal_586 = 0;
struct<4> ScriptParam_0 = { 0, 0, 0, 0 } ;
var uScriptParam_4 = 16;
var uScriptParam_5 = 0;
var uScriptParam_6 = 0;
var uScriptParam_7 = 0;
var uScriptParam_8 = 0;
var uScriptParam_9 = 0;
var uScriptParam_10 = 0;
var uScriptParam_11 = 0;
var uScriptParam_12 = 0;
var uScriptParam_13 = 0;
var uScriptParam_14 = 0;
var uScriptParam_15 = 0;
var uScriptParam_16 = 0;
var uScriptParam_17 = 0;
var uScriptParam_18 = 0;
var uScriptParam_19 = 0;
var uScriptParam_20 = 0;
var uScriptParam_21 = 0;
var uScriptParam_22 = 0;
var uScriptParam_23 = 0;
var uScriptParam_24 = 0;
var uScriptParam_25 = 0;
var uScriptParam_26 = 0;
var uScriptParam_27 = 0;
var uScriptParam_28 = 0;
var uScriptParam_29 = 0;
var uScriptParam_30 = 0;
var uScriptParam_31 = 0;
var uScriptParam_32 = 0;
var uScriptParam_33 = 0;
var uScriptParam_34 = 0;
var uScriptParam_35 = 0;
var uScriptParam_36 = 0;
var uScriptParam_37 = 0;
var uScriptParam_38 = 0;
var uScriptParam_39 = 0;
var uScriptParam_40 = 0;
var uScriptParam_41 = 0;
var uScriptParam_42 = 0;
var uScriptParam_43 = 0;
var uScriptParam_44 = 0;
var uScriptParam_45 = 0;
var uScriptParam_46 = 0;
var uScriptParam_47 = 0;
var uScriptParam_48 = 0;
var uScriptParam_49 = 0;
var uScriptParam_50 = 0;
var uScriptParam_51 = 0;
var uScriptParam_52 = 0;
var uScriptParam_53 = 0;
var uScriptParam_54 = 0;
var uScriptParam_55 = 0;
var uScriptParam_56 = 0;
var uScriptParam_57 = 0;
var uScriptParam_58 = 0;
var uScriptParam_59 = 0;
var uScriptParam_60 = 0;
var uScriptParam_61 = 0;
var uScriptParam_62 = 0;
var uScriptParam_63 = 0;
var uScriptParam_64 = 0;
var uScriptParam_65 = 0;
var uScriptParam_66 = 0;
var uScriptParam_67 = 0;
var uScriptParam_68 = 0;
var uScriptParam_69 = 0;
var uScriptParam_70 = 0;
var uScriptParam_71 = 0;
var uScriptParam_72 = 0;
var uScriptParam_73 = 0;
var uScriptParam_74 = 0;
var uScriptParam_75 = 0;
var uScriptParam_76 = 0;
var uScriptParam_77 = 0;
var uScriptParam_78 = 0;
var uScriptParam_79 = 0;
var uScriptParam_80 = 0;
var uScriptParam_81 = 0;
var uScriptParam_82 = 0;
var uScriptParam_83 = 0;
var uScriptParam_84 = 0;
var uScriptParam_85 = 0;
var uScriptParam_86 = 0;
var uScriptParam_87 = 0;
var uScriptParam_88 = 0;
var uScriptParam_89 = 0;
var uScriptParam_90 = 0;
var uScriptParam_91 = 0;
var uScriptParam_92 = 0;
var uScriptParam_93 = 0;
var uScriptParam_94 = 0;
var uScriptParam_95 = 0;
var uScriptParam_96 = 0;
var uScriptParam_97 = 0;
var uScriptParam_98 = 0;
var uScriptParam_99 = 0;
var uScriptParam_100 = 0;
var uScriptParam_101 = 0;
var uScriptParam_102 = 0;
var uScriptParam_103 = 0;
var uScriptParam_104 = 0;
var uScriptParam_105 = 0;
var uScriptParam_106 = 0;
var uScriptParam_107 = 0;
var uScriptParam_108 = 0;
var uScriptParam_109 = 0;
var uScriptParam_110 = 0;
var uScriptParam_111 = 0;
var uScriptParam_112 = 0;
var uScriptParam_113 = 0;
var uScriptParam_114 = 0;
var uScriptParam_115 = 0;
var uScriptParam_116 = 0;
var uScriptParam_117 = 0;
var uScriptParam_118 = 0;
var uScriptParam_119 = 0;
var uScriptParam_120 = 0;
var uScriptParam_121 = 0;
var uScriptParam_122 = 0;
var uScriptParam_123 = 0;
var uScriptParam_124 = 0;
var uScriptParam_125 = 0;
var uScriptParam_126 = 0;
var uScriptParam_127 = 0;
var uScriptParam_128 = 0;
var uScriptParam_129 = 0;
var uScriptParam_130 = 0;
var uScriptParam_131 = 0;
var uScriptParam_132 = 0;
var uScriptParam_133 = 0;
var uScriptParam_134 = 0;
var uScriptParam_135 = 0;
var uScriptParam_136 = 0;
var uScriptParam_137 = 0;
var uScriptParam_138 = 0;
var uScriptParam_139 = 0;
var uScriptParam_140 = 0;
var uScriptParam_141 = 0;
var uScriptParam_142 = 0;
var uScriptParam_143 = 0;
var uScriptParam_144 = 0;
var uScriptParam_145 = 0;
var uScriptParam_146 = 0;
var uScriptParam_147 = 0;
var uScriptParam_148 = 0;
var uScriptParam_149 = 0;
var uScriptParam_150 = 0;
var uScriptParam_151 = 0;
var uScriptParam_152 = 0;
var uScriptParam_153 = 0;
var uScriptParam_154 = 0;
var uScriptParam_155 = 0;
var uScriptParam_156 = 0;
var uScriptParam_157 = 0;
var uScriptParam_158 = 0;
var uScriptParam_159 = 0;
var uScriptParam_160 = 0;
var uScriptParam_161 = 0;
var uScriptParam_162 = 0;
var uScriptParam_163 = 0;
var uScriptParam_164 = 0;
var uScriptParam_165 = 0;
var uScriptParam_166 = 0;
var uScriptParam_167 = 0;
var uScriptParam_168 = 0;
var uScriptParam_169 = 0;
#endregion
void __EntryFunction__()
{
var uVar0;
int iVar14;
int iVar15;
struct<13> Var16;
var uVar101;
var uVar107;
struct<27> Var111;
int iVar719;
int iVar720;
int iVar721;
int* iVar722;
struct<11> Var727;
var uVar866;
bool bVar872;
int iVar873;
int iVar874;
int* iVar875;
int* iVar878;
int* iVar881;
int* iVar884;
int* iVar887;
int* iVar890;
int* iVar893;
int* iVar896;
int* iVar899;
int* iVar902;
int* iVar905;
struct<3> Var908;
int* iVar911;
int* iVar914;
int* iVar917;
int* iVar920;
var uVar923;
int* iVar1088;
int* iVar1089;
int* iVar1090;
int* iVar1091;
int* iVar1092;
int iVar1093;
int iVar1094[3];
int iVar1098;
int iVar1099;
int* iVar1100;
int* iVar1101;
int iVar1102[6];
int iVar1109;
int iVar1110;
int iVar1111;
int iVar1112;
int iVar1113;
int iVar1114;
var uVar1115;
int* iVar1116;
char[] cVar1117[8];
char* sVar1118;
struct<4> Var1119;
struct<3> Var1123;
struct<3> Var1126;
struct<3> Var1129;
struct<3> Var1132;
var uVar1135;
struct<3> Var1138;
struct<3> Var1141;
var uVar1144;
var uVar1147;
float fVar1148;
var uVar1149;
var uVar1150;
var uVar1151;
float fVar1152;
int iVar1153;
int iVar1154;
int iVar1155;
int iVar1156;
int iVar1157;
int iVar1158;
int iVar1159;
bool bVar1160;
var uVar1161;
int iVar1162;
int iVar1163;
int iVar1164;
int iVar1165;
bool bVar1166;
int iVar1167;
int iVar1168;
int iVar1169;
var uVar1170;
int iVar1171;
int iVar1172;
bool bVar1173;
bool bVar1174;
int iVar1175;
bool bVar1176;
bool bVar1177;
var uVar1178;
bool bVar1179;
bool bVar1180;
bool bVar1181;
bool bVar1182;
bool bVar1183;
bool bVar1184;
bool bVar1185;
bool bVar1186;
bool bVar1187;
bool bVar1188;
bool bVar1189;
bool bVar1190;
bool bVar1191;
bool bVar1192;
bool bVar1193;
bool bVar1194;
bool bVar1195;
bool bVar1196;
int iVar1197;
struct<3> Var1198;
int iVar1201;
bool bVar1202;
iLocal_2 = 1;
iLocal_3 = 134;
iLocal_4 = 134;
iLocal_5 = 1;
iLocal_6 = 1;
iLocal_7 = 1;
iLocal_8 = 134;
iLocal_9 = 1;
iLocal_10 = 12;
iLocal_11 = 12;
fLocal_14 = 0.001f;
iLocal_17 = -1;
sLocal_20 = "NULL";
fLocal_21 = 0f;
fLocal_25 = -0.0375f;
fLocal_26 = 0.17f;
iLocal_28 = 3;
fLocal_31 = 80f;
fLocal_32 = 140f;
fLocal_33 = 180f;
iLocal_39 = 1;
iLocal_40 = 65;
iLocal_41 = 49;
iLocal_42 = 64;
fLocal_64 = ((0.05f + 0.275f) - 0.01f);
Local_138 = { 500f, 500f, 500f };
uVar0 = 13;
Var16.f_12 = 12;
uVar107 = 2;
Var111.f_3 = 8;
Var111.f_12 = 8;
Var111.f_21 = 4;
Var111.f_26.f_32 = 3;
Var111.f_26.f_36 = 1;
Var111.f_26.f_53 = 2;
Var111.f_26.f_57 = 13;
Var111.f_26.f_71 = 13;
Var111.f_26.f_280 = 13;
Var111.f_26.f_489 = 13;
Var111.f_26.f_503 = 13;
Var111.f_26.f_517 = 13;
Var111.f_26.f_531 = 13;
Var727.f_10.f_2 = 8;
Var727.f_10.f_2.f_1.f_3 = 4;
Var727.f_10.f_2.f_1.f_15.f_3 = 4;
Var727.f_10.f_2.f_1.f_15.f_15.f_3 = 4;
Var727.f_10.f_2.f_1.f_15.f_15.f_15.f_3 = 4;
Var727.f_10.f_2.f_1.f_15.f_15.f_15.f_15.f_3 = 4;
Var727.f_10.f_2.f_1.f_15.f_15.f_15.f_15.f_15.f_3 = 4;
Var727.f_10.f_2.f_1.f_15.f_15.f_15.f_15.f_15.f_15.f_3 = 4;
Var727.f_10.f_2.f_1.f_15.f_15.f_15.f_15.f_15.f_15.f_15.f_3 = 4;
iVar873 = -1;
uVar923 = 16;
iVar1088 = ScriptParam_0.f_0;
iVar1100 = ScriptParam_0.f_3;
cVar1117 = "BJ_FAIL";
sVar1118 = "";
Var1132 = { 5f, 5f, 10f };
fVar1148 = 1f;
fVar1152 = -1f;
iVar1153 = -1;
iVar1156 = -1;
bVar1160 = Global_112922.f_18967;
iVar1163 = 1;
iVar1164 = -1;
bVar1183 = false;
bVar1188 = true;
bVar1190 = false;
bVar1191 = false;
bVar1193 = true;
bVar1194 = false;
bVar1195 = false;
bVar1196 = false;
if (ENTITY::DOES_ENTITY_EXIST(ScriptParam_0.f_1))
{
iVar1098 = ScriptParam_0.f_1;
}
else
{
iVar1098 = PLAYER::GET_PLAYERS_LAST_VEHICLE();
}
bVar1194 = WEAPON::HAS_PED_GOT_WEAPON(PLAYER::PLAYER_PED_ID(), joaat("gadget_parachute"), false);
bVar1195 = PLAYER::GET_PLAYER_HAS_RESERVE_PARACHUTE(PLAYER::PLAYER_ID());
if (bVar1194)
{
PLAYER::GET_PLAYER_PARACHUTE_TINT_INDEX(PLAYER::PLAYER_ID(), &iVar1169);
PLAYER::GET_PLAYER_PARACHUTE_PACK_TINT_INDEX(PLAYER::PLAYER_ID(), &uVar1170);
}
if (bVar1195)
{
PLAYER::GET_PLAYER_RESERVE_PARACHUTE_TINT_INDEX(PLAYER::PLAYER_ID(), &iVar1171);
}
if (ENTITY::DOES_ENTITY_EXIST(iVar1098))
{
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(iVar1098, true, true);
}
if (CAM::IS_SCRIPT_GLOBAL_SHAKING())
{
CAM::STOP_SCRIPT_GLOBAL_SHAKING(false);
}
if (PLAYER::HAS_FORCE_CLEANUP_OCCURRED(82))
{
func_560(&Var16, &uVar1115, &iVar1088, &iVar1089, &iVar1091, &iVar1094, &iVar1098, &uVar923, &iVar1100, &iVar1101, &iVar1102, iVar1168, &iVar1163, iVar1109, iVar1110, bVar872, &iVar1099, bVar1194);
}
if (bVar1160 < 0)
{
return;
}
if (BitTest(Global_112922.f_18967.f_1, bVar1160))
{
fVar1148 = 0.1f;
}
bVar872 = bVar1160;
func_559(0);
HUD::CLEAR_HELP(true);
MISC::SET_MISSION_FLAG(true);
func_558(23, 1);
HUD::_SET_MINIMAP_ALTITUDE_INDICATOR_LEVEL(1500f, false, 21);
func_532(&Var16, bVar872);
if (ENTITY::DOES_ENTITY_EXIST(iVar1100))
{
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(iVar1100, true, true);
}
if (ENTITY::DOES_ENTITY_EXIST(iVar1088))
{
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(iVar1088, true, true);
if (func_531(&Var16) != 0 && ENTITY::GET_ENTITY_MODEL(iVar1088) == func_531(&Var16))
{
iVar1091 = iVar1088;
iVar1088 = 0;
}
}
while (true)
{
if (!bVar1188)
{
SYSTEM::WAIT(0);
}
else
{
bVar1188 = false;
}
if ((iVar719 >= 6 && iVar719 <= 10) && !PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
iVar874 = func_520();
}
if (!ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
PED::SET_PED_RESET_FLAG(PLAYER::PLAYER_PED_ID(), 177, true);
}
func_519();
func_511(&uVar101);
func_507(&Var111, iVar719);
func_503(&Var111, iVar719, bVar872, bVar1176);
switch (iVar719)
{
case 0:
func_502();
if (CAM::IS_SCREEN_FADING_OUT())
{
break;
}
func_496();
func_495(1);
func_491("AM_H_BASEJ", 1);
HUD::CLEAR_PRINTS();
HUD::CLEAR_HELP(true);
if (bVar872 == 0)
{
PATHFIND::SET_ROADS_IN_ANGLED_AREA(-832.271f, -1525.112f, -100f, -1187.833f, -1876.646f, 100f, 50f, true, false, true);
iVar1099 = VEHICLE::ADD_VEHICLE_COMBAT_ANGLED_AVOIDANCE_AREA(-832.271f, -1525.112f, -100f, -1187.833f, -1876.646f, 100f, 50f);
}
else if (bVar872 == 5)
{
PATHFIND::SET_ROADS_IN_ANGLED_AREA(-129.031f, -726.381f, 35f, -38.185f, -465.801f, 100f, 75f, true, false, true);
}
else if (bVar872 == 4)
{
func_487(-74.9632f, -827.4467f, 324.9521f, 25f, 1);
MISC::CLEAR_AREA(-74.9632f, -827.4467f, 324.9521f, 25f, true, false, false, false);
}
else if (bVar872 == 8)
{
func_487(-74.9632f, -827.4467f, 324.9521f, 25f, 1);
MISC::CLEAR_AREA(-807.073f, 330.8846f, 232.6766f, 25f, true, false, false, false);
}
if (ENTITY::DOES_ENTITY_EXIST(iVar1088))
{
func_486(&iVar896);
}
if ((bVar872 == 6 || bVar872 == 12) || bVar872 == 5)
{
if (ENTITY::DOES_ENTITY_EXIST(ScriptParam_0.f_2))
{
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(ScriptParam_0.f_2, true, true);
OBJECT::DELETE_OBJECT(&(ScriptParam_0.f_2));
}
func_477(&uVar107, &Var16, bVar872, bVar872 == 6);
bVar1185 = true;
}
iVar719 = 1;
break;
case 1:
if (CAM::IS_SCREEN_FADED_OUT() || (((bVar872 == 5 || bVar872 == 6) || bVar872 == 12) && !bVar1176))
{
if (!bVar1176)
{
if ((bVar872 != 5 && bVar872 != 6) && bVar872 != 12)
{
Var1126 = { func_476(bVar872) };
Var1126 = { func_475(SYSTEM::COS(Var1126.f_2), SYSTEM::SIN(Var1126.f_2), MISC::TAN(Var1126.f_0)) };
if (func_474(bVar872))
{
STREAMING::NEW_LOAD_SCENE_START(func_473(bVar872), Var1126, 4000f, 0);
}
}
func_467(&Var16, bVar872, &uVar0, &iVar14, &iVar15, &uVar1115, &iVar1167);
}
else if (func_465(func_466(bVar872)))
{
Var1141 = { Vector(1.2f, 1.2f, 1.2f) * Vector(0f, -SYSTEM::COS((-97.4239f + func_464(&Var16))), SYSTEM::SIN((-97.4239f + func_464(&Var16)))) };
Var1138 = { ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(iVar1088, 1.12046f, -0.317773f, 1.3385f) };
Var1141 = { func_463(Var1141, 8.909f) };
if (func_474(bVar872))
{
STREAMING::NEW_LOAD_SCENE_START(Var1138 + Var1141, Var1141, 4000f, 0);
}
}
else
{
Var1126 = { -10f, 0f, func_464(&Var16) };
Var1126 = { func_475(SYSTEM::COS(Var1126.f_2), SYSTEM::SIN(Var1126.f_2), MISC::TAN(Var1126.f_0)) };
if (func_474(bVar872))
{
STREAMING::NEW_LOAD_SCENE_START(func_473(bVar872), Var1126, 4000f, 0);
}
}
if (((bVar1176 || bVar872 == 4) || bVar872 == 8) || bVar872 == 3)
{
if (PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), false))
{
PED::_0xF9ACF4A08098EA25(PLAYER::PLAYER_PED_ID(), true);
}
ENTITY::SET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), func_473(bVar872), false, false, false, true);
ENTITY::SET_ENTITY_HEADING(PLAYER::PLAYER_PED_ID(), func_464(&Var16));
ENTITY::FREEZE_ENTITY_POSITION(PLAYER::PLAYER_PED_ID(), true);
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), false, 0);
}
iVar719 = 2;
}
else if (!CAM::IS_SCREEN_FADING_OUT() && (!func_462(&iVar896) || func_461(&iVar896) > 0.05f))
{
if (PED::IS_PED_IN_ANY_HELI(PLAYER::PLAYER_PED_ID()))
{
CAM::DO_SCREEN_FADE_OUT(2500);
}
else
{
CAM::DO_SCREEN_FADE_OUT(800);
}
}
break;
case 2:
if (func_459(&uVar0, &iVar875, &uVar1115, bVar872, iVar1167, ((bVar872 != 5 && bVar872 != 6) && bVar872 != 12)))
{
func_458(&iVar875);
func_435(&Var16, &uVar923, &iVar1155, &iVar1088, &iVar1089, &iVar1091, &iVar1090, &iVar1092, &iVar1100, &iVar1101, iVar14, iVar15, &iVar884, bVar872, &iVar1164);
PED::FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER::PLAYER_PED_ID(), true, false);
if (!bVar1176 && !bVar1185)
{
func_477(&uVar107, &Var16, bVar872, 0);
}
iVar719 = 3;
}
break;
case 3:
if (!func_462(&iVar875) && !bVar1176)
{
func_434(0, 0, 1);
func_486(&iVar875);
}
else if ((func_462(&iVar875) && func_461(&iVar875) > 0.2f) || bVar1176)
{
if (func_465(func_466(bVar872)) && !ENTITY::IS_ENTITY_PLAYING_ANIM(PLAYER::PLAYER_PED_ID(), "oddjobs@basejump@", "Heli_door_loop", 3))
{
}
else if (bVar1176)
{
CAM::DO_SCREEN_FADE_OUT(800);
if (func_462(&iVar875))
{
func_458(&iVar875);
}
if (func_531(&Var16) != 0)
{
ENTITY::FREEZE_ENTITY_POSITION(iVar1091, false);
func_486(&iVar893);
}
iVar719 = 4;
}
else
{
func_458(&iVar875);
if (CAM::IS_SCREEN_FADED_OUT())
{
SYSTEM::WAIT(1000);
CAM::SET_CAM_ACTIVE_WITH_INTERP(func_433(&uVar107, 1), func_433(&uVar107, 0), 10000, 1, 1);
CAM::RENDER_SCRIPT_CAMS(true, false, 3000, true, false, 0);
CAM::DO_SCREEN_FADE_IN(800);
}
STREAMING::NEW_LOAD_SCENE_STOP();
if (func_465(func_466(bVar872)))
{
Var1141 = { Vector(1.2f, 1.2f, 1.2f) * Vector(0f, -SYSTEM::COS((-97.4239f + func_464(&Var16))), SYSTEM::SIN((-97.4239f + func_464(&Var16)))) };
Var1138 = { ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(iVar1088, 1.12046f, -0.317773f, 1.3385f) };
Var1141 = { func_463(Var1141, 8.909f) };
if (func_474(bVar872))
{
STREAMING::NEW_LOAD_SCENE_START(Var1138 + Var1141, Var1141, 4000f, 0);
}
}
else
{
Var1126 = { -10f, 0f, func_464(&Var16) };
Var1126 = { func_475(SYSTEM::COS(Var1126.f_2), SYSTEM::SIN(Var1126.f_2), MISC::TAN(Var1126.f_0)) };
if (func_474(bVar872))
{
STREAMING::NEW_LOAD_SCENE_START(func_473(bVar872), Var1126, 4000f, 0);
}
}
if (!func_431(func_432(bVar872)) && !ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
TASK::CLEAR_PED_TASKS(PLAYER::PLAYER_PED_ID());
PED::SET_PED_RESET_FLAG(PLAYER::PLAYER_PED_ID(), 177, true);
if (PED::GET_PED_STEALTH_MOVEMENT(PLAYER::PLAYER_PED_ID()))
{
PED::SET_PED_STEALTH_MOVEMENT(PLAYER::PLAYER_PED_ID(), false, 0);
}
ENTITY::SET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), func_432(bVar872), true, false, false, true);
ENTITY::SET_ENTITY_HEADING(PLAYER::PLAYER_PED_ID(), func_430(func_432(bVar872), func_473(bVar872)));
PED::SET_PED_RESET_FLAG(PLAYER::PLAYER_PED_ID(), 177, true);
if (func_428() == 0)
{
PED::SET_PED_COMPONENT_VARIATION(PLAYER::PLAYER_PED_ID(), 9, 5, 0, 0);
}
else if (func_428() == 1)
{
PED::SET_PED_COMPONENT_VARIATION(PLAYER::PLAYER_PED_ID(), 8, 1, 0, 0);
}
else if (func_428() == 2)
{
PED::SET_PED_COMPONENT_VARIATION(PLAYER::PLAYER_PED_ID(), 8, 3, 0, 0);
}
TASK::OPEN_SEQUENCE_TASK(&iVar1112);
if (func_427(bVar872) > 0)
{
TASK::TASK_STAND_STILL(0, func_427(bVar872));
}
TASK::TASK_GO_STRAIGHT_TO_COORD(0, func_473(bVar872), 1f, -1, func_464(&Var16), 0.5f);
TASK::CLOSE_SEQUENCE_TASK(iVar1112);
TASK::TASK_PERFORM_SEQUENCE(PLAYER::PLAYER_PED_ID(), iVar1112);
TASK::CLEAR_SEQUENCE_TASK(&iVar1112);
}
if (!func_465(func_466(bVar872)))
{
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
PED::GET_PED_NEARBY_VEHICLES(PLAYER::PLAYER_PED_ID(), &iVar1094);
}
iVar1165 = 0;
while (iVar1165 < iVar1094)
{
if (ENTITY::DOES_ENTITY_EXIST(iVar1094[iVar1165]) && !ENTITY::IS_ENTITY_DEAD(iVar1094[iVar1165], false))
{
if (SYSTEM::VDIST2(ENTITY::GET_ENTITY_COORDS(iVar1094[iVar1165], false), ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), false)) < 2500f)
{
ENTITY::SET_ENTITY_LOD_DIST(iVar1094[iVar1165], 1000);
VEHICLE::SET_VEHICLE_LOD_MULTIPLIER(iVar1094[iVar1165], 5f);
ENTITY::SET_ENTITY_LOAD_COLLISION_FLAG(iVar1094[iVar1165], true, 1);
}
}
iVar1165++;
}
}
if (func_531(&Var16) != 0)
{
func_486(&iVar893);
}
if (!PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), false))
{
ENTITY::FREEZE_ENTITY_POSITION(PLAYER::PLAYER_PED_ID(), false);
}
if (func_426(bVar872, iVar1167) > 0f)
{
func_486(&iVar911);
}
iVar719 = 4;
}
}
break;
case 4:
if (bVar872 == 0)
{
VEHICLE::SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(200f);
}
if (bVar1179 || bVar1180)
{
if (CAM::IS_SCREEN_FADED_OUT() || CAM::IS_SCREEN_FADING_OUT())
{
CAM::DO_SCREEN_FADE_IN(300);
SYSTEM::WAIT(300);
}
HUD::CLEAR_HELP(true);
HUD::CLEAR_PRINTS();
CAM::RENDER_SCRIPT_CAMS(false, false, 3000, true, true, 0);
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), true, 0);
iVar719 = 10;
}
else if (CAM::IS_SCREEN_FADED_OUT())
{
func_418(0, 1, 1, 0, 0, 0, 0);
if (func_465(func_466(bVar872)))
{
func_417(&uVar107, &Var16, &Var1123, &Var1138, &Var1141, iVar1088, &uVar1144, &uVar1147);
iVar1168 = AUDIO::GET_SOUND_ID();
if (bVar1193)
{
AUDIO::PLAY_SOUND_FROM_ENTITY(iVar1168, "Helicopter_Wind_Idle", iVar1088, "BASEJUMPS_SOUNDS", false, 0);
}
if (bVar1192)
{
AUDIO::_0x70B8EC8FC108A634(true, 300362576);
}
}
else
{
if (CAM::IS_SCRIPT_GLOBAL_SHAKING())
{
CAM::STOP_SCRIPT_GLOBAL_SHAKING(false);
}
CAM::RENDER_SCRIPT_CAMS(false, false, 3000, true, true, 0);
CAM::SET_GAMEPLAY_CAM_RELATIVE_HEADING(0f);
CAM::SET_GAMEPLAY_CAM_RELATIVE_PITCH(0f, 1f);
}
PED::CLEAR_PED_WETNESS(PLAYER::PLAYER_PED_ID());
PED::CLEAR_PED_ENV_DIRT(PLAYER::PLAYER_PED_ID());
PED::CLEAR_PED_BLOOD_DAMAGE(PLAYER::PLAYER_PED_ID());
PED::RESET_PED_VISIBLE_DAMAGE(PLAYER::PLAYER_PED_ID());
HUD::DISPLAY_RADAR(false);
HUD::DISPLAY_HUD(false);
iVar719 = 5;
}
else
{
if (!bVar1187)
{
if (!func_462(&iVar917))
{
func_486(&iVar917);
}
else if (func_461(&iVar917) > 4f || (func_465(func_466(bVar872)) && func_461(&iVar917) > 0.5f))
{
func_401(&uVar923, "OJBJAUD", func_416(&Var16), 8, 0, 0, 0);
bVar1187 = true;
}
}
if (!CAM::IS_SCREEN_FADING_OUT() && !bVar1176)
{
if (func_379(&Var16, bVar872, &iVar1091, &uVar107, &uVar101, &iVar878, &iVar881, &iVar893, &iVar911, iVar1167, &bVar1177, &bVar1189, bVar1181))
{
HUD::CLEAR_HELP(true);
bVar1181 = false;
if (func_378(&Var16))
{
CAM::DO_SCREEN_FADE_OUT(800);
}
else
{
HUD::DISPLAY_RADAR(false);
HUD::DISPLAY_HUD(false);
iVar719 = 5;
}
}
}
}
break;
case 5:
if (bVar872 == 0)
{
VEHICLE::SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(200f);
}
func_376();
func_375();
if (CAM::IS_SCREEN_FADED_OUT())
{
if (bVar1176 && bVar1186)
{
CLOCK::SET_CLOCK_TIME(func_374(iVar874), func_373(iVar874), func_372(iVar874));
}
SYSTEM::WAIT(2000);
if (bVar1176)
{
ENTITY::FREEZE_ENTITY_POSITION(PLAYER::PLAYER_PED_ID(), false);
func_371(&iVar914);
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
PED::SET_PED_RESET_FLAG(PLAYER::PLAYER_PED_ID(), 177, true);
}
while (func_461(&iVar914) < 1.1f)
{
SYSTEM::WAIT(0);
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
PED::SET_PED_RESET_FLAG(PLAYER::PLAYER_PED_ID(), 177, true);
}
}
func_458(&iVar914);
}
CAM::DO_SCREEN_FADE_IN(800);
}
if (ENTITY::DOES_ENTITY_EXIST(iVar1089) && !ENTITY::IS_ENTITY_DEAD(iVar1089, false))
{
iVar1109 = HUD::ADD_BLIP_FOR_COORD(ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(iVar1089, func_370(&Var16)));
HUD::SET_BLIP_COLOUR(iVar1109, 5);
HUD::SHOW_HEIGHT_ON_BLIP(iVar1109, true);
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(iVar1109, "BJ_BLIP_TGT");
}
else
{
iVar1109 = HUD::ADD_BLIP_FOR_COORD(func_369(&Var16, 0));
HUD::SET_BLIP_COLOUR(iVar1109, 5);
if (iVar1155 == 1)
{
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(iVar1109, "BJ_BLIP_TGT");
}
else
{
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(iVar1109, "BJ_BLIP_CHK");
}
}
HUD::SET_BLIP_SCALE(iVar1109, 1.2f);
if (iVar1155 > 1)
{
iVar1110 = HUD::ADD_BLIP_FOR_COORD(func_369(&Var16, 1));
HUD::SET_BLIP_COLOUR(iVar1110, 5);
HUD::SHOW_HEIGHT_ON_BLIP(iVar1109, true);
HUD::SET_BLIP_SCALE(iVar1110, 0.7f);
if (iVar1155 == 2)
{
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(iVar1110, "BJ_BLIP_TGT");
}
else
{
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(iVar1110, "BJ_BLIP_CHK");
}
}
if (ENTITY::DOES_ENTITY_EXIST(iVar1089) && !ENTITY::IS_ENTITY_DEAD(iVar1089, false))
{
ENTITY::SET_ENTITY_LOD_DIST(iVar1089, 2000);
if (ENTITY::DOES_ENTITY_EXIST(iVar1101) && !PED::IS_PED_INJURED(iVar1101))
{
TASK::CLEAR_PED_TASKS(iVar1101);
}
if (func_367(func_368(&Var16)))
{
VEHICLE::DELETE_MISSION_TRAIN(&iVar1089);
}
else
{
ENTITY::SET_ENTITY_COORDS(iVar1089, func_369(&Var16, 0), true, false, false, true);
}
}
if (BitTest(Global_112922.f_18967.f_1, (func_366(&Var16) - 125)))
{
PLAYER::SET_PLAYER_CAN_LEAVE_PARACHUTE_SMOKE_TRAIL(PLAYER::PLAYER_ID(), true);
PLAYER::SET_PLAYER_PARACHUTE_SMOKE_TRAIL_COLOR(PLAYER::PLAYER_ID(), MISC::GET_RANDOM_INT_IN_RANGE(0, 256), MISC::GET_RANDOM_INT_IN_RANGE(0, 256), MISC::GET_RANDOM_INT_IN_RANGE(0, 256));
}
if (func_365(func_466(bVar872)))
{
func_364(1, 1, 1);
TASK::CLEAR_PED_TASKS(PLAYER::PLAYER_PED_ID());
func_371(&iVar884);
iVar719 = 6;
func_363(88, 1);
}
else if (func_465(func_466(bVar872)))
{
func_364(0, 0, 1);
ENTITY::FREEZE_ENTITY_POSITION(PLAYER::PLAYER_PED_ID(), false);
iVar719 = 7;
func_363(88, 1);
}
else
{
func_364(1, 1, 1);
TASK::CLEAR_PED_TASKS(PLAYER::PLAYER_PED_ID());
PED::SET_PED_RESET_FLAG(PLAYER::PLAYER_PED_ID(), 177, true);
iVar719 = 6;
func_363(88, 1);
}
if (bVar872 == 5)
{
PED::SET_PED_CONFIG_FLAG(PLAYER::PLAYER_PED_ID(), 146, true);
}
if (!bVar1177 && ENTITY::DOES_ENTITY_EXIST(iVar1091))
{
func_362(&iVar1091, 1);
bVar1177 = true;
}
if (!func_378(&Var16))
{
if (func_465(func_466(bVar872)))
{
func_417(&uVar107, &Var16, &Var1123, &Var1138, &Var1141, iVar1088, &uVar1144, &uVar1147);
}
else
{
if ((func_361(&Var16) && !bVar1189) && !bVar1176)
{
CAM::STOP_RENDERING_SCRIPT_CAMS_USING_CATCH_UP(true, 0f, 3, 0);
}
else if (bVar872 == 4 && !func_360())
{
CAM::SET_CAM_COORD(func_433(&uVar107, 0), -76.7226f, -829.9866f, 326.0427f);
CAM::SET_CAM_ROT(func_433(&uVar107, 0), 0.8541f, 0f, -17.012f, 2);
CAM::SET_CAM_FOV(func_433(&uVar107, 0), 53.883f);
CAM::SET_CAM_ACTIVE(func_433(&uVar107, 0), true);
}
else
{
if (CAM::IS_SCRIPT_GLOBAL_SHAKING())
{
CAM::STOP_SCRIPT_GLOBAL_SHAKING(false);
}
CAM::RENDER_SCRIPT_CAMS(false, false, 3000, true, true, 0);
}
CAM::SET_GAMEPLAY_CAM_RELATIVE_HEADING(0f);
CAM::SET_GAMEPLAY_CAM_RELATIVE_PITCH(0f, 1f);
STREAMING::NEW_LOAD_SCENE_STOP();
}
}
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
if (bVar1194)
{
if (!WEAPON::HAS_PED_GOT_WEAPON(PLAYER::PLAYER_PED_ID(), joaat("gadget_parachute"), false))
{
WEAPON::GIVE_WEAPON_TO_PED(PLAYER::PLAYER_PED_ID(), joaat("weapon_unarmed"), 1, false, true);
}
PED::SET_PED_PARACHUTE_TINT_INDEX(PLAYER::PLAYER_PED_ID(), iVar1169);
if (bVar1195)
{
if (!PLAYER::GET_PLAYER_HAS_RESERVE_PARACHUTE(PLAYER::PLAYER_ID()))
{
PLAYER::SET_PLAYER_HAS_RESERVE_PARACHUTE(PLAYER::PLAYER_ID());
}
PED::SET_PED_RESERVE_PARACHUTE_TINT_INDEX(PLAYER::PLAYER_PED_ID(), iVar1171);
}
}
else
{
WEAPON::GIVE_WEAPON_TO_PED(PLAYER::PLAYER_PED_ID(), joaat("weapon_unarmed"), 1, false, true);
PED::SET_PED_PARACHUTE_TINT_INDEX(PLAYER::PLAYER_PED_ID(), (MISC::GET_RANDOM_INT_IN_RANGE(0, 65535) % 8));
}
}
STREAMING::REQUEST_ANIM_DICT("skydive@base");
STREAMING::REQUEST_ANIM_DICT("skydive@freefall");
STREAMING::REQUEST_ANIM_DICT("skydive@parachute@chute");
STREAMING::REQUEST_ANIM_DICT("skydive@parachute@");
break;
case 6:
if (PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
iVar719 = 12;
break;
}
else if ((bVar1180 || bVar1179) || func_359(&Var16, bVar872, &bVar1182))
{
HUD::CLEAR_HELP(true);
HUD::CLEAR_PRINTS();
iVar719 = 10;
}
else
{
if (bVar872 == 5)
{
PED::SET_PED_CONFIG_FLAG(PLAYER::PLAYER_PED_ID(), 146, ENTITY::IS_ENTITY_IN_AREA(PLAYER::PLAYER_PED_ID(), -118.4f, -973.1f, 295.2f, -117.1f, -975.7f, 297.7f, false, true, 0));
}
if (bVar1181)
{
Var1129 = { func_369(&Var16, (iVar1155 - 1)) };
Var1129.f_2 = (Var1129.f_2 + 100f);
ENTITY::SET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), Var1129, true, false, false, true);
bVar1181 = false;
}
if (!bVar1184)
{
if (bVar872 == 4)
{
if (((((PAD::IS_CONTROL_PRESSED(0, 71) || PAD::IS_CONTROL_PRESSED(0, 72)) || PAD::IS_CONTROL_PRESSED(0, 1)) || PAD::IS_CONTROL_PRESSED(0, 2)) || PAD::IS_CONTROL_PRESSED(0, 75)) || !PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), false))
{
CAM::RENDER_SCRIPT_CAMS(false, true, 1300, true, true, 0);
bVar1184 = true;
}
}
}
func_358(&iVar884);
func_348(&Var16, iVar1089, iVar1100, &iVar1102, &iVar1113, &iVar1114, &iVar1154, &iVar1156, &iVar1157, iVar1155, &iVar1158, &iVar1109, &iVar1110, &iVar1153, &iVar873, &uVar1149, &uVar1150, &uVar1151, &uVar1178, 0, 1, fVar1148);
func_347(&iVar1116);
if (func_462(&iVar875))
{
if (func_461(&iVar875) > 10f)
{
func_343(&iVar887, &iVar1163);
}
}
else
{
func_342(&iVar875, 0f);
}
if (ENTITY::DOES_ENTITY_EXIST(iVar1091) && !ENTITY::IS_ENTITY_DEAD(iVar1091, false))
{
if (!ENTITY::IS_ENTITY_ON_SCREEN(iVar1091) && SYSTEM::VDIST2(ENTITY::GET_ENTITY_COORDS(iVar1091, true), ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true)) > 40000f)
{
iVar1197 = VEHICLE::GET_PED_IN_VEHICLE_SEAT(iVar1091, -1, false);
if (!PED::IS_PED_INJURED(iVar1197))
{
PED::DELETE_PED(&iVar1197);
}
VEHICLE::DELETE_VEHICLE(&iVar1091);
}
}
if (!BitTest(uVar1161, 0))
{
if (HUD::IS_MESSAGE_BEING_DISPLAYED() || !func_462(&iVar920))
{
func_371(&iVar920);
}
else if (func_461(&iVar920) > 0.25f)
{
Var1119 = { func_341(bVar872) };
func_340(&Var1119, 7500, 0);
func_458(&iVar920);
MISC::SET_BIT(&uVar1161, false);
}
}
if (PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), false))
{
func_339(&Var111, 1);
iVar1093 = PED::GET_VEHICLE_PED_IS_IN(PLAYER::PLAYER_PED_ID(), true);
if (VEHICLE::IS_VEHICLE_DRIVEABLE(iVar1093, false) && ENTITY::IS_ENTITY_IN_AIR(iVar1093))
{
if (!BitTest(uVar1161, 1))
{
if (!func_462(&iVar899))
{
func_486(&iVar899);
}
else if (func_461(&iVar899) > 0.15f)
{
func_338("BJ_VEHHELP", -1);
func_458(&iVar899);
MISC::SET_BIT(&uVar1161, true);
}
}
}
else
{
MISC::CLEAR_BIT(&uVar1161, true);
if (func_337("BJ_VEHHELP"))
{
HUD::CLEAR_HELP(true);
}
if (func_462(&iVar899))
{
func_458(&iVar899);
}
}
}
else
{
func_339(&Var111, 0);
MISC::CLEAR_BIT(&uVar1161, true);
if (func_337("BJ_VEHHELP"))
{
HUD::CLEAR_HELP(true);
}
if (func_462(&iVar899))
{
func_458(&iVar899);
}
}
if (PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) != -1)
{
if (bVar872 == 5)
{
PED::SET_PED_CONFIG_FLAG(PLAYER::PLAYER_PED_ID(), 146, false);
}
GRAPHICS::CASCADE_SHADOWS_SET_AIRCRAFT_MODE(true);
AUDIO::SET_AUDIO_FLAG("DisableFlightMusic", false);
iVar719 = 9;
func_458(&iVar875);
}
}
break;
case 7:
if (bVar872 == 0)
{
VEHICLE::SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(200f);
}
if (bVar1179 || bVar1180)
{
if (CAM::IS_SCREEN_FADED_OUT() || CAM::IS_SCREEN_FADING_OUT())
{
CAM::DO_SCREEN_FADE_IN(300);
SYSTEM::WAIT(300);
}
HUD::CLEAR_HELP(true);
HUD::CLEAR_PRINTS();
if (CAM::IS_SCRIPT_GLOBAL_SHAKING())
{
CAM::STOP_SCRIPT_GLOBAL_SHAKING(false);
}
CAM::RENDER_SCRIPT_CAMS(false, false, 3000, true, false, 0);
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), true, 0);
iVar719 = 10;
}
else
{
func_358(&iVar884);
func_348(&Var16, iVar1089, iVar1100, &iVar1102, &iVar1113, &iVar1114, &iVar1154, &iVar1156, &iVar1157, iVar1155, &iVar1158, &iVar1109, &iVar1110, &iVar1153, &iVar873, &uVar1149, &uVar1150, &uVar1151, &uVar1178, 0, 1, fVar1148);
func_347(&iVar1116);
if (func_465(func_466(bVar872)) && !ENTITY::IS_ENTITY_DEAD(iVar1088, false))
{
func_336(iVar1088, func_473(bVar872));
}
if (func_462(&iVar875))
{
if (func_461(&iVar875) > 10f)
{
func_343(&iVar887, &iVar1163);
}
}
else
{
func_342(&iVar875, 0f);
}
if (func_332(&Var16, &uVar107, &uVar101, &iVar881, &Var1123, &uVar1135, Var1138, Var1141) || bVar1181)
{
func_458(&iVar875);
HUD::CLEAR_HELP(true);
if (!ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
if (ENTITY::DOES_ENTITY_EXIST(iVar1088) && !ENTITY::IS_ENTITY_DEAD(iVar1088, false))
{
ENTITY::SET_ENTITY_COORDS(iVar1088, func_473(bVar872), true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar1088, func_464(&Var16));
ENTITY::FREEZE_ENTITY_POSITION(iVar1088, true);
iVar1164 = PED::CREATE_SYNCHRONIZED_SCENE(0f, 0f, 0f, 0f, 0f, 0f, 2);
PED::ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iVar1164, iVar1088, ENTITY::GET_ENTITY_BONE_INDEX_BY_NAME(iVar1088, "Chassis"));
TASK::TASK_SYNCHRONIZED_SCENE(PLAYER::PLAYER_PED_ID(), iVar1164, "oddjobs@basejump@", "Heli_jump", 4f, -4f, 7, 0, 1000f, 0);
PED::SET_SYNCHRONIZED_SCENE_PHASE(iVar1164, 0.6f);
func_330(iVar1088, &uVar107, &iVar878);
STREAMING::NEW_LOAD_SCENE_STOP();
}
}
if (bVar1192)
{
AUDIO::_0x70B8EC8FC108A634(false, 300362576);
}
AUDIO::PLAY_SOUND_FROM_ENTITY(iVar1168, "Helicopter_Wind", iVar1088, "BASEJUMPS_SOUNDS", false, 0);
bVar1181 = false;
iVar719 = 8;
}
}
break;
case 8:
if (bVar872 == 0)
{
VEHICLE::SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(200f);
}
func_358(&iVar884);
func_348(&Var16, iVar1089, iVar1100, &iVar1102, &iVar1113, &iVar1114, &iVar1154, &iVar1156, &iVar1157, iVar1155, &iVar1158, &iVar1109, &iVar1110, &iVar1153, &iVar873, &uVar1149, &uVar1150, &uVar1151, &uVar1178, 0, 1, fVar1148);
if (PED::IS_SYNCHRONIZED_SCENE_RUNNING(iVar1164))
{
if (PED::GET_SYNCHRONIZED_SCENE_PHASE(iVar1164) > 0.92f)
{
TASK::OPEN_SEQUENCE_TASK(&iVar1111);
TASK::TASK_FORCE_MOTION_STATE(0, joaat("MotionState_Parachuting"), false);
TASK::TASK_PARACHUTE(0, true, false);
TASK::CLOSE_SEQUENCE_TASK(iVar1111);
TASK::TASK_PERFORM_SEQUENCE(PLAYER::PLAYER_PED_ID(), iVar1111);
TASK::CLEAR_SEQUENCE_TASK(&iVar1111);
}
}
if (ENTITY::DOES_ENTITY_EXIST(iVar1088))
{
if (func_329(&uVar107, &iVar878, Var1138, Var1141, Var1123, &uVar1144, &uVar1147))
{
ENTITY::SET_ENTITY_NO_COLLISION_ENTITY(PLAYER::PLAYER_PED_ID(), iVar1088, false);
if (!ENTITY::IS_ENTITY_PLAYING_ANIM(PLAYER::PLAYER_PED_ID(), "oddjobs@basejump@", "Heli_jump", 3))
{
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), true, 0);
HUD::DISPLAY_RADAR(true);
if (CAM::IS_SCRIPT_GLOBAL_SHAKING())
{
CAM::STOP_SCRIPT_GLOBAL_SHAKING(false);
}
AUDIO::SET_AUDIO_FLAG("DisableFlightMusic", false);
GRAPHICS::CASCADE_SHADOWS_SET_AIRCRAFT_MODE(true);
iVar719 = 9;
}
}
}
break;
case 9:
if (bVar872 == 0)
{
VEHICLE::SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(200f);
}
if (Global_22691.f_135)
{
PAD::DISABLE_CONTROL_ACTION(0, 144, true);
}
if (Global_22691.f_135)
{
PAD::DISABLE_CONTROL_ACTION(0, 144, true);
}
if (PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
iVar719 = 12;
break;
}
if (bVar1179 || bVar1180)
{
HUD::CLEAR_HELP(true);
HUD::CLEAR_PRINTS();
iVar719 = 10;
}
else if (func_328(&uVar101, 3, 1000) && !Global_22691.f_135)
{
ENTITY::SET_ENTITY_INVINCIBLE(PLAYER::PLAYER_PED_ID(), true);
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), false, 256);
CAM::DO_SCREEN_FADE_OUT(800);
while (CAM::IS_SCREEN_FADING_OUT())
{
func_348(&Var16, iVar1089, iVar1101, &iVar1102, &iVar1113, &iVar1114, &iVar1154, &iVar1156, &iVar1157, iVar1155, &iVar1158, &iVar1109, &iVar1110, &iVar1153, &iVar873, &uVar1149, &uVar1150, &uVar1151, &uVar1178, 0, 1, fVar1148);
SYSTEM::WAIT(0);
}
func_282(&Var16, &uVar1115, &Var111, &uVar1161, &iVar1101, &iVar1102, &iVar1098, &iVar1089, &iVar1090, &iVar1091, &iVar1094, &iVar1113, &iVar1114, iVar1109, iVar1110, &iVar1154, &iVar1156, &iVar1157, &iVar1163, &iVar1158, bVar872, &iVar720, &iVar873, &iVar890, &Var908, &uVar1135, &uVar1149, &uVar1150, &uVar1151, &uVar1178, &bVar1177, &bVar1179, &bVar1180, &bVar1181, &bVar1183, &iVar1175, &iVar1099);
bVar1176 = true;
iVar719 = 0;
}
else
{
func_279(&iVar905, &iVar1102);
if (bVar1181)
{
Var1129 = { func_369(&Var16, (iVar1155 - 1)) };
func_277(PLAYER::PLAYER_PED_ID(), Var1129);
bVar1181 = false;
}
func_358(&iVar884);
if (func_367(func_368(&Var16)))
{
if (!ENTITY::DOES_ENTITY_EXIST(iVar1089) && MISC::GET_DISTANCE_BETWEEN_COORDS(ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true), func_369(&Var16, 0), false) <= 200f)
{
iVar1089 = VEHICLE::CREATE_MISSION_TRAIN(6, func_369(&Var16, 0), true, 0, 0);
if (!ENTITY::IS_ENTITY_DEAD(iVar1089, false))
{
VEHICLE::SET_TRAIN_CRUISE_SPEED(iVar1089, 7.5f);
}
}
}
else if ((ENTITY::DOES_ENTITY_EXIST(iVar1089) && !ENTITY::IS_ENTITY_DEAD(iVar1089, false)) && !func_431(func_369(&Var16, 0)))
{
PED::IS_PED_INJURED(iVar1101);
if (func_276(PLAYER::PLAYER_PED_ID(), iVar1089, 0) <= 325f)
{
if (bVar872 == 5)
{
Var1198 = { 28.8687f, -299.1065f, 46.5693f };
}
else
{
Var1198 = { -819.7591f, -1512.229f, 0.1336f };
}
if (TASK::GET_SCRIPT_TASK_STATUS(iVar1101, -1273030092) != 1)
{
if (bVar872 == 5)
{
TASK::TASK_VEHICLE_MISSION_COORS_TARGET(iVar1101, iVar1089, Var1198, 4, 5f, 16785408, 5f, 10f, true);
}
else
{
TASK::TASK_VEHICLE_MISSION_COORS_TARGET(iVar1101, iVar1089, Var1198, 4, 5f, 16777216, 4f, -1f, true);
}
}
else
{
func_271(&iVar1089);
}
}
}
iVar720 = func_348(&Var16, iVar1089, iVar1101, &iVar1102, &iVar1113, &iVar1114, &iVar1154, &iVar1156, &iVar1157, iVar1155, &iVar1158, &iVar1109, &iVar1110, &iVar1153, &iVar873, &uVar1149, &uVar1150, &uVar1151, &uVar1178, 1, 1, fVar1148);
if (iVar720 == 1 || iVar720 >= 2)
{
TASK::TASK_CLEAR_LOOK_AT(PLAYER::PLAYER_PED_ID());
if (iVar720 >= 2)
{
if (HUD::IS_HELP_MESSAGE_BEING_DISPLAYED())
{
HUD::CLEAR_HELP(true);
}
if (HUD::IS_MESSAGE_BEING_DISPLAYED())
{
HUD::CLEAR_PRINTS();
}
}
WEAPON::SET_CURRENT_PED_WEAPON(PLAYER::PLAYER_PED_ID(), joaat("weapon_unarmed"), false);
if (bVar872 == 5)
{
TASK::CLEAR_PED_TASKS(iVar1101);
PED::SET_PED_CONFIG_FLAG(iVar1101, 296, true);
}
iVar1201 = 0;
while (iVar1201 < iVar1102)
{
if (ENTITY::DOES_ENTITY_EXIST(iVar1102[iVar1201]) && !ENTITY::IS_ENTITY_DEAD(iVar1102[iVar1201], false))
{
TASK::CLEAR_PED_TASKS(iVar1102[iVar1201]);
iVar1102[iVar1201] = 0;
}
iVar1201++;
}
iVar719 = 10;
}
func_270(&Var111, &Var16, bVar872, iVar1155);
}
break;
case 10:
if (bVar872 == 0)
{
VEHICLE::SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(200f);
}
if (ENTITY::DOES_ENTITY_EXIST(iVar1101) && !ENTITY::IS_ENTITY_DEAD(iVar1101, false))
{
if (TASK::GET_SCRIPT_TASK_STATUS(iVar1101, -982327190) != 0 && TASK::GET_SCRIPT_TASK_STATUS(iVar1101, -982327190) != 1)
{
TASK::CLEAR_PED_TASKS(iVar1101);
TASK::TASK_STAND_STILL(iVar1101, -1);
}
}
if ((!bVar1179 && !bVar1180) && !bVar1182)
{
if (!func_462(&iVar890))
{
if (!func_462(&iVar881))
{
func_486(&iVar881);
}
if (HUD::DOES_BLIP_EXIST(iVar1109))
{
HUD::REMOVE_BLIP(&iVar1109);
}
if (HUD::DOES_BLIP_EXIST(iVar1110))
{
HUD::REMOVE_BLIP(&iVar1110);
}
if (iVar1156 > -1)
{
GRAPHICS::DELETE_CHECKPOINT(iVar1113);
GRAPHICS::DELETE_CHECKPOINT(iVar1114);
iVar1156 = -1;
}
func_342(&iVar890, 0f);
}
if (!func_462(&Var908))
{
func_486(&Var908);
}
if (func_368(&Var16) == 0)
{
func_269(func_369(&Var16, (iVar1155 - 1)), Var908);
}
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
if (((((ENTITY::DOES_ENTITY_EXIST(iVar1089) && !ENTITY::IS_ENTITY_DEAD(iVar1089, false)) && !ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false)) && ENTITY::IS_ENTITY_AT_ENTITY(PLAYER::PLAYER_PED_ID(), iVar1089, Var1132, false, true, 0)) || ENTITY::IS_ENTITY_AT_COORD(PLAYER::PLAYER_PED_ID(), func_369(&Var16, iVar1154), Var1132, false, true, 0)) || ENTITY::IS_ENTITY_IN_AIR(PLAYER::PLAYER_PED_ID()))
{
bVar1202 = false;
if (ENTITY::IS_ENTITY_IN_AIR(PLAYER::PLAYER_PED_ID()) && (ENTITY::DOES_ENTITY_EXIST(iVar1089) && !ENTITY::IS_ENTITY_TOUCHING_ENTITY(PLAYER::PLAYER_PED_ID(), iVar1089)))
{
bVar1202 = true;
}
else if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()) && PED::IS_PED_RAGDOLL(PLAYER::PLAYER_PED_ID()))
{
bVar1202 = true;
}
if (bVar1202)
{
if (func_328(&uVar101, 3, 1000) && !Global_22691.f_135)
{
ENTITY::SET_ENTITY_INVINCIBLE(PLAYER::PLAYER_PED_ID(), true);
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), false, 256);
CAM::DO_SCREEN_FADE_OUT(800);
while (CAM::IS_SCREEN_FADING_OUT())
{
func_348(&Var16, iVar1089, iVar1101, &iVar1102, &iVar1113, &iVar1114, &iVar1154, &iVar1156, &iVar1157, iVar1155, &iVar1158, &iVar1109, &iVar1110, &iVar1153, &iVar873, &uVar1149, &uVar1150, &uVar1151, &uVar1178, 0, 1, fVar1148);
SYSTEM::WAIT(0);
}
func_282(&Var16, &uVar1115, &Var111, &uVar1161, &iVar1101, &iVar1102, &iVar1098, &iVar1089, &iVar1090, &iVar1091, &iVar1094, &iVar1113, &iVar1114, iVar1109, iVar1110, &iVar1154, &iVar1156, &iVar1157, &iVar1163, &iVar1158, bVar872, &iVar720, &iVar873, &iVar890, &Var908, &uVar1135, &uVar1149, &uVar1150, &uVar1151, &uVar1178, &bVar1177, &bVar1179, &bVar1180, &bVar1181, &bVar1183, &iVar1175, &iVar1099);
bVar1176 = true;
iVar719 = 0;
}
break;
}
}
}
}
if (PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
iVar719 = 12;
break;
}
if (((bVar1179 || bVar1180) || bVar1182) || (func_462(&iVar890) && func_461(&iVar890) > 0.25f))
{
if (func_462(&iVar890) && func_461(&iVar890) > 0.25f)
{
func_265(func_369(&Var16, iVar1154), iVar1089, iVar1101, &iVar720, &iVar1158, &fVar1152);
}
func_458(&iVar890);
if (bVar1179 || iVar720 == 1)
{
iVar722 = func_264();
while (!GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(iVar722))
{
SYSTEM::WAIT(0);
if (func_368(&Var16) == 0)
{
func_269(func_369(&Var16, (iVar1155 - 1)), Var908);
}
iVar722 = func_264();
}
if (bVar872 == 0)
{
if (!PED::IS_PED_INJURED(iVar1101))
{
func_401(&uVar923, "OJBJAUD", "BJ_01D", 8, 1, 1, 0);
}
}
iVar719 = 11;
if (!func_263(&Var111, 7))
{
iVar1162 = 125;
MISC::SET_BIT(&(Global_112922.f_18967.f_1), (func_366(&Var16) - iVar1162));
func_262(func_366(&Var16), 1);
iVar1172 = 1;
bVar1173 = true;
bVar1174 = true;
bVar1166 = false;
while (bVar1166 < 13)
{
if (!BitTest(Global_112922.f_18967.f_1, bVar1166))
{
if (func_465(func_466(bVar1166)))
{
bVar1174 = false;
}
else
{
bVar1173 = false;
}
iVar1172 = 0;
}
bVar1166++;
}
if (iVar1172 && !func_261(98))
{
func_260(98, 1);
}
if (bVar1173)
{
func_257(128, 0, 0);
}
if (bVar1174)
{
func_257(129, 0, 0);
}
func_222(&iVar1157, iVar1155, &iVar1158, &iVar1159, fVar1148);
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
WEAPON::SET_CURRENT_PED_WEAPON(PLAYER::PLAYER_PED_ID(), joaat("weapon_unarmed"), false);
}
func_221(&Var111, 7, 1);
func_220(1, 0);
func_486(&iVar902);
func_219();
}
}
else if ((bVar1180 || bVar1182) || iVar720 >= 2)
{
HUD::CLEAR_HELP(true);
HUD::CLEAR_PRINTS();
if (!bVar1182)
{
func_216();
}
if (PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
iVar1175 = 1;
}
if (PLAYER::IS_PLAYER_ONLINE())
{
func_214(&Var111, 0, 201, "BJ_CONTINUE", 203, "BJ_RETRY", 361, 0, 361, 0);
}
else
{
func_221(&Var111, 27, 1);
func_214(&Var111, 0, 201, "BJ_CONTINUE", 203, "BJ_RETRY", 211, "HUD_INPUT68", 361, 0);
}
iVar719 = 12;
}
func_458(&iVar881);
}
break;
case 11:
PAD::DISABLE_CONTROL_ACTION(2, 200, true);
if (!bVar1179 && !bVar1180)
{
if (func_213() && !func_263(&Var111, 26))
{
func_202(bVar872);
if (func_190(bVar872, iVar1158, fVar1152, iVar1159))
{
func_214(&Var111, 0, 215, "BJ_CONTINUE", 216, "BJ_RETRY", 211, "HUD_INPUT68", 361, 0);
func_221(&Var111, 26, 1);
}
}
}
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
bVar1191 = PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), false);
}
if (func_368(&Var16) == 0)
{
func_269(func_369(&Var16, (iVar1155 - 1)), Var908);
}
if (!bVar1196)
{
iVar721 = func_79(bVar872, &Var111, &uVar1115, &uVar101, iVar1157, iVar1155, iVar1158, &iVar1159, fVar1148, &bVar1183);
bVar1196 = iVar721 == true;
}
if (PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
if (bVar1160 == 0)
{
PATHFIND::SET_ROADS_IN_ANGLED_AREA(-832.271f, -1525.112f, -100f, -1187.833f, -1876.646f, 100f, 50f, false, true, true);
}
else if (bVar1160 == 5)
{
PATHFIND::SET_ROADS_IN_ANGLED_AREA(-129.031f, -726.381f, 35f, -38.185f, -465.801f, 100f, 75f, false, true, true);
}
func_78(&Var16, &uVar1115, &iVar1088, &iVar1089, &iVar1091, &iVar1094, iVar1098, &uVar923, &iVar1100, &iVar1101, &iVar1102, iVar1168, &iVar1163, iVar1109, iVar1110, bVar872, &iVar1099, bVar1194);
}
else if (!CAM::IS_SCREEN_FADING_OUT() && (!func_77() || func_461(&iVar902) >= 2f))
{
PAD::DISABLE_CONTROL_ACTION(0, 22, true);
PAD::DISABLE_CONTROL_ACTION(0, 21, true);
PAD::DISABLE_CONTROL_ACTION(0, 55, true);
PAD::DISABLE_CONTROL_ACTION(0, 140, true);
PAD::DISABLE_CONTROL_ACTION(0, 142, true);
PAD::DISABLE_CONTROL_ACTION(0, 141, true);
PAD::DISABLE_CONTROL_ACTION(0, 80, true);
PAD::DISABLE_CONTROL_ACTION(0, 95, true);
PAD::DISABLE_CONTROL_ACTION(0, 96, true);
PAD::DISABLE_CONTROL_ACTION(0, 97, true);
PAD::DISABLE_CONTROL_ACTION(0, 98, true);
PAD::DISABLE_CONTROL_ACTION(0, 0, true);
if (func_462(&iVar881))
{
if ((iVar721 == 1 || func_461(&iVar881) >= 60f) || ((!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()) && PED::IS_PED_JACKING(PLAYER::PLAYER_PED_ID())) || (!bVar1191 && PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), true))))
{
if (!bVar1196)
{
func_76(&(Var111.f_26));
bVar1196 = true;
}
if (func_47(&(Var111.f_26), 0, 1065353216, 0, 0, 0))
{
if (!bVar1179 && !bVar1180)
{
if (func_213() && !func_263(&Var111, 26))
{
if (func_190(bVar872, iVar1158, fVar1152, iVar1159))
{
func_221(&Var111, 26, 1);
}
}
}
func_44(&(Var111.f_26), 0);
func_458(&iVar902);
if (bVar872 == 0)
{
PATHFIND::SET_ROADS_IN_ANGLED_AREA(-832.271f, -1525.112f, -100f, -1187.833f, -1876.646f, 100f, 50f, false, true, true);
}
else if (bVar872 == 5)
{
PATHFIND::SET_ROADS_IN_ANGLED_AREA(-129.031f, -726.381f, 35f, -38.185f, -465.801f, 100f, 75f, false, true, true);
}
func_78(&Var16, &uVar1115, &iVar1088, &iVar1089, &iVar1091, &iVar1094, iVar1098, &uVar923, &iVar1100, &iVar1101, &iVar1102, iVar1168, &iVar1163, iVar1109, iVar1110, bVar872, &iVar1099, bVar1194);
}
}
else if (iVar721 == 0)
{
if (!bVar1179 && !bVar1180)
{
if (func_213() && !func_263(&Var111, 26))
{
if (func_190(bVar872, iVar1158, fVar1152, iVar1159))
{
func_221(&Var111, 26, 1);
}
}
}
func_44(&(Var111.f_26), 0);
func_458(&iVar902);
func_221(&Var111, 5, 0);
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), false, 256);
CAM::DO_SCREEN_FADE_OUT(800);
while (CAM::IS_SCREEN_FADING_OUT())
{
SYSTEM::WAIT(0);
if (func_368(&Var16) == 0)
{
func_269(func_369(&Var16, (iVar1155 - 1)), Var908);
}
}
func_282(&Var16, &uVar1115, &Var111, &uVar1161, &iVar1101, &iVar1102, &iVar1098, &iVar1089, &iVar1090, &iVar1091, &iVar1094, &iVar1113, &iVar1114, iVar1109, iVar1110, &iVar1154, &iVar1156, &iVar1157, &iVar1163, &iVar1158, bVar872, &iVar720, &iVar873, &iVar890, &Var908, &uVar1135, &uVar1149, &uVar1150, &uVar1151, &uVar1178, &bVar1177, &bVar1179, &bVar1180, &bVar1181, &bVar1183, &iVar1175, &iVar1099);
bVar1176 = true;
iVar719 = 0;
break;
}
else if (bVar1183)
{
if (func_461(&iVar881) > (60f - 5f))
{
func_42(&iVar881, (60f - 5f));
}
}
}
else
{
func_342(&iVar881, 0f);
}
}
break;
case 12:
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
bVar1191 = PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), false);
}
PAD::DISABLE_CONTROL_ACTION(2, 200, true);
if (iVar1159 > 0)
{
iVar1159 = 0;
}
if (!bVar1179 && !bVar1180)
{
if (func_213() && !func_263(&Var111, 26))
{
func_202(bVar872);
if (func_190(bVar872, iVar1158, fVar1152, iVar1159))
{
func_214(&Var111, 0, 201, "BJ_CONTINUE", 203, "BJ_RETRY", 211, "HUD_INPUT68", 361, 0);
func_221(&Var111, 26, 1);
}
}
}
if (!func_263(&Var111, 24))
{
if (PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
bVar1186 = true;
}
else
{
bVar1186 = false;
}
AUDIO::CANCEL_MUSIC_EVENT("OJBJ_START");
AUDIO::CANCEL_MUSIC_EVENT("OJBJ_JUMPED");
AUDIO::CANCEL_MUSIC_EVENT("OJBJ_LANDED");
AUDIO::TRIGGER_MUSIC_EVENT("OJBJ_STOP");
if (HUD::DOES_BLIP_EXIST(iVar1109))
{
HUD::REMOVE_BLIP(&iVar1109);
}
if (HUD::DOES_BLIP_EXIST(iVar1110))
{
HUD::REMOVE_BLIP(&iVar1110);
}
if (bVar872 == 0)
{
VEHICLE::SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(200f);
}
iVar722 = func_264();
while (!GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(iVar722))
{
if (func_368(&Var16) == 0)
{
func_269(func_369(&Var16, (iVar1155 - 1)), Var908);
}
SYSTEM::WAIT(0);
iVar722 = func_264();
}
if (bVar1186)
{
func_41(&uVar866, 0);
}
else
{
func_40(&Var727, 1050253722, 1073741824);
}
func_221(&Var111, 24, 1);
}
if (!bVar1186 && PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
func_221(&Var111, 24, 0);
break;
}
if (func_368(&Var16) == 0)
{
func_269(func_369(&Var16, (iVar1155 - 1)), Var908);
}
if (PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
switch (func_36(PLAYER::PLAYER_PED_ID()))
{
case 0:
sVar1118 = "BJ_FAIL_M";
break;
case 1:
sVar1118 = "BJ_FAIL_F";
break;
case 2:
sVar1118 = "BJ_FAIL_T";
break;
}
}
else if (bVar1182)
{
sVar1118 = "BJ_FAIL_02";
}
else
{
sVar1118 = "BJ_FAIL_01";
}
bVar1190 = false;
PAD::DISABLE_CONTROL_ACTION(0, 0, true);
PAD::DISABLE_CONTROL_ACTION(0, 80, true);
if (bVar1186)
{
bVar1190 = func_16(&uVar866, &Var727, &iVar722, cVar1117, sVar1118, &bVar1176, 78);
}
else
{
bVar1190 = func_3(&iVar722, &Var727, cVar1117, sVar1118, &bVar1176, 79, 7, 1, 1097859072, 1);
}
if (bVar1190)
{
if (bVar1176)
{
if (!bVar1179 && !bVar1180)
{
if (func_213() && !func_263(&Var111, 26))
{
if (func_190(bVar872, iVar1158, fVar1152, iVar1159))
{
func_221(&Var111, 26, 1);
}
}
}
func_282(&Var16, &uVar1115, &Var111, &uVar1161, &iVar1101, &iVar1102, &iVar1098, &iVar1089, &iVar1090, &iVar1091, &iVar1094, &iVar1113, &iVar1114, iVar1109, iVar1110, &iVar1154, &iVar1156, &iVar1157, &iVar1163, &iVar1158, bVar872, &iVar720, &iVar873, &iVar890, &Var908, &uVar1135, &uVar1149, &uVar1150, &uVar1151, &uVar1178, &bVar1177, &bVar1179, &bVar1180, &bVar1181, &bVar1183, &iVar1175, &iVar1099);
iVar719 = 0;
}
else
{
if (!bVar1179 && !bVar1180)
{
if (func_213() && !func_263(&Var111, 26))
{
if (func_190(bVar872, iVar1158, fVar1152, iVar1159))
{
func_221(&Var111, 26, 1);
}
}
}
func_2(bVar1186, &Var16, &uVar1115, &iVar1088, &iVar1089, &iVar1091, &iVar1094, iVar1098, &uVar923, &iVar1100, &iVar1101, &iVar1102, iVar1168, &iVar1163, iVar1109, iVar1110, bVar872, &iVar1099, bVar1194);
}
func_1(&iVar722);
}
iVar720 = 0;
break;
}
}
}
void func_1(int* iParam0)
{
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(*iParam0))
{
GRAPHICS::SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(iParam0);
*iParam0 = 0;
}
}
void func_2(bool bParam0, var uParam1, var uParam2, int* iParam3, int* iParam4, int* iParam5, int iParam6, int iParam7, var uParam8, int* iParam9, int* iParam10, int iParam11, int iParam12, int iParam13, int iParam14, int iParam15, bool bParam16, int iParam17, bool bParam18)
{
if (bParam0)
{
func_560(uParam1, uParam2, iParam3, iParam4, iParam5, iParam6, &iParam7, uParam8, iParam9, iParam10, iParam11, iParam12, iParam13, iParam14, iParam15, bParam16, iParam17, bParam18);
}
else
{
func_560(uParam1, uParam2, iParam3, iParam4, iParam5, iParam6, &iParam7, uParam8, iParam9, iParam10, iParam11, iParam12, iParam13, iParam14, iParam15, bParam16, iParam17, bParam18);
}
}
int func_3(int iParam0, var uParam1, char* sParam2, char* sParam3, bool bParam4, int iParam5, int iParam6, bool bParam7, float fParam8, bool bParam9)
{
switch (*uParam1)
{
case 0:
if (!CAM::IS_SCREEN_FADED_OUT() || CAM::IS_SCREEN_FADING_OUT())
{
CAM::DO_SCREEN_FADE_OUT(2500);
RECORDING::_STOP_RECORDING_THIS_FRAME();
}
if (bParam9)
{
SCRIPT::SET_NO_LOADING_SCREEN(true);
}
MISC::SET_TIME_SCALE(0.2f);
if (func_15(iParam5, 4))
{
if (AUDIO::REQUEST_SCRIPT_AUDIO_BANK("generic_failed", false, -1))
{
*uParam1 = 1;
}
}
else
{
*uParam1 = 1;
}
break;
case 1:
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "SHOW_CENTERED_MP_MESSAGE_LARGE");
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::SET_COLOUR_OF_NEXT_TEXT_COMPONENT(6);
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(sParam2);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
func_14(sParam3);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(100);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(true);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD_RETURN_VALUE();
if (func_15(iParam5, 32))
{
if (!uParam1->f_136)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "TRANSITION_UP");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(uParam1->f_134);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
uParam1->f_136 = 1;
}
}
if (!func_15(iParam5, 1))
{
PAD::DISABLE_ALL_CONTROL_ACTIONS(0);
}
func_13(&(uParam1->f_10), 0, 1, 1, 1);
func_12(&(uParam1->f_10), "IB_RETRY", 2, 201, 1, 1, 0);
func_12(&(uParam1->f_10), "FE_HLP16", 2, 202, 1, 1, 0);
if (func_15(iParam5, 4))
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "ScreenFlash", "MissionFailedSounds", true);
}
if (func_15(iParam5, 8))
{
switch (func_428())
{
case 0:
GRAPHICS::ANIMPOSTFX_PLAY("MinigameEndMichael", 500, false);
break;
case 1:
GRAPHICS::ANIMPOSTFX_PLAY("MinigameEndFranklin", 500, false);
break;
case 2:
GRAPHICS::ANIMPOSTFX_PLAY("MinigameEndTrevor", 500, false);
break;
}
}
if (!func_462(&(uParam1->f_1)))
{
func_486(&(uParam1->f_1));
}
if (func_15(iParam5, 2))
{
if (!func_462(&(uParam1->f_4)))
{
func_486(&(uParam1->f_4));
}
}
*uParam1 = 2;
break;
case 2:
HUD::HIDE_LOADING_ON_FADE_THIS_FRAME();
if (func_15(iParam5, 32))
{
if (!uParam1->f_136)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "TRANSITION_UP");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(uParam1->f_134);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
uParam1->f_136 = 1;
}
}
GRAPHICS::SET_SCRIPT_GFX_DRAW_ORDER(iParam6);
func_11(iParam0, 0, 0);
if (!func_15(iParam5, 16) && (func_461(&(uParam1->f_1)) >= uParam1->f_135 || CAM::IS_SCREEN_FADED_OUT()))
{
func_5(&(uParam1->f_10), 1128792064, iParam6, bParam7, 1, 1065353216);
HUD::_SET_MOUSE_CURSOR_ACTIVE_THIS_FRAME();
if (PAD::IS_CONTROL_JUST_RELEASED(2, 201))
{
uParam1->f_138 = 1;
AUDIO::PLAY_SOUND_FRONTEND(-1, "YES", "HUD_FRONTEND_DEFAULT_SOUNDSET", true);
if (!func_15(iParam5, 1))
{
PAD::ENABLE_ALL_CONTROL_ACTIONS(0);
}
func_4(&(uParam1->f_10));
*uParam1 = 3;
return 0;
}
else if (PAD::IS_CONTROL_JUST_RELEASED(2, 202))
{
uParam1->f_138 = 0;
AUDIO::PLAY_SOUND_FRONTEND(-1, "NO", "HUD_FRONTEND_DEFAULT_SOUNDSET", true);
if (!func_15(iParam5, 1))
{
PAD::ENABLE_ALL_CONTROL_ACTIONS(0);
}
func_4(&(uParam1->f_10));
*uParam1 = 3;
return 0;
}
}
if (func_15(iParam5, 2))
{
if (func_461(&(uParam1->f_4)) >= fParam8)
{
uParam1->f_138 = 0;
AUDIO::PLAY_SOUND_FRONTEND(-1, "NO", "HUD_FRONTEND_DEFAULT_SOUNDSET", true);
if (!func_15(iParam5, 1))
{
PAD::ENABLE_ALL_CONTROL_ACTIONS(0);
}
func_4(&(uParam1->f_10));
*uParam1 = 3;
return 0;
}
}
break;
case 3:
func_11(iParam0, 0, 0);
MISC::SET_TIME_SCALE(1f);
if (uParam1->f_138 || !((MISC::ARE_STRINGS_EQUAL("stunt_plane_races", SCRIPT::GET_THIS_SCRIPT_NAME()) || MISC::ARE_STRINGS_EQUAL("pilot_school", SCRIPT::GET_THIS_SCRIPT_NAME())) || (MISC::ARE_STRINGS_EQUAL("bj", SCRIPT::GET_THIS_SCRIPT_NAME()) && PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))))
{
CAM::DO_SCREEN_FADE_IN(2500);
}
if (func_15(iParam5, 64) && uParam1->f_138)
{
CAM::DO_SCREEN_FADE_OUT(500);
}
func_371(&(uParam1->f_4));
if (bParam9)
{
SCRIPT::SET_NO_LOADING_SCREEN(false);
}
*uParam1 = 4;
break;
case 4:
if (func_461(&(uParam1->f_4)) <= 0.1f)
{
func_11(iParam0, 0, 0);
}
else
{
*bParam4 = uParam1->f_138;
return 1;
}
break;
}
return 0;
}
void func_4(int* iParam0)
{
if (*iParam0 != 0)
{
GRAPHICS::SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(iParam0);
*iParam0 = 0;
}
iParam0->f_1 = 0;
iParam0->f_123 = 0;
}
void func_5(var uParam0, float fParam1, int iParam2, bool bParam3, bool bParam4, float fParam5)
{
int iVar0;
int iVar1;
bool bVar2;
char* sVar3;
bool bVar4;
int iVar5;
int iVar6;
bool bVar7;
float fVar8;
if (((CAM::IS_SCREEN_FADING_OUT() || CAM::IS_SCREEN_FADING_IN()) || CAM::IS_SCREEN_FADED_OUT()) || MISC::IS_FRONTEND_FADING())
{
if (!bParam3)
{
return;
}
}
if (!func_10(uParam0))
{
return;
}
HUD::HIDE_LOADING_ON_FADE_THIS_FRAME();
GRAPHICS::SET_SCRIPT_GFX_DRAW_ORDER(iParam2);
if (!func_15(uParam0->f_1, 256) || (func_15(uParam0->f_1, 8192) && PAD::_0x6CD79468A1E595C6(2)))
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "SET_CLEAR_SPACE");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(fParam1);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "SET_MAX_WIDTH");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(fParam5);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "SET_DATA_SLOT_EMPTY");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
if (MISC::IS_PC_VERSION())
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "TOGGLE_MOUSE_BUTTONS");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(func_15(uParam0->f_1, 4096));
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
iVar5 = 0;
iVar6 = 0;
while (iVar6 < uParam0->f_123)
{
switch (uParam0->f_2[iVar6 /*15*/].f_2)
{
case 0:
bVar4 = true;
break;
case 1:
bVar4 = PAD::_IS_USING_KEYBOARD(2);
break;
case 2:
bVar4 = !PAD::_IS_USING_KEYBOARD(2);
break;
default:
bVar4 = false;
break;
}
if (bVar4)
{
if (GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "SET_DATA_SLOT"))
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iVar5);
iVar5++;
bVar7 = false;
while (bVar7 < uParam0->f_2[iVar6 /*15*/].f_14)
{
iVar0 = uParam0->f_2[iVar6 /*15*/].f_3[bVar7 /*2*/];
iVar1 = uParam0->f_2[iVar6 /*15*/].f_3[bVar7 /*2*/].f_1;
bVar2 = BitTest(uParam0->f_2[iVar6 /*15*/].f_13, bVar7);
if (!BitTest(uParam0->f_2[iVar6 /*15*/].f_12, bVar7))
{
sVar3 = PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(iVar0, iVar1, bVar2);
}
else
{
sVar3 = PAD::GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTON(iVar0, iVar1, bVar2);
}
if (!MISC::IS_STRING_NULL_OR_EMPTY(sVar3))
{
func_9(sVar3);
}
bVar7++;
}
if (!MISC::IS_STRING_NULL_OR_EMPTY(uParam0->f_2[iVar6 /*15*/]))
{
func_14(uParam0->f_2[iVar6 /*15*/]);
}
if (MISC::IS_PC_VERSION())
{
if (func_15(uParam0->f_1, 4096))
{
if (uParam0->f_2[iVar6 /*15*/].f_1)
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(true);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(uParam0->f_2[iVar6 /*15*/].f_3[0 /*2*/].f_1);
}
else
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(false);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(-1);
}
}
}
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
}
iVar6++;
}
fVar8 = func_8(bParam4, func_8(func_15(uParam0->f_1, 32), 1f, 0f), -1f);
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "DRAW_INSTRUCTIONAL_BUTTONS");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(fVar8);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "SET_BACKGROUND_COLOUR");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0f);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0f);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0f);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(80f);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
func_7(&(uParam0->f_1), 256);
func_6(&(uParam0->f_1), 128);
}
GRAPHICS::DRAW_SCALEFORM_MOVIE_FULLSCREEN(*uParam0, 255, 255, 255, 0, 0);
}
void func_6(var uParam0, int iParam1)
{
*uParam0 = (*uParam0 - (*uParam0 && iParam1));
}
void func_7(var uParam0, int iParam1)
{
*uParam0 = (*uParam0 || iParam1);
}
float func_8(bool bParam0, float fParam1, float fParam2)
{
if (bParam0)
{
return fParam1;
}
return fParam2;
}
void func_9(char* sParam0)
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_PLAYER_NAME_STRING(sParam0);
}
int func_10(var uParam0)
{
if (*uParam0 != 0)
{
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(*uParam0))
{
func_7(&(uParam0->f_1), 1);
return 1;
}
}
return 0;
}
int func_11(var uParam0, bool bParam1, bool bParam2)
{
if (!func_462(&(uParam0->f_2)))
{
func_371(&(uParam0->f_2));
}
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(14);
if (!bParam2)
{
GRAPHICS::DRAW_SCALEFORM_MOVIE_FULLSCREEN(*uParam0, 255, 255, 255, 255, 0);
}
else if (bParam2)
{
GRAPHICS::DRAW_SCALEFORM_MOVIE_FULLSCREEN(*uParam0, 255, 255, 255, 255, 0);
}
if (bParam1)
{
if (PAD::IS_CONTROL_PRESSED(2, 201))
{
return 0;
}
}
if (uParam0->f_1 == -1)
{
return 1;
}
if (func_461(&(uParam0->f_2)) * 1000f) > SYSTEM::TO_FLOAT(uParam0->f_1)
{
func_458(&(uParam0->f_2));
return 0;
}
return 1;
}
int func_12(var uParam0, char* sParam1, int iParam2, int iParam3, int iParam4, int iParam5, int iParam6)
{
int iVar0;
int iVar1;
if (*uParam0 == 0)
{
return 0;
}
iVar0 = 0;
if (iParam5 == 1)
{
iVar0 = 1;
}
iVar1 = uParam0->f_123;
if (iVar1 < 8)
{
uParam0->f_2[iVar1 /*15*/] = sParam1;
uParam0->f_2[iVar1 /*15*/].f_1 = iVar0;
uParam0->f_2[iVar1 /*15*/].f_2 = iParam6;
uParam0->f_2[iVar1 /*15*/].f_12 = 0;
uParam0->f_2[iVar1 /*15*/].f_13 = 0;
uParam0->f_2[iVar1 /*15*/].f_14 = 0;
uParam0->f_2[iVar1 /*15*/].f_3[0 /*2*/] = iParam2;
uParam0->f_2[iVar1 /*15*/].f_3[0 /*2*/].f_1 = iParam3;
if (iParam4 == 1)
{
MISC::SET_BIT(&(uParam0->f_2[iVar1 /*15*/].f_13), false);
}
uParam0->f_2[iVar1 /*15*/].f_14++;
uParam0->f_123++;
return 1;
}
return 0;
}
void func_13(var uParam0, bool bParam1, bool bParam2, bool bParam3, bool bParam4)
{
if (*uParam0 == 0)
{
*uParam0 = GRAPHICS::REQUEST_SCALEFORM_MOVIE_INSTANCE("instructional_buttons");
}
uParam0->f_1 = 0;
uParam0->f_123 = 0;
if (bParam1)
{
func_7(&(uParam0->f_1), 32);
}
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(*uParam0))
{
func_7(&(uParam0->f_1), 1);
if (bParam2)
{
GRAPHICS::SET_SCALEFORM_MOVIE_TO_USE_SYSTEM_TIME(*uParam0, true);
}
}
if (MISC::IS_PC_VERSION())
{
if (bParam3)
{
func_7(&(uParam0->f_1), 4096);
}
}
if (bParam4)
{
func_7(&(uParam0->f_1), 8192);
}
}
void func_14(char* sParam0)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sParam0);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
bool func_15(var uParam0, int iParam1)
{
return (uParam0 && iParam1) != 0;
}
int func_16(var uParam0, var uParam1, int iParam2, char* sParam3, char* sParam4, bool bParam5, int iParam6)
{
switch (*uParam0)
{
case 0:
*uParam0 = 1;
AUDIO::START_AUDIO_SCENE("DEATH_SCENE");
AUDIO::PLAY_SOUND_FRONTEND(-1, "ScreenFlash", "WastedSounds", true);
func_35(&(uParam0->f_1));
func_34();
func_40(uParam1, (0.15f * 0.075f), 0.5f);
SCRIPT::SET_NO_LOADING_SCREEN(true);
break;
case 1:
if (func_24() || CAM::IS_SCREEN_FADED_OUT())
{
*uParam0 = 2;
}
if (!func_23(uParam0->f_4, 4))
{
if (AUDIO::REQUEST_SCRIPT_AUDIO_BANK("OFFMISSION_WASTED", false, -1))
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "Bed", "WastedSounds", true);
func_21(&(uParam0->f_4), 4);
}
}
if (IntToFloat(SYSTEM::TIMERA()) > (1500f * 0.2f))
{
if (!func_23(uParam0->f_4, 2))
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "TextHit", "WastedSounds", true);
func_21(&(uParam0->f_4), 2);
}
func_3(iParam2, uParam1, sParam3, sParam4, bParam5, ((iParam6 - 4 & iParam6) - 2 & iParam6) | 16, 7, 1, 1097859072, 0);
}
break;
case 2:
if (func_3(iParam2, uParam1, sParam3, sParam4, bParam5, (((iParam6 - 8 & iParam6) - 4 & iParam6) - 2 & iParam6), 7, 1, 1097859072, 1))
{
func_20(0, 1);
func_18(0, 1);
func_34();
if (*bParam5)
{
MISC::IGNORE_NEXT_RESTART(true);
}
else if (!uParam0->f_5)
{
func_17(0);
}
SCRIPT::SET_NO_LOADING_SCREEN(false);
MISC::PAUSE_DEATH_ARREST_RESTART(false);
*uParam0 = 3;
}
break;
case 3:
if (PLAYER::IS_PLAYER_PLAYING(PLAYER::PLAYER_ID()))
{
MISC::SET_FADE_IN_AFTER_DEATH_ARREST(true);
func_20(0, 1);
func_18(0, 1);
AUDIO::STOP_AUDIO_SCENE("DEATH_SCENE");
SCRIPT::SET_NO_LOADING_SCREEN(false);
return 1;
}
break;
case 4:
SCRIPT::SET_NO_LOADING_SCREEN(false);
return 1;
break;
}
return 0;
}
void func_17(bool bParam0)
{
if ((Global_42602 == 9 || Global_42602 == 10) || Global_42602 == 5)
{
Global_111571 = bParam0;
if (bParam0)
{
}
}
else
{
if (bParam0)
{
}
Global_111571 = 0;
}
}
void func_18(int iParam0, int iParam1)
{
if (iParam0 == 1)
{
func_20(0, 0);
GRAPHICS::ANIMPOSTFX_PLAY("DeathFailOut", 0, false);
MISC::SET_BIT(&iLocal_43, true);
func_19(1, 2, 0);
CAM::_SET_CAM_EFFECT(2);
}
else
{
if (BitTest(iLocal_43, 1) || iParam1)
{
GRAPHICS::ANIMPOSTFX_STOP("DeathFailOut");
func_19(0, 2, 1);
CAM::_SET_CAM_EFFECT(0);
}
MISC::CLEAR_BIT(&iLocal_43, true);
}
}
void func_19(int iParam0, int iParam1, int iParam2)
{
if (iParam0 == 1)
{
MISC::SET_BIT(&iLocal_43, 2);
if (!NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
if (iParam1 == 1)
{
MISC::SET_TIME_SCALE(0.2f);
}
else
{
MISC::SET_TIME_SCALE(0.075f);
}
}
}
else
{
if (BitTest(iLocal_43, 2) || iParam2)
{
if (!NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
MISC::SET_TIME_SCALE(1f);
}
}
MISC::CLEAR_BIT(&iLocal_43, 2);
}
}
void func_20(int iParam0, int iParam1)
{
char* sVar0;
switch (func_428())
{
case 0:
sVar0 = "DeathFailMichaelIn";
break;
case 1:
sVar0 = "DeathFailFranklinIn";
break;
case 2:
sVar0 = "DeathFailTrevorIn";
break;
}
if (iParam0 == 1)
{
if (!BitTest(iLocal_43, 0) || iParam1)
{
GRAPHICS::ANIMPOSTFX_PLAY(sVar0, 0, false);
MISC::SET_BIT(&iLocal_43, false);
func_19(1, 1, 0);
CAM::_SET_CAM_EFFECT(1);
}
}
else
{
if (BitTest(iLocal_43, 0) || iParam1)
{
GRAPHICS::ANIMPOSTFX_STOP(sVar0);
func_19(0, 1, 1);
CAM::_SET_CAM_EFFECT(0);
}
MISC::CLEAR_BIT(&iLocal_43, false);
}
}
void func_21(var uParam0, int iParam1)
{
func_22(uParam0, iParam1);
}
void func_22(var uParam0, var uParam1)
{
*uParam0 = (*uParam0 || uParam1);
}
bool func_23(var uParam0, int iParam1)
{
return (uParam0 && iParam1) != 0;
}
int func_24()
{
if (!BitTest(iLocal_43, 0) && !BitTest(iLocal_43, 1))
{
SYSTEM::SETTIMERA(0);
func_20(1, 0);
}
if (!CUTSCENE::IS_CUTSCENE_PLAYING())
{
HUD::CLEAR_PRINTS();
}
PAD::DISABLE_CONTROL_ACTION(2, 199, true);
PAD::DISABLE_CONTROL_ACTION(0, 59, true);
PAD::DISABLE_CONTROL_ACTION(0, 60, true);
PAD::DISABLE_CONTROL_ACTION(0, 37, true);
PAD::DISABLE_CONTROL_ACTION(0, 25, true);
PED::_0x5A7F62FDA59759BD();
if (IntToFloat(SYSTEM::TIMERA()) > (1500f * 0.2f))
{
if (!BitTest(iLocal_43, 1))
{
func_18(1, 0);
SYSTEM::SETTIMERB(0);
}
else if (IntToFloat(SYSTEM::TIMERB()) > (1500f * 0.075f) || CAM::IS_SCREEN_FADED_OUT())
{
if (!CAM::IS_SCREEN_FADED_OUT())
{
if (!CAM::IS_SCREEN_FADING_OUT())
{
CAM::DO_SCREEN_FADE_OUT(1500);
}
}
else if (iLocal_44 == 0)
{
iLocal_44 = MISC::GET_GAME_TIMER() + 1000;
if (PLAYER::IS_PLAYER_PLAYING(PLAYER::PLAYER_ID()))
{
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), false, 0);
}
func_19(0, 2, 1);
func_418(1, 1, 1, 0, 0, 0, 0);
func_26(1);
HUD::SET_FRONTEND_ACTIVE(false);
HUD::SET_PAUSE_MENU_ACTIVE(false);
HUD::CLEAR_HELP(true);
HUD::CLEAR_PRINTS();
if (PLAYER::IS_PLAYER_PLAYING(PLAYER::PLAYER_ID()))
{
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), false, 0);
}
func_20(0, 0);
func_25(0);
}
else if (MISC::GET_GAME_TIMER() < iLocal_44)
{
return 1;
}
}
}
return 0;
}
void func_25(int iParam0)
{
int iVar0;
iVar0 = 0;
if (iVar0 == 0)
{
if (iParam0 == 1)
{
if (!BitTest(iLocal_43, 3))
{
MISC::SET_GAME_PAUSED(true);
MISC::SET_BIT(&iLocal_43, 3);
}
}
else if (BitTest(iLocal_43, 3))
{
MISC::SET_GAME_PAUSED(false);
MISC::CLEAR_BIT(&iLocal_43, 3);
}
}
}
void func_26(bool bParam0)
{
if (bParam0)
{
func_33();
if (Global_19954.f_1 == 10 || Global_19954.f_1 == 9)
{
MISC::SET_BIT(&Global_7825, 16);
}
Global_19954.f_1 = 1;
if (func_32(0))
{
func_27(0);
}
}
else if (Global_19954.f_1 == 1)
{
if (!Global_19954.f_1 == 0)
{
Global_19954.f_1 = 3;
}
}
}
void func_27(int iParam0)
{
if (func_31())
{
return;
}
if (Global_20144)
{
if (func_30())
{
func_29(1, 1);
}
else
{
func_29(0, 0);
}
}
if (Global_19954.f_1 == 10 || Global_19954.f_1 == 9)
{
MISC::SET_BIT(&Global_7825, 16);
}
if (AUDIO::IS_MOBILE_PHONE_CALL_ONGOING())
{
AUDIO::STOP_SCRIPTED_CONVERSATION(false);
}
Global_21285 = 5;
if (iParam0 == 1)
{
MISC::SET_BIT(&Global_7824, 30);
}
else
{
MISC::CLEAR_BIT(&Global_7824, 30);
}
if (!func_28())
{
Global_19954.f_1 = 3;
}
}
int func_28()
{
if (Global_19954.f_1 == 1 || Global_19954.f_1 == 0)
{
return 1;
}
return 0;
}
void func_29(bool bParam0, bool bParam1)
{
if (bParam0)
{
if (func_32(0))
{
Global_20144 = 1;
if (bParam1)
{
MOBILE::GET_MOBILE_PHONE_POSITION(&Global_19891);
}
Global_19882 = { Global_19900[Global_19899 /*3*/] };
MOBILE::SET_MOBILE_PHONE_POSITION(Global_19882);
}
}
else if (Global_20144 == 1)
{
Global_20144 = 0;
Global_19882 = { Global_19907[Global_19899 /*3*/] };
if (bParam1)
{
MOBILE::SET_MOBILE_PHONE_POSITION(Global_19891);
}
else
{
MOBILE::SET_MOBILE_PHONE_POSITION(Global_19882);
}
}
}
bool func_30()
{
return BitTest(Global_1958928, 5);
}
bool func_31()
{
return BitTest(Global_1958928, 19);
}
int func_32(int iParam0)
{
if (iParam0 == 1)
{
if (Global_19954.f_1 > 3)
{
if (BitTest(Global_7824, 14))
{
return 1;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
if (SCRIPT::_GET_NUMBER_OF_REFERENCES_OF_SCRIPT_WITH_NAME_HASH(joaat("cellphone_flashhand")) > 0)
{
return 1;
}
if (Global_19954.f_1 > 3)
{
return 1;
}
return 0;
}
void func_33()
{
if (Global_19954.f_1 == 9 || Global_19954.f_1 == 10)
{
Global_21338 = 0;
Global_21334 = 1;
}
}
void func_34()
{
iLocal_43 = 0;
iLocal_44 = 0;
func_418(0, 1, 1, 0, 0, 0, 0);
func_26(1);
}
void func_35(int* iParam0)
{
if (!func_462(iParam0))
{
func_486(iParam0);
}
else
{
func_371(iParam0);
}
}
int func_36(int iParam0)
{
int iVar0;
int iVar1;
if (ENTITY::DOES_ENTITY_EXIST(iParam0))
{
iVar1 = ENTITY::GET_ENTITY_MODEL(iParam0);
iVar0 = 0;
while (iVar0 <= 2)
{
if (func_37(iVar0) == iVar1)
{
return iVar0;
}
iVar0++;
}
}
return 145;
}
int func_37(int iParam0)
{
if (func_39(iParam0))
{
return func_38(iParam0);
}
else if (iParam0 != 145)
{
}
return 0;
}
var func_38(int iParam0)
{
return Global_1918[iParam0 /*29*/];
}
bool func_39(int iParam0)
{
return iParam0 < 3;
}
void func_40(var uParam0, int iParam1, int iParam2)
{
if (func_462(&(uParam0->f_1)))
{
func_458(&(uParam0->f_1));
}
if (func_462(&(uParam0->f_4)))
{
func_458(&(uParam0->f_4));
}
func_4(&(uParam0->f_10));
uParam0->f_134 = iParam1;
uParam0->f_135 = iParam2;
uParam0->f_137 = 1;
uParam0->f_136 = 0;
*uParam0 = 0;
}
void func_41(var uParam0, int iParam1)
{
*uParam0 = 0;
uParam0->f_4 = 0;
uParam0->f_5 = iParam1;
AUDIO::REQUEST_SCRIPT_AUDIO_BANK("OFFMISSION_WASTED", false, -1);
}
void func_42(int* iParam0, float fParam1)
{
iParam0->f_1 = (func_43(BitTest(*iParam0, 4)) - fParam1);
MISC::SET_BIT(iParam0, true);
MISC::CLEAR_BIT(iParam0, 2);
iParam0->f_2 = 0f;
}
float func_43(bool bParam0)
{
float fVar0;
float fVar1;
int iVar2;
float fVar3;
float fVar4;
if (bParam0)
{
fVar0 = SYSTEM::TO_FLOAT(MISC::GET_GAME_TIMER());
fVar1 = (fVar0 / 1000f);
return fVar1;
}
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
iVar2 = NETWORK::GET_NETWORK_TIME();
fVar3 = SYSTEM::TO_FLOAT(iVar2);
fVar4 = (fVar3 / 1000f);
return fVar4;
}
return (SYSTEM::TO_FLOAT(MISC::GET_GAME_TIMER()) / 1000f);
}
void func_44(var uParam0, int iParam1)
{
if (uParam0->f_1 != 0)
{
GRAPHICS::SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(&(uParam0->f_1));
uParam0->f_1 = 0;
}
if ((uParam0->f_566 || iParam1) && uParam0->f_4 != 0)
{
if (MISC::IS_PC_VERSION())
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "TOGGLE_MOUSE_BUTTONS");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(false);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
GRAPHICS::SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(&(uParam0->f_4));
uParam0->f_4 = 0;
}
if (uParam0->f_568)
{
SCRIPT::SET_NO_LOADING_SCREEN(false);
uParam0->f_568 = 0;
}
if (!Global_78126)
{
if (!PLAYER::IS_PLAYER_DEAD(PLAYER::GET_PLAYER_INDEX()))
{
if (!Global_78127)
{
if (CAM::IS_SCREEN_FADED_OUT() && !func_46(0))
{
CAM::DO_SCREEN_FADE_IN(800);
}
}
}
}
func_45(0);
}
void func_45(int iParam0)
{
Global_78118 = iParam0;
Global_78119 = iParam0;
}
int func_46(bool bParam0)
{
if (!bParam0 && SCRIPT::_GET_NUMBER_OF_REFERENCES_OF_SCRIPT_WITH_NAME_HASH(joaat("benchmark")) > 0)
{
return 1;
}
return BitTest(Global_78106, 0);
}
int func_47(var uParam0, bool bParam1, float fParam2, bool bParam3, int iParam4, bool bParam5)
{
bool bVar0;
if (MISC::GET_FRAME_COUNT() == uParam0->f_578)
{
return uParam0->f_579;
}
uParam0->f_578 = MISC::GET_FRAME_COUNT();
if (!NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
if (PED::IS_PED_DEAD_OR_DYING(PLAYER::GET_PLAYER_PED(PLAYER::GET_PLAYER_INDEX()), true))
{
uParam0->f_579 = 1;
return 1;
}
if (TASK::IS_PED_BEING_ARRESTED(PLAYER::GET_PLAYER_PED(PLAYER::GET_PLAYER_INDEX())))
{
uParam0->f_579 = 1;
return 1;
}
}
if (!uParam0->f_568)
{
if (CAM::IS_SCREEN_FADED_OUT() || CAM::IS_SCREEN_FADING_OUT())
{
SCRIPT::SET_NO_LOADING_SCREEN(true);
uParam0->f_568 = 1;
}
}
if (PLAYER::IS_PLAYER_PLAYING(PLAYER::PLAYER_ID()))
{
if (!NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
if (PLAYER::IS_SPECIAL_ABILITY_ACTIVE(PLAYER::PLAYER_ID(), 0))
{
PLAYER::SPECIAL_ABILITY_DEACTIVATE(PLAYER::PLAYER_ID(), 0);
}
}
}
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(7);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(8);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(9);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(6);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(19);
PAD::DISABLE_CONTROL_ACTION(2, 19, true);
PAD::DISABLE_CONTROL_ACTION(0, 37, true);
PAD::DISABLE_CONTROL_ACTION(0, 21, true);
PAD::DISABLE_CONTROL_ACTION(0, 28, true);
PAD::DISABLE_CONTROL_ACTION(0, 29, true);
PAD::DISABLE_CONTROL_ACTION(0, 171, true);
func_75(0);
if (PAD::_IS_USING_KEYBOARD(2))
{
if (PLAYER::_IS_PLAYER_CAM_CONTROL_DISABLED() || (CAM::IS_SCREEN_FADED_OUT() && !CAM::IS_SCREEN_FADING_IN()))
{
HUD::_SET_MOUSE_CURSOR_ACTIVE_THIS_FRAME();
}
}
Global_43152 = 1;
if (!uParam0->f_567)
{
switch (func_36(PLAYER::GET_PLAYER_PED(PLAYER::GET_PLAYER_INDEX())))
{
case 1:
GRAPHICS::ANIMPOSTFX_PLAY("SuccessFranklin", 1000, false);
break;
case 2:
GRAPHICS::ANIMPOSTFX_PLAY("SuccessTrevor", 1000, false);
break;
default:
GRAPHICS::ANIMPOSTFX_PLAY("SuccessMichael", 1000, false);
break;
}
uParam0->f_567 = 1;
}
if (uParam0->f_562 == 0)
{
uParam0->f_562 = (uParam0->f_576 + SYSTEM::FLOOR((15000f * fParam2)));
}
if (iParam4 && uParam0->f_576 >= (uParam0->f_562 - 1500))
{
uParam0->f_562 = uParam0->f_576 + 3000;
}
if (uParam0->f_564 == 0f)
{
uParam0->f_564 = (uParam0->f_564 + func_74(30f));
uParam0->f_564 = (uParam0->f_564 + (IntToFloat(uParam0->f_56) * func_74(25f)));
if (uParam0->f_56 > 0)
{
uParam0->f_564 = (uParam0->f_564 + func_74((25f * 0.5f)));
}
if (uParam0->f_549)
{
uParam0->f_564 = (uParam0->f_564 + (func_74(30f) - func_74(2f)));
}
}
bVar0 = true;
while (bVar0)
{
func_45(1);
uParam0->f_576 = (uParam0->f_576 + SYSTEM::ROUND((0f + (1000f * SYSTEM::TIMESTEP()))));
func_50(uParam0, fParam2, bParam3);
if (IntToFloat(uParam0->f_576) > (IntToFloat(uParam0->f_562 + 666) - (15000f * fParam2)))
{
if (uParam0->f_30 < 1f)
{
uParam0->f_30 = (uParam0->f_30 + (0f + ((1f / 0.225f) * SYSTEM::TIMESTEP())));
}
}
uParam0->f_30 = func_49(uParam0->f_30, 0f, 1f);
if (uParam0->f_576 > (uParam0->f_562 - 333))
{
if (!uParam0->f_565)
{
if (uParam0->f_569)
{
uParam0->f_569 = 0;
uParam0->f_570 = 0;
uParam0->f_577 = 0.75f;
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_1, "ROLL_UP_BACKGROUND");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
uParam0->f_547 = (uParam0->f_547 - (0f + ((1f / 1.215f) * SYSTEM::TIMESTEP())));
}
}
uParam0->f_547 = func_49(uParam0->f_547, 0f, 1f);
if ((uParam0->f_547 <= 0.7f && !uParam0->f_545) && uParam0->f_1 != 0)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_1, "TRANSITION_OUT");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
uParam0->f_546 = uParam0->f_576;
uParam0->f_545 = 1;
}
if (uParam0->f_576 > (uParam0->f_562 - 333))
{
if (!uParam0->f_565)
{
if (uParam0->f_548 < 1f)
{
uParam0->f_548 = (uParam0->f_548 + (0f + ((1f / 0.3f) * SYSTEM::TIMESTEP())));
}
}
}
uParam0->f_548 = func_49(uParam0->f_548, 0f, 1f);
if (uParam0->f_566)
{
if (PAD::_0x6CD79468A1E595C6(2))
{
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(uParam0->f_4))
{
if (!uParam0->f_571)
{
func_48(uParam0, (!uParam0->f_569 && uParam0->f_56 > 0));
}
}
}
}
if (PAD::IS_CONTROL_JUST_PRESSED(2, 216) && uParam0->f_562 > uParam0->f_576 + 333)
{
if (((!uParam0->f_570 && uParam0->f_56 != 0) && GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(uParam0->f_4)) && IntToFloat(uParam0->f_576) > (IntToFloat(uParam0->f_562 + 1165) - (15000f * fParam2)))
{
if (!uParam0->f_569)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_1, "ROLL_DOWN_BACKGROUND");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
uParam0->f_569 = 1;
uParam0->f_577 = 0.75f;
if (uParam0->f_576 > (uParam0->f_562 - 5000))
{
uParam0->f_562 = uParam0->f_576 + 5000;
}
}
else if (bParam5)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_1, "ROLL_UP_BACKGROUND");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
uParam0->f_569 = 0;
uParam0->f_577 = 0.75f;
}
func_48(uParam0, (!uParam0->f_569 && uParam0->f_56 > 0));
}
}
if ((uParam0->f_569 || uParam0->f_570) && uParam0->f_56 != 0)
{
if (IntToFloat(uParam0->f_576) > (IntToFloat(uParam0->f_562 + 1165) - (15000f * fParam2)))
{
if (uParam0->f_570 && !uParam0->f_569)
{
uParam0->f_569 = 1;
uParam0->f_577 = 0.75f;
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_1, "ROLL_DOWN_BACKGROUND");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
uParam0->f_563 = func_49((uParam0->f_563 + (((1f / 0.3f) * uParam0->f_577) * SYSTEM::TIMESTEP())), 0f, 1f);
uParam0->f_577 = func_49((uParam0->f_577 + 0.07f), 0.75f, 1.15f);
}
}
else
{
uParam0->f_563 = func_49((uParam0->f_563 - ((((1f / 0.3f) * uParam0->f_577) * 0.01f) * SYSTEM::TIMESTEP())), 0f, 1f);
uParam0->f_577 = func_49((uParam0->f_577 + 0.07f), 0.75f, 1.15f);
}
if (uParam0->f_576 > uParam0->f_562)
{
if (uParam0->f_565)
{
if (!uParam0->f_571)
{
if (PAD::IS_CONTROL_JUST_PRESSED(2, 215))
{
uParam0->f_565 = 0;
}
}
}
else if ((uParam0->f_576 - uParam0->f_546) > 1000 && uParam0->f_545)
{
bVar0 = false;
}
}
uParam0->f_579 = !bVar0;
if (bParam1)
{
SYSTEM::WAIT(0);
}
else
{
if (!bVar0)
{
func_45(0);
}
return !bVar0;
}
}
func_45(0);
return 1;
}
void func_48(var uParam0, bool bParam1)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "CLEAR_ALL");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
if (MISC::IS_PC_VERSION())
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "TOGGLE_MOUSE_BUTTONS");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(true);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "SET_DATA_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(0);
func_9(PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, 215, true));
func_14("ES_HELP");
if (MISC::IS_PC_VERSION())
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(true);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(215);
}
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
if (bParam1)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "SET_DATA_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(1);
func_9(PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, 216, true));
func_14("ES_XPAND");
if (MISC::IS_PC_VERSION())
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(true);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(216);
}
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "DRAW_INSTRUCTIONAL_BUTTONS");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
float func_49(float fParam0, float fParam1, float fParam2)
{
if (fParam0 > fParam2)
{
return fParam2;
}
else if (fParam0 < fParam1)
{
return fParam1;
}
return fParam0;
}
void func_50(var uParam0, float fParam1, bool bParam2)
{
int iVar0;
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
float fVar9;
float fVar10;
float fVar11;
float fVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
float fVar18;
float fVar19;
float fVar20;
float fVar21;
float fVar22;
char cVar23[16];
char cVar27[32];
int iVar35;
int iVar36;
int iVar37;
int iVar38;
float fVar39;
float fVar40;
float fVar41;
float fVar42;
float fVar43;
iVar0 = SYSTEM::ROUND((uParam0->f_547 * 255f));
fVar1 = (func_73() * 0.25f);
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(uParam0->f_1))
{
if (uParam0->f_30 >= 0f)
{
if (!uParam0->f_2)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_1, "SHOW_MISSION_PASSED_MESSAGE");
func_14(&(uParam0->f_5));
if (uParam0->f_560 == 4)
{
func_72(&(uParam0->f_13));
}
else
{
func_14(&(uParam0->f_13));
}
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(150);
}
else
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(100);
}
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(true);
if (uParam0->f_560 == 4)
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT((uParam0->f_56 - 1));
}
else
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(uParam0->f_56);
}
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(bParam2);
if (uParam0->f_560 == 4 || uParam0->f_560 == 3)
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(2);
}
else
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(69);
}
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
uParam0->f_2 = 1;
}
if ((uParam0->f_56 > 0 && !uParam0->f_3) && uParam0->f_576 > 600)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_1, "TRANSITION_UP");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0.15f);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(true);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
uParam0->f_3 = 1;
}
}
func_71();
GRAPHICS::DRAW_SCALEFORM_MOVIE_FULLSCREEN(uParam0->f_1, 255, 255, 255, 255, 0);
}
fVar2 = ((uParam0->f_564 * uParam0->f_563) * (1f - uParam0->f_548));
fVar3 = 0f;
if (uParam0->f_571)
{
fVar3 = (((0.1388889f + func_74((2f * 2f))) * uParam0->f_572) * (1f - uParam0->f_548));
fVar2 = (fVar2 + (3f * fVar3));
}
if (uParam0->f_548 != 0f)
{
fVar4 = 0f;
if (fVar2 < fVar4)
{
fVar2 = fVar4;
}
}
else
{
fVar5 = 0f;
if (uParam0->f_30 >= 0.975f)
{
if (fVar2 < fVar5)
{
fVar2 = fVar5;
}
}
}
fVar1 = (0.3f * func_73());
if (uParam0->f_12)
{
fVar1 = 0.5f;
}
fVar6 = (*uParam0 * 2f);
if (uParam0->f_560 != 4)
{
fVar7 = func_70(&(uParam0->f_13));
if (fVar6 < fVar7)
{
fVar6 = (fVar7 + (3f * 0.006f));
}
if (GRAPHICS::_GET_ASPECT_RATIO(false) < 1.4f)
{
fVar6 = (fVar6 * 1.3f);
}
if (!MISC::IS_STRING_NULL_OR_EMPTY(&(uParam0->f_554)))
{
fVar7 = func_69(&(uParam0->f_550), &(uParam0->f_554));
}
else
{
fVar7 = func_70(&(uParam0->f_550));
}
fVar8 = (((0.119f + 0.05f) / func_73()) / 2.5f);
if ((uParam0->f_560 == 1 || uParam0->f_560 == 0) && uParam0->f_561 != 0)
{
if (fVar6 < (fVar7 + (2.6f * fVar8)))
{
fVar6 = (fVar7 + (2.6f * fVar8));
}
}
else if (uParam0->f_560 == 5)
{
if (fVar6 < (fVar7 + (2.6f * fVar8)))
{
fVar6 = (fVar7 + (2.6f * fVar8));
}
}
else if (fVar6 < (fVar7 + (1.9f * fVar8)))
{
fVar6 = (fVar7 + (2f * fVar8));
}
}
fVar9 = ((0.499f - (fVar6 / 2f)) + 0.006f);
fVar10 = ((0.499f + (fVar6 / 2f)) - 0.006f);
PAD::SET_INPUT_EXCLUSIVE(2, 215);
PAD::SET_INPUT_EXCLUSIVE(2, 216);
PAD::SET_INPUT_EXCLUSIVE(2, 200);
PAD::DISABLE_CONTROL_ACTION(2, 200, true);
if (uParam0->f_566 || uParam0->f_571)
{
if ((IntToFloat(uParam0->f_562) - (14000f * fParam1)) < IntToFloat(uParam0->f_576) || ((uParam0->f_571 && uParam0->f_563 > 0.95f) && (uParam0->f_562 - 10000) < uParam0->f_576))
{
if (uParam0->f_571)
{
if (uParam0->f_574 < 0)
{
uParam0->f_574 = (uParam0->f_574 * -1);
uParam0->f_574 = (uParam0->f_576 + uParam0->f_574);
}
if (uParam0->f_574 > 0)
{
if ((uParam0->f_574 - uParam0->f_576) > 0)
{
func_66((uParam0->f_574 - uParam0->f_576), "TIMER_TIME", 0, 0, -1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, -1);
}
else
{
uParam0->f_574 = 0;
uParam0->f_573 = 1;
uParam0->f_571 = 0;
uParam0->f_565 = 0;
uParam0->f_566 = 0;
uParam0->f_562 = uParam0->f_576 + 500;
uParam0->f_574 = 0;
}
}
if (uParam0->f_572 < 1f)
{
uParam0->f_572 = (uParam0->f_572 + (0f + ((1f / 0.166f) * SYSTEM::TIMESTEP())));
if (uParam0->f_572 > 1f)
{
uParam0->f_572 = 1f;
}
}
}
if (CAM::IS_SCREEN_FADED_OUT())
{
HUD::HIDE_LOADING_ON_FADE_THIS_FRAME();
}
if ((uParam0->f_4 != 0 && uParam0->f_548 < 0.1f) && uParam0->f_576 <= uParam0->f_562)
{
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(7);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(8);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(9);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(6);
GRAPHICS::DRAW_SCALEFORM_MOVIE_FULLSCREEN(uParam0->f_4, 255, 255, 255, iVar0, 0);
}
if (uParam0->f_571)
{
PAD::DISABLE_CONTROL_ACTION(0, 140, true);
PAD::DISABLE_CONTROL_ACTION(0, 141, true);
PAD::DISABLE_CONTROL_ACTION(0, 142, true);
PAD::DISABLE_CONTROL_ACTION(2, 188, true);
if (PAD::IS_DISABLED_CONTROL_JUST_PRESSED(2, 188))
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "CONTINUE", "HUD_FRONTEND_DEFAULT_SOUNDSET", false);
uParam0->f_571 = 0;
uParam0->f_565 = 0;
uParam0->f_566 = 0;
uParam0->f_562 = uParam0->f_576 + 500;
uParam0->f_573 = 3;
uParam0->f_574 = 0;
AUDIO::PLAY_SOUND_FRONTEND(-1, "continue", "HUD_FRONTEND_DEFAULT_SOUNDSET", false);
}
PAD::DISABLE_CONTROL_ACTION(2, 187, true);
if (PAD::IS_DISABLED_CONTROL_JUST_PRESSED(2, 187))
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "CONTINUE", "HUD_FRONTEND_DEFAULT_SOUNDSET", false);
uParam0->f_571 = 0;
uParam0->f_565 = 0;
uParam0->f_566 = 0;
uParam0->f_562 = uParam0->f_576 + 500;
uParam0->f_573 = 4;
uParam0->f_574 = 0;
AUDIO::PLAY_SOUND_FRONTEND(-1, "continue", "HUD_FRONTEND_DEFAULT_SOUNDSET", false);
}
PAD::DISABLE_CONTROL_ACTION(2, 202, true);
if (PAD::IS_DISABLED_CONTROL_JUST_PRESSED(2, 202))
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "CONTINUE", "HUD_FRONTEND_DEFAULT_SOUNDSET", false);
uParam0->f_571 = 0;
uParam0->f_565 = 0;
uParam0->f_566 = 0;
uParam0->f_562 = uParam0->f_576 + 500;
uParam0->f_573 = 2;
uParam0->f_574 = 0;
AUDIO::PLAY_SOUND_FRONTEND(-1, "continue", "HUD_FRONTEND_DEFAULT_SOUNDSET", false);
}
}
else if (uParam0->f_566)
{
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(7);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(8);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(9);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(6);
PAD::DISABLE_CONTROL_ACTION(0, 140, true);
PAD::DISABLE_CONTROL_ACTION(0, 141, true);
PAD::DISABLE_CONTROL_ACTION(0, 142, true);
if (PAD::IS_CONTROL_JUST_PRESSED(2, 215) || PAD::IS_DISABLED_CONTROL_JUST_PRESSED(2, 200))
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "CONTINUE", "HUD_FRONTEND_DEFAULT_SOUNDSET", false);
uParam0->f_566 = 0;
uParam0->f_565 = 0;
uParam0->f_562 = uParam0->f_576 + 500;
AUDIO::PLAY_SOUND_FRONTEND(-1, "continue", "HUD_FRONTEND_DEFAULT_SOUNDSET", false);
}
}
}
}
HUD::GET_HUD_COLOUR(1, &iVar13, &iVar14, &iVar15, &iVar16);
HUD::SET_TEXT_COLOUR(iVar13, iVar14, iVar15, iVar0);
HUD::SET_TEXT_WRAP(fVar9, fVar10);
HUD::SET_TEXT_JUSTIFICATION(0);
HUD::SET_TEXT_SCALE(1f, 0.4f);
fVar1 = (fVar1 - func_74(6f));
fVar1 = (fVar1 + (func_74(30f) - func_74((2f * 2f))));
fVar11 = (fVar2 - func_74((2f * 14f)));
if (fVar11 >= 0f)
{
fVar12 = func_49((fVar11 / (0.6f * func_74(25f))), 0f, 1f);
func_71();
GRAPHICS::DRAW_RECT(0.5f, (fVar1 - (func_74((2f - 0.5f)) - 0.001388889f)), fVar6, func_65(1f), iVar13, iVar14, iVar15, SYSTEM::ROUND((fVar12 * IntToFloat(iVar16))), false);
}
else
{
return;
}
fVar1 = (fVar1 + func_74((2f * 0.3f)));
if (uParam0->f_56 > 0)
{
fVar1 = (fVar1 + func_74((25f * 0.2f)));
}
iVar17 = 0;
iVar17 = 0;
while (iVar17 < uParam0->f_56)
{
fVar11 = (fVar2 - (fVar1 - (0.3f * func_73())));
if (fVar11 >= 0f)
{
fVar12 = func_49((fVar11 / (0.8f * func_74(25f))), 0f, 1f);
func_62(uParam0, iVar17, (fVar1 + func_74(2f)), fVar9, fVar10, SYSTEM::ROUND((IntToFloat(iVar0) * fVar12)));
}
else
{
return;
}
fVar1 = (fVar1 + func_74(25f));
if (uParam0->f_560 == 4)
{
if (iVar17 == (uParam0->f_580 - 1))
{
fVar1 = (fVar1 + func_74((25f * 0.2f)));
fVar11 = (fVar2 - (fVar1 - (0.3f * func_73())));
if (fVar11 >= 0f)
{
fVar1 = (fVar1 + func_74(2f));
fVar12 = func_49((fVar11 / (0.6f * func_74(25f))), 0f, 1f);
func_71();
GRAPHICS::DRAW_RECT(0.5f, (fVar1 + func_74((2f * 0.5f))), fVar6, func_65(1f), iVar13, iVar14, iVar15, SYSTEM::ROUND((fVar12 * IntToFloat(iVar16))), false);
fVar1 = (fVar1 + func_74((2f * 0.3f)));
if (uParam0->f_56 > 0)
{
fVar1 = (fVar1 + func_74((25f * 0.2f)));
}
}
}
}
iVar17++;
}
if (uParam0->f_560 == 4)
{
return;
}
if (uParam0->f_56 > 0)
{
fVar1 = (fVar1 + func_74((25f * 0.2f)));
fVar11 = (fVar2 - (fVar1 - (0.3f * func_73())));
if (fVar11 >= 0f)
{
fVar1 = (fVar1 + func_74(2f));
fVar12 = func_49((fVar11 / (0.6f * func_74(25f))), 0f, 1f);
func_71();
GRAPHICS::DRAW_RECT(0.5f, (fVar1 + func_74((2f * 0.5f))), fVar6, func_65(1f), iVar13, iVar14, iVar15, SYSTEM::ROUND((fVar12 * IntToFloat(iVar16))), false);
}
}
if (uParam0->f_549)
{
fVar1 = (fVar1 + func_74((25f * 0.2f)));
fVar11 = (fVar2 - (fVar1 - (0.3f * func_73())));
if (fVar11 >= 0f)
{
fVar12 = func_49((fVar11 / (0.8f * func_74(25f))), 0f, 1f);
HUD::SET_TEXT_COLOUR(iVar13, iVar14, iVar15, SYSTEM::ROUND((fVar12 * IntToFloat(iVar0))));
func_54(7, 0, 1, &fVar18, &fVar19, 0);
fVar20 = fVar9;
fVar21 = fVar10;
if (LOCALIZATION::GET_CURRENT_LANGUAGE() == 0)
{
fVar20 = (fVar9 + ((0.119f / func_73()) / 2.5f));
fVar21 = (fVar10 - ((0.119f / func_73()) / 2.5f));
if (uParam0->f_560 == 1)
{
fVar20 = (fVar9 + (((0.119f + 0.05f) / func_73()) / 2.5f));
fVar21 = (fVar10 - (((0.119f + 0.05f) / func_73()) / 2.5f));
}
}
if (uParam0->f_561 == 0)
{
fVar20 = (fVar20 + (((fVar18 * 0.28f) + 0.006f) / 2f));
fVar21 = (fVar21 + (((fVar18 * 0.28f) + 0.006f) / 2f));
}
if (uParam0->f_560 != 3)
{
HUD::SET_TEXT_WRAP(fVar20, fVar21);
HUD::SET_TEXT_JUSTIFICATION(1);
}
else
{
fVar20 = 0.5f;
HUD::SET_TEXT_JUSTIFICATION(0);
}
HUD::SET_TEXT_SCALE(1f, 0.4f);
if (MISC::IS_STRING_NULL_OR_EMPTY(&(uParam0->f_554)))
{
func_53(&(uParam0->f_550), fVar20, (fVar1 + func_74((2f * 2f))), 0, 0, 0);
}
else
{
func_52(&(uParam0->f_550), &(uParam0->f_554), fVar20, (fVar1 + func_74((2f * 2f))), 0, 0);
}
HUD::SET_TEXT_WRAP(fVar20, fVar21);
HUD::SET_TEXT_JUSTIFICATION(2);
HUD::SET_TEXT_SCALE(1f, 0.4f);
HUD::SET_TEXT_CENTRE(false);
func_71();
fVar22 = fVar21;
StringCopy(&cVar23, "MPHud", 16);
StringCopy(&cVar27, "MissionPassedMedal", 32);
fVar22 = (fVar22 - ((fVar18 * 0.28f) + 0.006f));
HUD::SET_TEXT_WRAP(fVar20, fVar22);
HUD::SET_TEXT_COLOUR(iVar13, iVar14, iVar15, SYSTEM::ROUND((fVar12 * IntToFloat(iVar0))));
switch (uParam0->f_560)
{
case 0:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("PERCENTAGE");
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_558);
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fVar20, (fVar1 + func_74((2f * 2f))), 0);
break;
case 1:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("FO_TWO_NUM");
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_558);
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_559);
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fVar20, (fVar1 + func_74((2f * 2f))), 0);
break;
case 2:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("MTPHPER_XPNO");
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_558);
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fVar20, (fVar1 + func_74((2f * 2f))), 0);
break;
case 5:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("ESDOLLA");
HUD::ADD_TEXT_COMPONENT_FORMATTED_INTEGER(uParam0->f_558, true);
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fVar20, (fVar1 + func_74((2f * 2f))), 0);
break;
}
if (uParam0->f_561 != 0)
{
iVar35 = 255;
iVar36 = 255;
iVar37 = 255;
iVar38 = iVar0;
switch (uParam0->f_561)
{
case 1:
HUD::GET_HUD_COLOUR(107, &iVar35, &iVar36, &iVar37, &iVar38);
break;
case 3:
HUD::GET_HUD_COLOUR(109, &iVar35, &iVar36, &iVar37, &iVar38);
break;
case 2:
HUD::GET_HUD_COLOUR(108, &iVar35, &iVar36, &iVar37, &iVar38);
break;
}
fVar39 = (0.001388889f * 5f);
fVar40 = ((0.00078125f * 16f) * 2f);
fVar41 = ((0.001388889f * 16f) * 2f);
fVar42 = ((fVar21 + func_51(4f)) - 0.006f);
fVar43 = ((fVar1 + func_74(10f)) + fVar39);
if (uParam0->f_560 == -1)
{
fVar42 = (fVar42 - (0.006f * 6f));
}
fVar40 = (fVar40 * 0.65f);
fVar41 = (fVar41 * 0.65f);
GRAPHICS::DRAW_SPRITE(&cVar23, &cVar27, fVar42, fVar43, fVar40, fVar41, 0f, iVar35, iVar36, iVar37, SYSTEM::ROUND((fVar12 * IntToFloat(iVar0))), false, 0);
}
fVar1 = (fVar1 + (func_74(30f) - 2f));
}
}
}
float func_51(float fParam0)
{
return (fParam0 * 0.00078125f);
}
void func_52(char* sParam0, char* sParam1, float fParam2, float fParam3, bool bParam4, int iParam5)
{
HUD::SET_TEXT_CENTRE(bParam4);
HUD::SET_TEXT_FONT(iParam5);
func_71();
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(sParam0);
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(sParam1);
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fParam2, fParam3, 0);
}
void func_53(char* sParam0, float fParam1, float fParam2, bool bParam3, bool bParam4, int iParam5)
{
HUD::SET_TEXT_CENTRE(bParam3);
HUD::SET_TEXT_FONT(iParam5);
func_71();
if (bParam4)
{
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(sParam0);
}
else
{
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(sParam0);
}
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fParam1, fParam2, 0);
}
int func_54(int iParam0, bool bParam1, bool bParam2, float fParam3, float fParam4, bool bParam5)
{
char cVar0[64];
char cVar16[64];
int iVar32;
int iVar33;
float fVar34;
struct<3> Var35;
float fVar38;
StringCopy(&cVar0, func_61(iParam0), 64);
StringCopy(&cVar16, func_58(iParam0, bParam1), 64);
if (MISC::GET_HASH_KEY(&cVar16) != 0)
{
fVar34 = 1f;
func_56(bParam5, &iVar32, &iVar33, &fVar34);
Var35 = { GRAPHICS::GET_TEXTURE_RESOLUTION(&cVar0, &cVar16) };
fVar38 = (func_55(iParam0) / fVar34);
Var35 = { Var35 * Vector(fVar38, fVar38, fVar38) };
if (!bParam2)
{
Var35.f_0 = (Var35.f_0 - 2f);
Var35.f_1 = (Var35.f_1 - 2f);
}
if (iParam0 == 30)
{
Var35.f_0 = 288f;
Var35.f_1 = 106f;
}
if (iParam0 == 29 && MISC::GET_HASH_KEY(&(Global_22830.f_7292[29 /*16*/])) == joaat("CREW_LOGO"))
{
Var35.f_0 = 106f;
Var35.f_1 = 106f;
}
*fParam3 = ((Var35.f_0 / IntToFloat(iVar32)) * IntToFloat((iVar32 / iVar33)));
*fParam4 = (((Var35.f_1 / IntToFloat(iVar33)) / (Var35.f_0 / IntToFloat(iVar32))) * *fParam3);
if (!bParam5)
{
if (!GRAPHICS::GET_IS_WIDESCREEN() && iParam0 != 30)
{
*fParam3 = (*fParam3 * 1.33f);
}
}
if (iParam0 == 29)
{
if (*fParam3 > Global_22829)
{
*fParam4 = (*fParam4 * (Global_22829 / *fParam3));
*fParam3 = Global_22829;
}
}
return 1;
}
return 0;
}
float func_55(int iParam0)
{
switch (iParam0)
{
case 33:
case 4:
case 11:
case 31:
case 20:
case 15:
case 10:
case 12:
case 13:
case 32:
case 9:
case 5:
case 6:
case 7:
case 14:
case 18:
case 19:
case 17:
case 28:
case 26:
case 27:
case 52:
case 56:
case 57:
case 58:
case 59:
case 60:
case 62:
return 0.5f;
break;
case 61:
return 0.8f;
break;
}
return 1f;
}
void func_56(bool bParam0, int* iParam1, int* iParam2, float fParam3)
{
float fVar0;
float fVar1;
float fVar2;
if (!bParam0)
{
GRAPHICS::GET_SCREEN_RESOLUTION(iParam1, iParam2);
return;
}
GRAPHICS::_GET_ACTIVE_SCREEN_RESOLUTION(iParam1, iParam2);
fVar0 = SYSTEM::TO_FLOAT(*iParam1);
fVar1 = SYSTEM::TO_FLOAT(*iParam2);
fVar2 = GRAPHICS::_GET_ASPECT_RATIO(false);
if (func_57(*iParam1, *iParam2))
{
*fParam3 = 1f;
*iParam1 = SYSTEM::ROUND((fVar1 * fVar2));
*iParam2 = SYSTEM::ROUND(fVar1);
return;
}
*fParam3 = ((fVar0 / fVar1) / fVar2);
*iParam1 = SYSTEM::ROUND((fVar0 / *fParam3));
*iParam2 = SYSTEM::ROUND((fVar1 / *fParam3));
}
bool func_57(int iParam0, int iParam1)
{
return (SYSTEM::TO_FLOAT(iParam0) / SYSTEM::TO_FLOAT(iParam1)) > 3.5f;
}
var func_58(int iParam0, bool bParam1)
{
char* sVar0[2];
var uVar3;
struct<13> Var19;
if (!MISC::IS_STRING_NULL_OR_EMPTY(&(Global_22830.f_7292[iParam0 /*16*/])))
{
if (MISC::GET_HASH_KEY(&(Global_22830.f_7292[iParam0 /*16*/])) == joaat("CREW_LOGO"))
{
Var19 = { func_60(PLAYER::PLAYER_ID()) };
if (NETWORK::NETWORK_CLAN_GET_EMBLEM_TXD_NAME(&Var19, &uVar3))
{
return func_59(&uVar3);
}
}
else
{
return func_59(&(Global_22830.f_7292[iParam0 /*16*/]));
}
}
switch (iParam0)
{
case 3:
sVar0[0] = "MP_hostCrown";
sVar0[1] = "MP_hostCrown";
break;
case 21:
sVar0[0] = "MP_SpecItem_Coke";
sVar0[1] = "MP_SpecItem_Coke";
break;
case 22:
sVar0[0] = "MP_SpecItem_Heroin";
sVar0[1] = "MP_SpecItem_Heroin";
break;
case 23:
sVar0[0] = "MP_SpecItem_Weed";
sVar0[1] = "MP_SpecItem_Weed";
break;
case 24:
sVar0[0] = "MP_SpecItem_Meth";
sVar0[1] = "MP_SpecItem_Meth";
break;
case 25:
sVar0[0] = "MP_SpecItem_Cash";
sVar0[1] = "MP_SpecItem_Cash";
break;
case 1:
sVar0[0] = "shop_NEW_Star";
sVar0[1] = "shop_NEW_Star";
break;
case 2:
sVar0[0] = "shop_NEW_Star";
sVar0[1] = "shop_NEW_Star";
break;
case 4:
sVar0[0] = "Shop_Tick_Icon";
sVar0[1] = "Shop_Tick_Icon";
break;
case 6:
sVar0[0] = "Shop_Box_CrossB";
sVar0[1] = "Shop_Box_Cross";
break;
case 7:
sVar0[0] = "Shop_Box_BlankB";
sVar0[1] = "Shop_Box_Blank";
break;
case 5:
sVar0[0] = "Shop_Box_TickB";
sVar0[1] = "Shop_Box_Tick";
break;
case 8:
sVar0[0] = "shop_NEW_Star";
sVar0[1] = "shop_NEW_Star";
break;
case 9:
sVar0[0] = "Shop_Clothing_Icon_B";
sVar0[1] = "Shop_Clothing_Icon_A";
break;
case 10:
sVar0[0] = "Shop_GunClub_Icon_B";
sVar0[1] = "Shop_GunClub_Icon_A";
break;
case 17:
sVar0[0] = "Shop_Ammo_Icon_B";
sVar0[1] = "Shop_Ammo_Icon_A";
break;
case 18:
sVar0[0] = "Shop_Armour_Icon_B";
sVar0[1] = "Shop_Armour_Icon_A";
break;
case 19:
sVar0[0] = "Shop_Health_Icon_B";
sVar0[1] = "Shop_Health_Icon_A";
break;
case 20:
sVar0[0] = "Shop_MakeUp_Icon_B";
sVar0[1] = "Shop_MakeUp_Icon_A";
break;
case 11:
sVar0[0] = "Shop_Tattoos_Icon_B";
sVar0[1] = "Shop_Tattoos_Icon_A";
break;
case 12:
sVar0[0] = "Shop_Garage_Icon_B";
sVar0[1] = "Shop_Garage_Icon_A";
break;
case 13:
sVar0[0] = "Shop_Garage_Bike_Icon_B";
sVar0[1] = "Shop_Garage_Bike_Icon_A";
break;
case 14:
sVar0[0] = "Shop_Barber_Icon_B";
sVar0[1] = "Shop_Barber_Icon_A";
break;
case 15:
sVar0[0] = "shop_Lock";
sVar0[1] = "shop_Lock";
break;
case 16:
sVar0[0] = "Shop_Tick_Icon";
sVar0[1] = "Shop_Tick_Icon";
break;
case 26:
sVar0[0] = "arrowleft";
sVar0[1] = "arrowleft";
break;
case 27:
sVar0[0] = "arrowright";
sVar0[1] = "arrowright";
break;
case 28:
sVar0[0] = "MP_AlertTriangle";
sVar0[1] = "MP_AlertTriangle";
break;
case 29:
sVar0[0] = "shop_NEW_Star";
sVar0[1] = "shop_NEW_Star";
break;
case 31:
sVar0[0] = "Shop_Michael_Icon_B";
sVar0[1] = "Shop_Michael_Icon_A";
break;
case 32:
sVar0[0] = "Shop_Franklin_Icon_B";
sVar0[1] = "Shop_Franklin_Icon_A";
break;
case 33:
sVar0[0] = "Shop_Trevor_Icon_B";
sVar0[1] = "Shop_Trevor_Icon_A";
break;
case 51:
sVar0[0] = "SaleIcon";
sVar0[1] = "SaleIcon";
break;
case 52:
sVar0[0] = "Shop_Tick_Icon";
sVar0[1] = "Shop_Tick_Icon";
break;
case 54:
sVar0[0] = "shop_NEW_Star";
sVar0[1] = "shop_NEW_Star";
break;
case 55:
sVar0[0] = "Shop_Lock_Arena";
sVar0[1] = "Shop_Lock_Arena";
break;
case 56:
sVar0[0] = "Card_Suit_Clubs";
sVar0[1] = "Card_Suit_Clubs";
break;
case 57:
sVar0[0] = "Card_Suit_Hearts";
sVar0[1] = "Card_Suit_Hearts";
break;
case 58:
sVar0[0] = "Card_Suit_Spades";
sVar0[1] = "Card_Suit_Spades";
break;
case 59:
sVar0[0] = "Card_Suit_Diamonds";
sVar0[1] = "Card_Suit_Diamonds";
break;
case 60:
sVar0[0] = "Shop_Art_Icon_B";
sVar0[1] = "Shop_Art_Icon_A";
break;
case 62:
sVar0[0] = "Shop_Art_Icon_B";
sVar0[1] = "Shop_Art_Icon_A";
break;
case 61:
sVar0[0] = "Shop_Chips_A";
sVar0[1] = "Shop_Chips_B";
break;
case 0:
sVar0[0] = "";
sVar0[1] = "";
break;
}
if (bParam1)
{
return sVar0[0];
}
return sVar0[1];
}
var func_59(var uParam0)
{
return uParam0;
}
struct<13> func_60(int iParam0)
{
struct<13> Var0;
NETWORK::NETWORK_HANDLE_FROM_PLAYER(iParam0, &Var0, 13);
return Var0;
}
char* func_61(int iParam0)
{
var uVar0;
struct<13> Var16;
if (!MISC::IS_STRING_NULL_OR_EMPTY(&(Global_22830.f_6283[iParam0 /*16*/])))
{
if (MISC::GET_HASH_KEY(&(Global_22830.f_6283[iParam0 /*16*/])) == joaat("CREW_LOGO"))
{
Var16 = { func_60(PLAYER::PLAYER_ID()) };
NETWORK::NETWORK_CLAN_GET_EMBLEM_TXD_NAME(&Var16, &uVar0);
return func_59(&uVar0);
}
else
{
return func_59(&(Global_22830.f_6283[iParam0 /*16*/]));
}
}
if (iParam0 == 51)
{
return "MPShopSale";
}
return "CommonMenu";
}
void func_62(var uParam0, int iParam1, float fParam2, float fParam3, float fParam4, int iParam5)
{
int iVar0;
int iVar1;
int iVar2;
var uVar3;
float fVar4;
float fVar5;
float fVar6;
HUD::GET_HUD_COLOUR(1, &iVar0, &iVar1, &iVar2, &uVar3);
HUD::SET_TEXT_COLOUR(iVar0, iVar1, iVar2, iParam5);
HUD::SET_TEXT_WRAP(fParam3, fParam4);
HUD::SET_TEXT_JUSTIFICATION(1);
HUD::SET_TEXT_SCALE(1f, func_64(14f));
HUD::SET_TEXT_CENTRE(false);
HUD::SET_TEXT_FONT(0);
func_71();
if (uParam0->f_531[iParam1])
{
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(&(uParam0->f_71[iParam1 /*16*/]));
}
else
{
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(&(uParam0->f_71[iParam1 /*16*/]));
if (uParam0->f_57[iParam1] == 16 || uParam0->f_57[iParam1] == 17)
{
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_489[iParam1]);
}
}
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fParam3, fParam2, 0);
fVar4 = fParam4;
switch (uParam0->f_517[iParam1])
{
case 0:
break;
case 1:
func_54(7, 0, 1, &fVar5, &fVar6, 0);
GRAPHICS::DRAW_SPRITE("CommonMenu", func_58(7, 0), (fParam4 - 0.006f), ((fParam2 + func_74(2f)) + (0.25f * fVar6)), fVar5, fVar6, 0f, 255, 255, 255, iParam5, false, 0);
fVar4 = (fVar4 - ((fVar5 * 0.38f) + 0.006f));
break;
case 2:
func_54(5, 0, 1, &fVar5, &fVar6, 0);
GRAPHICS::DRAW_SPRITE("CommonMenu", func_58(5, 0), (fParam4 - 0.006f), ((fParam2 + func_74(2f)) + (0.25f * fVar6)), fVar5, fVar6, 0f, 255, 255, 255, iParam5, false, 0);
fVar4 = (fVar4 - ((fVar5 * 0.38f) + 0.006f));
break;
case 3:
func_54(6, 0, 1, &fVar5, &fVar6, 0);
GRAPHICS::DRAW_SPRITE("CommonMenu", func_58(6, 0), (fParam4 - 0.006f), ((fParam2 + func_74(2f)) + (0.25f * fVar6)), fVar5, fVar6, 0f, 255, 255, 255, iParam5, false, 0);
fVar4 = (fVar4 - ((fVar5 * 0.38f) + 0.006f));
break;
}
if (uParam0->f_57[iParam1] == 0)
{
return;
}
if (uParam0->f_57[iParam1] == 15)
{
HUD::SET_TEXT_JUSTIFICATION(1);
}
else
{
HUD::SET_TEXT_JUSTIFICATION(2);
}
HUD::SET_TEXT_SCALE(1f, func_64(14f));
if (uParam0->f_57[iParam1] == 5 || uParam0->f_57[iParam1] == 4)
{
HUD::SET_TEXT_WRAP(fParam3, (fVar4 - (0.00078125f * 3f)));
}
else
{
HUD::SET_TEXT_WRAP(fParam3, (fVar4 + (0.00078125f * 2f)));
}
HUD::SET_TEXT_COLOUR(iVar0, iVar1, iVar2, iParam5);
func_63(uParam0->f_489[iParam1], uParam0->f_503[iParam1], fParam4, fParam2, &(uParam0->f_280[iParam1 /*16*/]), uParam0->f_57[iParam1]);
}
void func_63(int iParam0, int iParam1, float fParam2, float fParam3, char* sParam4, int iParam5)
{
int iVar0;
float fVar1;
float fVar2;
float fVar3;
int iVar4;
int iVar5;
int iVar6;
iVar0 = 1;
HUD::SET_TEXT_CENTRE(false);
HUD::SET_TEXT_FONT(0);
func_71();
fVar1 = 0f;
fVar2 = (8f * 0.00078125f);
fVar3 = (16f * 0.001388889f);
iVar4 = 93;
iVar5 = 182;
iVar6 = 229;
if (iParam5 == 4)
{
iVar4 = 194;
iVar5 = 80;
iVar6 = 80;
}
switch (iParam5)
{
case 4:
case 5:
HUD::SET_TEXT_SCALE(1f, func_64(18f));
HUD::SET_TEXT_FONT(4);
if (iParam0 < 0)
{
HUD::_BEGIN_TEXT_COMMAND_GET_WIDTH("ESMINDOLLA");
HUD::ADD_TEXT_COMPONENT_FORMATTED_INTEGER((-1 * iParam0), true);
fVar1 = HUD::_END_TEXT_COMMAND_GET_WIDTH(false);
}
else
{
HUD::_BEGIN_TEXT_COMMAND_GET_WIDTH("ESDOLLA");
HUD::ADD_TEXT_COMPONENT_FORMATTED_INTEGER(iParam0, true);
fVar1 = HUD::_END_TEXT_COMMAND_GET_WIDTH(false);
}
fVar1 = (fVar1 - (fVar1 % 0.00078125f));
GRAPHICS::DRAW_SPRITE("CommonMenu", "BettingBox_Left", (fParam2 - fVar1), ((fParam3 + (fVar3 * 0.6f)) + (0.001388889f * 2f)), fVar2, fVar3, 0f, iVar4, iVar5, iVar6, 255, false, 0);
GRAPHICS::DRAW_SPRITE("CommonMenu", "BettingBox_Centre", ((fParam2 - (fVar1 * 0.5f)) - (0.00078125f * 2f)), ((fParam3 + (fVar3 * 0.6f)) + (0.001388889f * 2f)), (fVar1 - (fVar2 * 0.5f)), fVar3, 0f, iVar4, iVar5, iVar6, 255, false, 0);
GRAPHICS::DRAW_SPRITE("CommonMenu", "BettingBox_Right", (fParam2 - (0.00078125f * 4f)), ((fParam3 + (fVar3 * 0.6f)) + (0.001388889f * 2f)), fVar2, fVar3, 0f, iVar4, iVar5, iVar6, 255, false, 0);
HUD::SET_TEXT_SCALE(1f, func_64(14f));
break;
}
HUD::SET_COLOUR_OF_NEXT_TEXT_COMPONENT(iVar0);
switch (iParam5)
{
case 11:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("PERCENTAGE");
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam0);
break;
case 1:
HUD::SET_TEXT_FONT(5);
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("FO_NUM");
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam0);
break;
case 2:
HUD::SET_TEXT_FONT(5);
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("FO_TWO_NUM");
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam0);
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam1);
break;
case 4:
case 5:
HUD::SET_TEXT_SCALE(1f, func_64(18f));
case 3:
if (iParam0 < 0)
{
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("ESMINDOLLA");
HUD::ADD_TEXT_COMPONENT_FORMATTED_INTEGER((-1 * iParam0), true);
}
else
{
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("ESDOLLA");
HUD::ADD_TEXT_COMPONENT_FORMATTED_INTEGER(iParam0, true);
}
break;
case 6:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(sParam4);
break;
case 7:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(sParam4);
break;
case 8:
HUD::SET_TEXT_FONT(5);
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam0, 14);
break;
case 9:
HUD::SET_TEXT_FONT(5);
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam0, 6);
break;
case 10:
HUD::SET_TEXT_FONT(5);
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam0, 2055);
break;
case 18:
HUD::SET_TEXT_FONT(5);
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam0, 2055);
break;
case 12:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT("AHD_DIST");
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam0);
break;
case 13:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(sParam4);
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam0);
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam1);
break;
case 15:
case 14:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(sParam4);
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam0);
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam1);
break;
case 16:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(sParam4);
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam1);
break;
case 20:
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(sParam4);
break;
}
if (iParam5 != 17)
{
if (iParam5 == 4 || iParam5 == 5)
{
HUD::END_TEXT_COMMAND_DISPLAY_TEXT((fParam2 - (0.00078125f * 4f)), fParam3, 0);
HUD::SET_TEXT_SCALE(1f, func_64(14f));
}
else
{
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fParam2, fParam3, 0);
}
}
}
float func_64(float fParam0)
{
return (fParam0 * 0.025f);
}
float func_65(float fParam0)
{
return (fParam0 * 0.0009259259f);
}
void func_66(int iParam0, char* sParam1, int iParam2, int iParam3, int iParam4, int iParam5, int iParam6, int iParam7, int iParam8, int iParam9, int iParam10, int iParam11, int iParam12, int iParam13, int iParam14, int iParam15, int iParam16, int iParam17)
{
bool bVar0;
int iVar1;
bVar0 = -1;
iVar1 = 0;
while (iVar1 <= 9)
{
if (bVar0 == -1)
{
if (func_68(7, iVar1) == 0)
{
bVar0 = iVar1;
}
}
iVar1++;
}
if (bVar0 > -1)
{
Global_1645748.f_1 = 1;
func_67(7, bVar0);
Global_1645748.f_4617[bVar0] = iParam0;
StringCopy(&(Global_1645748.f_4617.f_11[bVar0 /*16*/]), sParam1, 64);
Global_1645748.f_4617.f_172[bVar0] = iParam2;
Global_1645748.f_4617.f_216[bVar0] = iParam3;
Global_1645748.f_4617.f_183[bVar0] = iParam4;
Global_1645748.f_4617.f_194[bVar0] = iParam5;
Global_1645748.f_4617.f_249[bVar0] = iParam6;
Global_1645748.f_4617.f_260[bVar0] = iParam7;
Global_1645748.f_4617.f_205[bVar0] = iParam8;
Global_1645748.f_4617.f_314[bVar0] = iParam9;
Global_1645748.f_4617.f_325[bVar0] = iParam10;
Global_1645748.f_4617.f_357[bVar0] = iParam11;
Global_1645748.f_4617.f_238[bVar0] = iParam12;
Global_1645748.f_4617.f_271[bVar0] = iParam13;
Global_1645748.f_4617.f_368[bVar0] = iParam14;
Global_1645748.f_4617.f_379[bVar0] = iParam15;
Global_1645748.f_4617.f_390[bVar0] = iParam16;
Global_1645748.f_4617.f_227[bVar0] = iParam17;
}
}
void func_67(int iParam0, bool bParam1)
{
MISC::SET_BIT(&(Global_1645748.f_6736[iParam0]), bParam1);
}
int func_68(int iParam0, int iParam1)
{
return BitTest(Global_1645748.f_6736[iParam0], iParam1);
}
float func_69(char* sParam0, char* sParam1)
{
HUD::_BEGIN_TEXT_COMMAND_GET_WIDTH(sParam0);
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(sParam1);
return (HUD::_END_TEXT_COMMAND_GET_WIDTH(true) / 2f);
}
float func_70(char* sParam0)
{
HUD::_BEGIN_TEXT_COMMAND_GET_WIDTH(sParam0);
return (HUD::_END_TEXT_COMMAND_GET_WIDTH(true) / 2f);
}
void func_71()
{
GRAPHICS::SET_SCRIPT_GFX_DRAW_ORDER(1);
if (CAM::IS_SCREEN_FADING_OUT() || CAM::IS_SCREEN_FADED_OUT())
{
GRAPHICS::SET_SCRIPT_GFX_DRAW_ORDER(7);
}
GRAPHICS::SET_SCRIPT_GFX_DRAW_BEHIND_PAUSEMENU(false);
}
void func_72(char* sParam0)
{
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_PLAYER_NAME_STRING(sParam0);
}
float func_73()
{
float fVar0;
fVar0 = 1f;
if (MISC::IS_PC_VERSION())
{
}
return fVar0;
}
float func_74(float fParam0)
{
return (fParam0 * 0.001388889f);
}
void func_75(int iParam0)
{
if (func_31())
{
return;
}
if (!Global_19954.f_1 == 1)
{
if (func_32(0))
{
func_27(iParam0);
}
MISC::SET_BIT(&Global_7825, 2);
}
}
void func_76(var uParam0)
{
if (uParam0->f_565 || uParam0->f_576 <= uParam0->f_562)
{
uParam0->f_565 = 0;
uParam0->f_562 = (uParam0->f_576 - 1);
}
}
bool func_77()
{
return Global_100019.f_1;
}
void func_78(var uParam0, var uParam1, int* iParam2, int* iParam3, int* iParam4, int iParam5, int iParam6, var uParam7, int* iParam8, int iParam9, int iParam10, int iParam11, int iParam12, int iParam13, int iParam14, bool bParam15, int iParam16, bool bParam17)
{
func_560(uParam0, uParam1, iParam2, iParam3, iParam4, iParam5, &iParam6, uParam7, iParam8, iParam9, iParam10, iParam11, iParam12, iParam13, iParam14, bParam15, iParam16, bParam17);
}
int func_79(bool bParam0, int* iParam1, var uParam2, var uParam3, int iParam4, int iParam5, int iParam6, int iParam7, float fParam8, int iParam9)
{
if (!func_263(iParam1, 5))
{
HUD::CLEAR_HELP(true);
func_185(iParam1, func_189(bParam0), iParam4, (iParam5 - 1), iParam6, iParam7, fParam8);
func_214(iParam1, 0, 215, "BJ_CONTINUE", 216, "BJ_RETRY", 361, 0, 361, 0);
func_221(iParam1, 5, 1);
SYSTEM::SETTIMERA(0);
}
if (!func_263(iParam1, 6))
{
if (func_181(&(iParam1->f_26), 0, 0))
{
func_221(iParam1, 6, 1);
}
else
{
return 2;
}
}
if (func_263(iParam1, 27) && PLAYER::IS_PLAYER_ONLINE())
{
if (!func_263(iParam1, 26))
{
func_214(iParam1, 0, 215, "BJ_CONTINUE", 216, "BJ_RETRY", 361, 0, 361, 0);
}
func_221(iParam1, 27, 0);
}
if (SYSTEM::TIMERA() > 1000)
{
if (*iParam9)
{
if (PLAYER::IS_PLAYER_ONLINE())
{
func_99(uParam2, bParam0);
func_95(iParam1);
}
else if (func_81(&iLocal_581, 0))
{
iLocal_581 = 0;
*iParam9 = 0;
func_214(iParam1, 0, 215, "BJ_CONTINUE", 216, "BJ_RETRY", 211, "HUD_INPUT68", 361, 0);
}
}
else
{
if (!func_263(iParam1, 10))
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "BASE_JUMP_PASSED", "HUD_AWARDS", true);
func_221(iParam1, 10, 1);
}
func_47(&(iParam1->f_26), 0, 1065353216, 0, 1, 0);
func_95(iParam1);
}
if (*iParam9)
{
if (PLAYER::IS_PLAYER_ONLINE())
{
if (!func_263(iParam1, 28) && func_80(&uLocal_144))
{
func_221(iParam1, 28, 1);
func_214(iParam1, 0, 202, "HUD_INPUT53", 217, "SCLB_PROFILE", 361, 0, 361, 0);
}
}
if (func_328(uParam3, 7, 1000))
{
*iParam9 = 0;
func_214(iParam1, 0, 215, "BJ_CONTINUE", 216, "BJ_RETRY", 211, "HUD_INPUT68", 361, 0);
}
}
else if (func_328(uParam3, 5, 1000))
{
func_76(&(iParam1->f_26));
return 1;
}
else if (func_328(uParam3, 4, 1000))
{
return 0;
}
else if ((!*iParam9 && func_328(uParam3, 8, 1000)) && (!PLAYER::IS_PLAYER_ONLINE() || func_263(iParam1, 26)))
{
*iParam9 = 1;
if (PLAYER::IS_PLAYER_ONLINE())
{
if (func_80(&uLocal_144))
{
func_221(iParam1, 28, 1);
func_214(iParam1, 0, 202, "HUD_INPUT53", 217, "SCLB_PROFILE", 361, 0, 361, 0);
}
else
{
func_221(iParam1, 28, 0);
func_214(iParam1, 0, 202, "HUD_INPUT53", 361, 0, 361, 0, 361, 0);
}
}
}
}
return 2;
}
int func_80(var uParam0)
{
if ((BitTest(uParam0->f_42, 1) && Global_2097536.f_2704[0] > 0) && uParam0->f_246.f_1 >= 0)
{
return 1;
}
return 0;
}
int func_81(int* iParam0, bool bParam1)
{
int iVar0;
int iVar1;
bool bVar2;
iVar0 = 2;
if (Global_2103068.f_2 + 5 < MISC::GET_FRAME_COUNT() && Global_2103068.f_2 > 0)
{
func_94(&Global_2103068);
func_94(&(Global_2103068.f_49));
*iParam0 = 0;
Global_2103068.f_2 = 0;
func_93(0);
}
Global_2103068.f_2 = MISC::GET_FRAME_COUNT();
iVar1 = -1;
if (func_92())
{
if (NETWORK::_0xBD545D44CCE70597() == 0)
{
iVar1 = NETWORK::_0x74FB3E29E6D10FA9();
}
}
if ((func_92() && (((iVar1 == 4 || iVar1 == 2) || iVar1 == 1) || iVar1 == 5)) || (!func_90() && NETWORK::NETWORK_IS_SIGNED_ONLINE()))
{
if (NETWORK::_0x8D11E61A4ABF49CC())
{
func_87(&(Global_2103068.f_3), func_89(&(Global_2103068.f_3)));
if (!BitTest(*iParam0, 4))
{
MISC::SET_BIT(iParam0, 4);
StringCopy(&(Global_2103068.f_3.f_1), "", 64);
func_85(&(Global_2103068.f_3), 0);
}
}
else
{
if (iVar1 == 4)
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "HUD_PROFILECHNG", iVar0, 0, false, -1, 0, 0, true, 0);
}
else if (iVar1 == 2)
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "HUD_GAMEUPD_G", iVar0, 0, false, -1, 0, 0, true, 0);
}
else if (iVar1 == 1)
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "HUD_SYSTUPD_G", iVar0, 0, false, -1, 0, 0, true, 0);
}
else if (iVar1 == 5)
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "SCLB_NO_INT", iVar0, 0, false, -1, 0, 0, true, 0);
}
else if (!func_90())
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "SCLB_NO_ROS", iVar0, 0, false, -1, 0, 0, true, 0);
}
if (!BitTest(*iParam0, 0))
{
if (!PAD::IS_CONTROL_PRESSED(2, 201))
{
MISC::SET_BIT(iParam0, false);
}
}
else if (PAD::IS_CONTROL_JUST_RELEASED(2, 201))
{
func_94(&(Global_2103068.f_49));
func_94(&Global_2103068);
*iParam0 = 0;
Global_2103068.f_2 = 0;
func_93(0);
return 1;
}
}
}
else
{
func_87(&(Global_2103068.f_3), func_89(&(Global_2103068.f_3)));
if ((func_84(&(Global_2103068.f_49)) && !func_82(&(Global_2103068.f_49), 2000, 1)) && !NETWORK::NETWORK_IS_SIGNED_ONLINE())
{
MISC::SET_BIT(iParam0, 3);
StringCopy(&(Global_2103068.f_3.f_1), "", 64);
func_85(&(Global_2103068.f_3), 0);
}
else if (!BitTest(*iParam0, 3))
{
if (!BitTest(*iParam0, 1))
{
PLAYER::DISPLAY_SYSTEM_SIGNIN_UI(false);
MISC::SET_BIT(iParam0, true);
StringCopy(&(Global_2103068.f_3.f_1), "", 64);
func_85(&(Global_2103068.f_3), 0);
}
}
if (func_84(&Global_2103068))
{
if (!func_82(&Global_2103068, 4000, 1))
{
bVar2 = true;
}
}
if (!bVar2)
{
if (bParam1)
{
if (!NETWORK::NETWORK_IS_SIGNED_ONLINE())
{
if (NETWORK::NETWORK_IS_CABLE_CONNECTED())
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "STORE_NOT_ONL", iVar0, 0, false, -1, 0, 0, true, 0);
}
else
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "SCLB_NO_INT", iVar0, 0, false, -1, 0, 0, true, 0);
}
if (!PLAYER::IS_SYSTEM_UI_BEING_DISPLAYED())
{
if (!BitTest(*iParam0, 0))
{
if (!PAD::IS_CONTROL_PRESSED(2, 201))
{
MISC::SET_BIT(iParam0, false);
}
}
else if (PAD::IS_CONTROL_JUST_RELEASED(2, 201))
{
func_94(&Global_2103068);
*iParam0 = 0;
Global_2103068.f_2 = 0;
func_93(0);
return 1;
}
}
}
else
{
func_94(&Global_2103068);
*iParam0 = 0;
Global_2103068.f_2 = 0;
func_93(0);
return 1;
}
}
else if (BitTest(*iParam0, 3))
{
if (NETWORK::NETWORK_IS_CABLE_CONNECTED())
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "SCLB_SIGN_OUT", iVar0, 0, false, -1, 0, 0, true, 0);
}
else
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "SCLB_NO_INT", iVar0, 0, false, -1, 0, 0, true, 0);
}
if (!BitTest(*iParam0, 0))
{
if (!PAD::IS_CONTROL_PRESSED(2, 201))
{
MISC::SET_BIT(iParam0, false);
}
}
else if (PAD::IS_CONTROL_JUST_RELEASED(2, 201))
{
func_94(&(Global_2103068.f_49));
func_94(&Global_2103068);
*iParam0 = 0;
Global_2103068.f_2 = 0;
func_93(0);
return 1;
}
}
else
{
if (NETWORK::NETWORK_IS_CABLE_CONNECTED())
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "SCLB_NOT_ONL", iVar0, 0, false, -1, 0, 0, true, 0);
}
else
{
HUD::SET_WARNING_MESSAGE_WITH_HEADER("PM_INF_QMFT", "SCLB_NO_INT", iVar0, 0, false, -1, 0, 0, true, 0);
}
if (!PLAYER::IS_SYSTEM_UI_BEING_DISPLAYED())
{
if (!BitTest(*iParam0, 0))
{
if (!PAD::IS_CONTROL_PRESSED(2, 201))
{
MISC::SET_BIT(iParam0, false);
}
}
else if (PAD::IS_CONTROL_JUST_RELEASED(2, 201))
{
func_94(&(Global_2103068.f_49));
func_94(&Global_2103068);
*iParam0 = 0;
Global_2103068.f_2 = 0;
func_93(0);
return 1;
}
}
}
}
}
return 0;
}
int func_82(var uParam0, int iParam1, bool bParam2)
{
if (iParam1 == -1)
{
return 1;
}
func_83(uParam0, bParam2, 0);
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS() && !bParam2)
{
if (MISC::ABSI(NETWORK::GET_TIME_DIFFERENCE(NETWORK::GET_NETWORK_TIME(), *uParam0)) >= iParam1)
{
return 1;
}
}
else if (MISC::ABSI(NETWORK::GET_TIME_DIFFERENCE(MISC::GET_GAME_TIMER(), *uParam0)) >= iParam1)
{
return 1;
}
return 0;
}
void func_83(var uParam0, bool bParam1, bool bParam2)
{
if (uParam0->f_1 == 0)
{
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS() && !bParam1)
{
if (!bParam2)
{
*uParam0 = NETWORK::GET_NETWORK_TIME();
}
else
{
*uParam0 = NETWORK::GET_NETWORK_TIME_ACCURATE();
}
}
else
{
*uParam0 = MISC::GET_GAME_TIMER();
}
uParam0->f_1 = 1;
}
}
bool func_84(var uParam0)
{
return uParam0->f_1;
}
void func_85(var uParam0, bool bParam1)
{
func_86(uParam0);
if (bParam1)
{
func_93(0);
}
uParam0->f_35 = 1;
}
void func_86(var uParam0)
{
struct<46> Var0;
Var0.f_41 = 1;
*uParam0 = { Var0 };
}
void func_87(var uParam0, int iParam1)
{
if (iParam1 == 1)
{
*uParam0 = 0;
func_88(uParam0);
}
if (*uParam0 == 0)
{
if (uParam0->f_36)
{
HUD::BEGIN_TEXT_COMMAND_BUSYSPINNER_ON(&(uParam0->f_1));
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_33);
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_34);
HUD::END_TEXT_COMMAND_BUSYSPINNER_ON(uParam0->f_41);
}
else if (uParam0->f_37)
{
HUD::BEGIN_TEXT_COMMAND_BUSYSPINNER_ON(&(uParam0->f_1));
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_33);
HUD::END_TEXT_COMMAND_BUSYSPINNER_ON(uParam0->f_41);
}
else if (uParam0->f_39)
{
HUD::BEGIN_TEXT_COMMAND_BUSYSPINNER_ON(&(uParam0->f_1));
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(&(uParam0->f_17));
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_33);
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_34);
HUD::END_TEXT_COMMAND_BUSYSPINNER_ON(uParam0->f_41);
}
else if (uParam0->f_38)
{
HUD::BEGIN_TEXT_COMMAND_BUSYSPINNER_ON(&(uParam0->f_1));
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(&(uParam0->f_17));
HUD::END_TEXT_COMMAND_BUSYSPINNER_ON(uParam0->f_41);
}
else if (uParam0->f_40)
{
HUD::BEGIN_TEXT_COMMAND_BUSYSPINNER_ON(&(uParam0->f_1));
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(uParam0->f_33, 70);
HUD::END_TEXT_COMMAND_BUSYSPINNER_ON(uParam0->f_41);
}
else
{
HUD::BEGIN_TEXT_COMMAND_BUSYSPINNER_ON(&(uParam0->f_1));
HUD::END_TEXT_COMMAND_BUSYSPINNER_ON(uParam0->f_41);
}
*uParam0 = 1;
}
if (*uParam0 == 1)
{
}
}
void func_88(var uParam0)
{
uParam0->f_35 = 0;
}
int func_89(var uParam0)
{
return uParam0->f_35;
}
int func_90()
{
if (func_91())
{
return 0;
}
if (NETWORK::NETWORK_IS_CLOUD_AVAILABLE() == 0)
{
return 0;
}
return 1;
}
bool func_91()
{
return Global_2725740;
}
bool func_92()
{
return (MISC::IS_ORBIS_VERSION() || unk_0x807ABE1AB65C24D2());
}
void func_93(bool bParam0)
{
HUD::BUSYSPINNER_OFF();
if (bParam0)
{
HUD::PRELOAD_BUSYSPINNER();
}
}
void func_94(var uParam0)
{
uParam0->f_1 = 0;
}
void func_95(int* iParam0)
{
int iVar0;
float fVar1;
int iVar2;
if (!func_98(iParam0))
{
return;
}
GRAPHICS::DRAW_SCALEFORM_MOVIE_FULLSCREEN(*iParam0, 255, 255, 255, 0, 0);
if (PAD::_0x6CD79468A1E595C6(2))
{
iVar0 = 0;
while (iVar0 < iParam0->f_3)
{
if (iParam0->f_3[iVar0] != 361)
{
iParam0->f_12[iVar0] = PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, iParam0->f_3[iVar0], true);
}
iVar0++;
}
func_96(&(iParam0->f_1), 4);
}
if (!func_23(iParam0->f_1, 4))
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "SET_CLEAR_SPACE");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(200f);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "SET_DATA_SLOT_EMPTY");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
fVar1 = 0f;
iVar2 = 0;
while (iVar2 < 4)
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(iParam0->f_21[iVar2]))
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(iParam0->f_12[iVar2 + 4]))
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "SET_DATA_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(fVar1);
func_9(iParam0->f_12[iVar2 + 4]);
func_9(iParam0->f_12[iVar2]);
func_14(iParam0->f_21[iVar2]);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
else
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "SET_DATA_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(fVar1);
func_9(iParam0->f_12[iVar2]);
func_14(iParam0->f_21[iVar2]);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
fVar1 = (fVar1 + 1f);
}
iVar2++;
}
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "DRAW_INSTRUCTIONAL_BUTTONS");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(SYSTEM::TO_FLOAT(iParam0->f_2));
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*iParam0, "SET_BACKGROUND_COLOUR");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0f);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0f);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0f);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(80f);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
func_21(&(iParam0->f_1), 4);
}
}
void func_96(var uParam0, int iParam1)
{
func_97(uParam0, iParam1);
}
void func_97(var uParam0, var uParam1)
{
*uParam0 = (*uParam0 - (*uParam0 && uParam1));
}
int func_98(var uParam0)
{
if (*uParam0 != 0)
{
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(*uParam0))
{
func_21(&(uParam0->f_1), 1);
return 1;
}
}
return 0;
}
void func_99(var uParam0, int iParam1)
{
func_100(uParam0, &uLocal_144);
}
void func_100(var uParam0, var uParam1)
{
int iVar0;
bool bVar1;
var uVar2[3];
int iVar6;
bool bVar7;
bool bVar8;
struct<8> Var9;
char[] cVar25[8];
int iVar27[3];
int iVar31;
struct<13> Var32;
var uVar45;
struct<3> Var51;
struct<3> Var57;
bool bVar63;
func_180(&(Global_2103068.f_49), 1, 0);
HUD::HIDE_HELP_TEXT_THIS_FRAME();
func_179();
func_75(0);
HUD::HIDE_HUD_AND_RADAR_THIS_FRAME();
func_177(1);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(10);
func_176(1);
func_175(1);
if (!func_172())
{
if (!AUDIO::IS_AUDIO_SCENE_ACTIVE("LEADERBOARD_SCENE"))
{
AUDIO::START_AUDIO_SCENE("LEADERBOARD_SCENE");
}
}
if (!BitTest(uParam1->f_42, 3))
{
*uParam0 = func_171();
MISC::SET_BIT(&(uParam1->f_42), 3);
}
Var32 = { func_60(PLAYER::PLAYER_ID()) };
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(*uParam0))
{
if (((!NETWORK::NETWORK_HAS_VALID_ROS_CREDENTIALS() || !PLAYER::IS_PLAYER_ONLINE()) || (!NETWORK::NETWORK_HAVE_ONLINE_PRIVILEGES() && NETWORK::_NETWORK_HAS_AGE_RESTRICTED_PROFILE())) || Global_2097536.f_2832 != 0)
{
if (!PLAYER::IS_PLAYER_ONLINE())
{
if (Global_2097536.f_2829 != 2)
{
MISC::CLEAR_BIT(&(uParam1->f_42), true);
Global_2097536.f_2829 = 2;
}
}
else if (!NETWORK::NETWORK_HAVE_ONLINE_PRIVILEGES() && NETWORK::_NETWORK_HAS_AGE_RESTRICTED_PROFILE())
{
if (Global_2097536.f_2829 != 3)
{
MISC::CLEAR_BIT(&(uParam1->f_42), true);
Global_2097536.f_2829 = 3;
}
}
else if (!NETWORK::NETWORK_HAS_VALID_ROS_CREDENTIALS())
{
if (Global_2097536.f_2829 != 4)
{
MISC::CLEAR_BIT(&(uParam1->f_42), true);
Global_2097536.f_2829 = 4;
}
}
else if (Global_2097536.f_2832 != 0)
{
if (Global_2097536.f_2829 != 5)
{
MISC::CLEAR_BIT(&(uParam1->f_42), true);
Global_2097536.f_2829 = 5;
}
}
if (!BitTest(uParam1->f_42, 1))
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "CLEAR_ALL_SLOTS");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
func_170(*uParam0, Global_2097536.f_2780);
if (HUD::DOES_TEXT_LABEL_EXIST(&(Global_2097536.f_2780.f_1)))
{
if (!func_169(uParam1->f_44))
{
if (Global_2097536.f_2780.f_26 > 0)
{
Var9 = { Global_2097536.f_2780.f_9 };
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &cVar25, &Var9, Global_2097536.f_2780.f_25, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &cVar25, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
else if (!Global_2097536.f_2780.f_27)
{
StringCopy(&Var9, "FMMC_COR_SCLB5", 64);
if (Global_2097536.f_2780.f_26 > 0)
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
else
{
StringCopy(&Var9, "FMMC_COR_SCLB6", 64);
if (Global_2097536.f_2780.f_26 > 0)
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
func_167(*uParam0, "SCLB_C_RANK", &(Global_2097536.f_2717), Global_2097536.f_2708);
}
iVar31 = 0;
MISC::SET_BIT(&iVar31, 4);
func_166(*uParam0, &iVar6, iVar31, 1, 1);
iVar31 = 0;
MISC::SET_BIT(&iVar31, 5);
func_166(*uParam0, &iVar6, iVar31, 1, 1);
iVar31 = 0;
MISC::SET_BIT(&iVar31, 6);
func_166(*uParam0, &iVar6, iVar31, 1, 1);
MISC::SET_BIT(&(uParam1->f_42), true);
func_165(*uParam0);
MISC::CLEAR_BIT(&(uParam1->f_42), 2);
HUD::CLEAR_HELP(true);
}
else
{
func_165(*uParam0);
}
}
else
{
if (Global_2097536.f_2829 != 1)
{
MISC::CLEAR_BIT(&(uParam1->f_42), true);
Global_2097536.f_2829 = 1;
}
if (!func_128(uParam1))
{
uParam1->f_246.f_1 = -1;
MISC::CLEAR_BIT(&(uParam1->f_42), true);
if (!BitTest(uParam1->f_42, 0))
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "CLEAR_ALL_SLOTS");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
func_170(*uParam0, Global_2097536.f_2780);
if (HUD::DOES_TEXT_LABEL_EXIST(&(Global_2097536.f_2780.f_1)))
{
if (!func_169(uParam1->f_44))
{
if (Global_2097536.f_2780.f_26 > 0)
{
Var9 = { Global_2097536.f_2780.f_9 };
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &cVar25, &Var9, 1, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &cVar25, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
else if (!Global_2097536.f_2780.f_27)
{
StringCopy(&Var9, "FMMC_COR_SCLB5", 64);
if (Global_2097536.f_2780.f_26 > 0)
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
else
{
StringCopy(&Var9, "FMMC_COR_SCLB6", 64);
if (Global_2097536.f_2780.f_26 > 0)
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
func_167(*uParam0, "SCLB_C_RANK", &(Global_2097536.f_2717), Global_2097536.f_2708);
}
MISC::SET_BIT(&(uParam1->f_42), false);
MISC::CLEAR_BIT(&(uParam1->f_42), 2);
}
iVar6 = 0;
iVar0 = 0;
if (Global_2097536.f_2825 == -1)
{
StringCopy(&Var51, "SC_LB_DL0", 24);
iVar0 = 0;
while (iVar0 < 3)
{
if (iVar0 == 0)
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 4);
func_166(*uParam0, &iVar6, iVar31, 0, 0);
}
else if (iVar0 == 1)
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 5);
func_166(*uParam0, &iVar6, iVar31, 0, 0);
}
else if (iVar0 == 2)
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 6);
func_166(*uParam0, &iVar6, iVar31, 0, 0);
}
iVar31 = 0;
MISC::SET_BIT(&iVar31, 7);
func_127(*uParam0, iVar6, iVar31, &Var51);
iVar6++;
iVar0++;
}
Global_2097536.f_2825 = 1;
func_94(&(Global_2097536.f_2823));
}
else if (func_82(&(Global_2097536.f_2823), 300, 0))
{
StringCopy(&Var57, "SC_LB_DL", 24);
StringIntConCat(&Var57, Global_2097536.f_2825, 24);
iVar0 = 0;
while (iVar0 < 3)
{
if (iVar0 == 0)
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 4);
func_166(*uParam0, &iVar6, iVar31, 0, 0);
}
else if (iVar0 == 1)
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 5);
func_166(*uParam0, &iVar6, iVar31, 0, 0);
}
else if (iVar0 == 2)
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 6);
func_166(*uParam0, &iVar6, iVar31, 0, 0);
}
iVar31 = 0;
MISC::SET_BIT(&iVar31, 7);
func_127(*uParam0, iVar6, iVar31, &Var57);
iVar6++;
iVar0++;
}
Global_2097536.f_2825++;
if (Global_2097536.f_2825 > 3)
{
Global_2097536.f_2825 = 0;
}
func_94(&(Global_2097536.f_2823));
}
func_165(*uParam0);
}
else
{
MISC::CLEAR_BIT(&(uParam1->f_42), false);
if (!BitTest(uParam1->f_42, 1))
{
iVar0 = 0;
while (iVar0 < 3)
{
uParam1->f_246.f_187[iVar0] = 0;
iVar0++;
}
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(*uParam0, "CLEAR_ALL_SLOTS");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
func_170(*uParam0, Global_2097536.f_2780);
if (HUD::DOES_TEXT_LABEL_EXIST(&(Global_2097536.f_2780.f_1)))
{
if (!func_169(uParam1->f_44))
{
if (Global_2097536.f_2780.f_26 > 0)
{
Var9 = { Global_2097536.f_2780.f_9 };
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &cVar25, &Var9, 1, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &cVar25, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
else if (!Global_2097536.f_2780.f_27)
{
StringCopy(&Var9, "FMMC_COR_SCLB5", 64);
if (Global_2097536.f_2780.f_26 > 0)
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
else
{
StringCopy(&Var9, "FMMC_COR_SCLB6", 64);
if (Global_2097536.f_2780.f_26 > 0)
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, Global_2097536.f_2780.f_26);
}
else
{
func_168(*uParam0, &(Global_2097536.f_2780.f_1), &Var9, &(Global_2097536.f_2780.f_9), Global_2097536.f_2780.f_25, -1);
}
}
func_167(*uParam0, "SCLB_C_RANK", &(Global_2097536.f_2717), Global_2097536.f_2708);
}
if (!BitTest(uParam1->f_42, 6))
{
func_126(&Global_2101867);
func_122(uParam1, &Global_2101867);
func_121(uParam1, &Global_2101867);
}
iVar6 = 0;
uParam1->f_246.f_2 = 0;
if ((Global_2097536.f_2704[0] > 1 || (Global_2097536.f_2704[0] > 0 && Global_2097536.f_2775[0] != -1)) || (((Global_2097536.f_2704[0] > 0 && Global_2097536.f_2780.f_27) && func_169(uParam1->f_44)) && Global_2097536.f_2775[0] != -1))
{
uParam1->f_246.f_1 = -1;
iVar0 = 0;
iVar0 = 0;
while (iVar0 < 12)
{
bVar63 = false;
if (Global_2101867[iVar0 /*100*/].f_75 == 1)
{
if (!iVar27[0])
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 4);
func_166(*uParam0, &iVar6, iVar31, 0, 0);
iVar27[0] = 1;
}
}
else if (Global_2101867[iVar0 /*100*/].f_75 == 2)
{
if (!iVar27[1])
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 5);
if ((Global_2097536.f_2704[1] < 1 && Global_2097536.f_2775[1] == -1) && !(((Global_2097536.f_2704[1] > 0 && Global_2097536.f_2780.f_27) && func_169(uParam1->f_44)) && Global_2097536.f_2775[1] != -1))
{
func_166(*uParam0, &iVar6, iVar31, 1, 0);
bVar63 = true;
}
else
{
func_166(*uParam0, &iVar6, iVar31, 0, 0);
}
iVar27[1] = 1;
}
}
else if (Global_2101867[iVar0 /*100*/].f_75 == 3)
{
if (!iVar27[2])
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 6);
if (!NETWORK::NETWORK_HAS_SOCIAL_CLUB_ACCOUNT())
{
bVar63 = true;
}
else if (!NETWORK::NETWORK_ARE_SOCIAL_CLUB_POLICIES_CURRENT())
{
bVar63 = true;
}
if ((Global_2097536.f_2704[2] < 2 && Global_2097536.f_2775[2] == -1) && !(((Global_2097536.f_2704[2] > 0 && Global_2097536.f_2780.f_27) && func_169(uParam1->f_44)) && Global_2097536.f_2775[2] != -1))
{
bVar63 = true;
}
if (bVar63)
{
func_166(*uParam0, &iVar6, iVar31, 1, 0);
}
else
{
func_166(*uParam0, &iVar6, iVar31, 0, 0);
}
iVar27[2] = 1;
}
}
if (func_120(Global_2101867[iVar0 /*100*/].f_32))
{
if (func_169(uParam1->f_44))
{
NETWORK::NETWORK_PLAYER_GET_USERID(PLAYER::PLAYER_ID(), &uVar45);
if (!Global_2101867[iVar0 /*100*/].f_74 && MISC::ARE_STRINGS_EQUAL(&(uParam1->f_44.f_3.f_1[1 /*16*/].f_8), &uVar45))
{
bVar63 = true;
}
}
if (!bVar63)
{
iVar31 = 0;
if (!Global_2097536.f_2780.f_27)
{
if (func_119(&(Global_2101867[iVar0 /*100*/].f_32), &Var32))
{
MISC::SET_BIT(&iVar31, true);
if (uParam1->f_246.f_1 == -1)
{
bVar7 = true;
uParam1->f_246.f_1 = iVar0;
MISC::SET_BIT(&iVar31, 3);
}
}
}
if (func_169(uParam1->f_44))
{
Var9 = { Global_2101867[iVar0 /*100*/] };
if (!MISC::IS_STRING_NULL_OR_EMPTY(&(Global_2101867[iVar0 /*100*/].f_84)) && !MISC::ARE_STRINGS_EQUAL(&(Global_2101867[iVar0 /*100*/].f_84), ""))
{
StringConCat(&Var9, "/", 64);
StringConCat(&Var9, &(Global_2101867[iVar0 /*100*/].f_84), 64);
}
func_118(*uParam0, iVar6, iVar31, Global_2101867[iVar0 /*100*/].f_59, &Var9, &(Global_2101867[iVar0 /*100*/].f_80));
uParam1->f_246.f_6[iVar0 /*15*/] = iVar6;
uParam1->f_246.f_6[iVar0 /*15*/].f_1 = iVar31;
uParam1->f_246.f_6[iVar0 /*15*/].f_2 = { Global_2101867[iVar0 /*100*/].f_32 };
uParam1->f_246.f_2++;
}
else
{
func_118(*uParam0, iVar6, iVar31, Global_2101867[iVar0 /*100*/].f_59, &(Global_2101867[iVar0 /*100*/]), &(Global_2101867[iVar0 /*100*/].f_80));
uParam1->f_246.f_6[iVar0 /*15*/] = iVar6;
uParam1->f_246.f_6[iVar0 /*15*/].f_1 = iVar31;
uParam1->f_246.f_6[iVar0 /*15*/].f_2 = { Global_2101867[iVar0 /*100*/].f_32 };
uParam1->f_246.f_2++;
}
bVar1 = false;
while (bVar1 < Global_2097536.f_2708)
{
bVar8 = false;
if (BitTest(Global_2097536.f_2770, bVar1))
{
if (BitTest(Global_2097536.f_2768, bVar1))
{
if (Global_2097536.f_2754[bVar1] == Global_2101867[iVar0 /*100*/].f_67[bVar1])
{
bVar8 = true;
}
}
if (bVar8)
{
func_109(Global_2097536.f_2780, bVar1, Global_2101867[iVar0 /*100*/].f_67[bVar1], 0, Global_2101867[iVar0 /*100*/].f_58);
}
else
{
func_109(Global_2097536.f_2780, bVar1, Global_2101867[iVar0 /*100*/].f_67[bVar1], Global_2101867[iVar0 /*100*/].f_74, Global_2101867[iVar0 /*100*/].f_58);
}
}
else
{
if (BitTest(Global_2097536.f_2768, bVar1))
{
if (Global_2097536.f_2761[bVar1] == Global_2101867[iVar0 /*100*/].f_67[bVar1])
{
bVar8 = true;
}
}
if (bVar8)
{
func_106(Global_2097536.f_2780, bVar1, Global_2101867[iVar0 /*100*/].f_60[bVar1], 0);
}
else
{
func_106(Global_2097536.f_2780, bVar1, Global_2101867[iVar0 /*100*/].f_60[bVar1], Global_2101867[iVar0 /*100*/].f_74);
}
}
bVar1++;
}
func_105();
uVar2[(Global_2101867[iVar0 /*100*/].f_75 - 1)]++;
if (uVar2[(Global_2101867[iVar0 /*100*/].f_75 - 1)] == 2)
{
if (Global_2101867[iVar0 /*100*/].f_59 > 2)
{
MISC::SET_BIT(&iVar31, 2);
MISC::SET_BIT(&(uParam1->f_246.f_6[0 /*15*/].f_1), 2);
func_104(*uParam0, (iVar6 - 1), iVar31);
}
}
iVar6++;
}
}
iVar0++;
}
iVar0 = 0;
iVar0 = 0;
while (iVar0 < 3)
{
uParam1->f_246.f_187[iVar0] = uVar2[iVar0];
iVar0++;
}
}
else
{
iVar31 = 0;
MISC::SET_BIT(&iVar31, 4);
func_166(*uParam0, &iVar6, iVar31, 1, 0);
iVar31 = 0;
MISC::SET_BIT(&iVar31, 5);
func_166(*uParam0, &iVar6, iVar31, 1, 0);
iVar31 = 0;
MISC::SET_BIT(&iVar31, 6);
func_166(*uParam0, &iVar6, iVar31, 1, 0);
}
MISC::SET_BIT(&(uParam1->f_42), true);
MISC::CLEAR_BIT(&(uParam1->f_42), 2);
func_165(*uParam0);
HUD::CLEAR_HELP(true);
if (uParam1->f_246.f_1 == -1 && !bVar7 == 1)
{
if (Global_2097536.f_2704[0] > 1)
{
uParam1->f_246.f_1 = 0;
MISC::SET_BIT(&(uParam1->f_246.f_6[uParam1->f_246.f_1 /*15*/].f_1), 3);
func_104(*uParam0, uParam1->f_246.f_6[uParam1->f_246.f_1 /*15*/], uParam1->f_246.f_6[uParam1->f_246.f_1 /*15*/].f_1);
}
}
}
else
{
func_165(*uParam0);
func_101(uParam0, uParam1);
}
}
}
}
}
void func_101(var uParam0, var uParam1)
{
bool bVar0;
int iVar1;
int iVar2;
int iVar3;
var uVar4;
var uVar5;
int iVar6;
var uVar7;
var uVar8;
iVar1 = uParam1->f_246.f_1;
if (PAD::_IS_USING_KEYBOARD(2))
{
HUD::_SET_MOUSE_CURSOR_ACTIVE_THIS_FRAME();
PAD::SET_INPUT_EXCLUSIVE(2, 239);
PAD::SET_INPUT_EXCLUSIVE(2, 240);
PAD::SET_INPUT_EXCLUSIVE(2, 237);
PAD::SET_INPUT_EXCLUSIVE(2, 238);
PAD::DISABLE_CONTROL_ACTION(2, 200, true);
if (PAD::IS_DISABLED_CONTROL_PRESSED(2, 241))
{
PAD::_SET_CONTROL_NORMAL(2, 188, 1f);
}
if (PAD::IS_DISABLED_CONTROL_PRESSED(2, 242))
{
PAD::_SET_CONTROL_NORMAL(2, 187, 1f);
}
if (HUD::_0x632B2940C67F4EA9(*uParam0, &iVar2, &iVar3, &uVar4))
{
if (iVar2 == 5)
{
if (iVar3 > uParam1->f_246.f_187[0])
{
if (iVar3 <= (uParam1->f_246.f_187[0] + uParam1->f_246.f_187[1]) + 2)
{
iVar3 = (iVar3 - 2);
}
else
{
iVar3 = (iVar3 - 4);
}
}
iVar3 = (iVar3 - 1);
if (uParam1->f_246.f_1 != iVar3)
{
uParam1->f_246.f_1 = iVar3;
AUDIO::PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true);
bVar0 = true;
}
else
{
PAD::_SET_CONTROL_NORMAL(2, 217, 1f);
}
}
}
}
if (!PAD::_IS_USING_KEYBOARD(2))
{
func_103(&uVar5, &iVar6, &uVar7, &uVar8, 0);
}
if (uParam1->f_246.f_2 > 0)
{
if (!BitTest(uParam1->f_246, 0))
{
if ((PAD::IS_CONTROL_PRESSED(2, 188) || PAD::IS_DISABLED_CONTROL_PRESSED(2, 188)) || iVar6 < -100)
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true);
uParam1->f_246.f_1 = (uParam1->f_246.f_1 + -1);
MISC::SET_BIT(&(uParam1->f_246), false);
func_94(&(uParam1->f_246.f_3));
bVar0 = true;
}
}
else if (func_102(uParam1, 188))
{
MISC::CLEAR_BIT(&(uParam1->f_246), false);
}
if (!BitTest(uParam1->f_246, 1))
{
if ((PAD::IS_CONTROL_PRESSED(2, 187) || PAD::IS_DISABLED_CONTROL_PRESSED(2, 187)) || iVar6 > 100)
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", true);
uParam1->f_246.f_1++;
MISC::SET_BIT(&(uParam1->f_246), true);
func_94(&(uParam1->f_246.f_3));
bVar0 = true;
}
}
else if (func_102(uParam1, 187))
{
MISC::CLEAR_BIT(&(uParam1->f_246), true);
}
}
if (bVar0)
{
if (uParam1->f_246.f_1 < 0)
{
uParam1->f_246.f_1 = (uParam1->f_246.f_2 - 1);
}
if (uParam1->f_246.f_1 >= uParam1->f_246.f_2)
{
uParam1->f_246.f_1 = 0;
}
}
if (!BitTest(uParam1->f_246, 3))
{
if ((PAD::IS_CONTROL_PRESSED(2, 204) || PAD::IS_DISABLED_CONTROL_JUST_PRESSED(2, 204)) || PAD::IS_CONTROL_JUST_PRESSED(2, 237))
{
MISC::SET_BIT(&(uParam1->f_246), 3);
func_94(&(uParam1->f_246.f_3));
bVar0 = true;
}
}
else if (func_102(uParam1, 204))
{
MISC::CLEAR_BIT(&(uParam1->f_246), 3);
}
if (uParam1->f_246.f_1 >= 0)
{
if (uParam1->f_246.f_1 != iVar1)
{
if (iVar1 >= 0)
{
MISC::CLEAR_BIT(&(uParam1->f_246.f_6[iVar1 /*15*/].f_1), 3);
func_104(*uParam0, uParam1->f_246.f_6[iVar1 /*15*/], uParam1->f_246.f_6[iVar1 /*15*/].f_1);
}
MISC::SET_BIT(&(uParam1->f_246.f_6[uParam1->f_246.f_1 /*15*/].f_1), 3);
func_104(*uParam0, uParam1->f_246.f_6[uParam1->f_246.f_1 /*15*/], uParam1->f_246.f_6[uParam1->f_246.f_1 /*15*/].f_1);
MISC::CLEAR_BIT(&(uParam1->f_42), 2);
}
if (func_120(uParam1->f_246.f_6[uParam1->f_246.f_1 /*15*/].f_2))
{
if (!BitTest(uParam1->f_246, 2))
{
if (PAD::IS_CONTROL_PRESSED(2, 217) || PAD::IS_DISABLED_CONTROL_JUST_PRESSED(2, 217))
{
if (!PLAYER::IS_SYSTEM_UI_BEING_DISPLAYED())
{
AUDIO::PLAY_SOUND_FRONTEND(-1, "SELECT", "HUD_FRONTEND_MP_SOUNDSET", true);
MISC::SET_BIT(&(uParam1->f_246), 2);
NETWORK::NETWORK_SHOW_PROFILE_UI(&(uParam1->f_246.f_6[uParam1->f_246.f_1 /*15*/].f_2));
}
}
}
else if (!PAD::IS_CONTROL_PRESSED(2, 217))
{
MISC::CLEAR_BIT(&(uParam1->f_246), 2);
}
}
}
}
int func_102(var uParam0, int iParam1)
{
var uVar0;
int iVar1;
var uVar2;
var uVar3;
if (iParam1 == 188 || iParam1 == 187)
{
func_103(&uVar0, &iVar1, &uVar2, &uVar3, 0);
if (((!PAD::IS_CONTROL_PRESSED(2, iParam1) && !PAD::IS_DISABLED_CONTROL_PRESSED(2, iParam1)) && (iVar1 < 75 && iVar1 > -75)) || func_82(&(uParam0->f_246.f_3), 250, 0))
{
return 1;
}
}
else if ((!PAD::IS_CONTROL_PRESSED(2, iParam1) && !PAD::IS_DISABLED_CONTROL_PRESSED(2, iParam1)) || func_82(&(uParam0->f_246.f_3), 250, 0))
{
return 1;
}
return 0;
}
void func_103(var uParam0, var uParam1, var uParam2, var uParam3, bool bParam4)
{
*uParam0 = SYSTEM::FLOOR((PAD::GET_CONTROL_NORMAL(2, 218) * 127f));
*uParam1 = SYSTEM::FLOOR((PAD::GET_CONTROL_NORMAL(2, 219) * 127f));
*uParam2 = SYSTEM::FLOOR((PAD::GET_CONTROL_NORMAL(2, 220) * 127f));
*uParam3 = SYSTEM::FLOOR((PAD::GET_CONTROL_NORMAL(2, 221) * 127f));
if (bParam4)
{
if (IntToFloat(*uParam0) == 0f && IntToFloat(*uParam1) == 0f)
{
*uParam0 = SYSTEM::FLOOR((PAD::GET_DISABLED_CONTROL_NORMAL(2, 218) * 127f));
*uParam1 = SYSTEM::FLOOR((PAD::GET_DISABLED_CONTROL_NORMAL(2, 219) * 127f));
}
if (IntToFloat(*uParam2) == 0f && IntToFloat(*uParam3) == 0f)
{
*uParam2 = SYSTEM::FLOOR((PAD::GET_DISABLED_CONTROL_NORMAL(2, 220) * 127f));
*uParam3 = SYSTEM::FLOOR((PAD::GET_DISABLED_CONTROL_NORMAL(2, 221) * 127f));
}
}
}
void func_104(int iParam0, int iParam1, int iParam2)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_SLOT_STATE");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iParam1);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iParam2);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
void func_105()
{
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
void func_106(struct<30> Param0, var uParam30, var uParam31, var uParam32, var uParam33, var uParam34, var uParam35, var uParam36, var uParam37, var uParam38, var uParam39, var uParam40, var uParam41, var uParam42, bool bParam43, float fParam44, bool bParam45)
{
switch (Param0.f_29[bParam43])
{
case 4:
if (bParam45)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("NUMBER");
HUD::ADD_TEXT_COMPONENT_FLOAT(fParam44, 2);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 12:
if (bParam45)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("NUMBER");
HUD::ADD_TEXT_COMPONENT_INTEGER(SYSTEM::FLOOR(fParam44));
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 17:
case 19:
case 18:
case 20:
if (bParam45)
{
if (Param0.f_29[bParam43] == 18 || Param0.f_29[bParam43] == 20)
{
fParam44 = (fParam44 * -1f);
}
if (!MISC::SHOULD_USE_METRIC_MEASUREMENTS())
{
if (Param0.f_29[bParam43] == 19 || Param0.f_29[bParam43] == 20)
{
fParam44 = func_108(fParam44);
}
else
{
fParam44 = func_107(fParam44);
}
}
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("NUMBER");
HUD::ADD_TEXT_COMPONENT_FLOAT(fParam44, 2);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 0:
break;
}
}
float func_107(float fParam0)
{
return (fParam0 / 0.3048f);
}
float func_108(float fParam0)
{
return (fParam0 / 1609.344f);
}
void func_109(struct<30> Param0, var uParam30, var uParam31, var uParam32, var uParam33, var uParam34, var uParam35, var uParam36, var uParam37, var uParam38, var uParam39, var uParam40, var uParam41, var uParam42, bool bParam43, int iParam44, bool bParam45, bool bParam46)
{
struct<4> Var0;
if (iParam44 == 2147483647 || iParam44 == -2147483647)
{
bParam45 = false;
}
StringCopy(&Var0, "", 16);
switch (Param0.f_29[bParam43])
{
case 5:
if (bParam45)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("NUMBER");
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam44);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 7:
if (bParam45)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("NUMBER");
HUD::ADD_TEXT_COMPONENT_INTEGER(-iParam44);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 1:
case 9:
case 11:
if (bParam45)
{
if (Param0.f_29[bParam43] == 11 && iParam44 < 0)
{
iParam44 = (iParam44 * -1);
}
if (iParam44 >= 3600000 || iParam44 <= -3600000)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam44, 14);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else if (Param0.f_29[bParam43] == 9)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam44, 6);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam44, 2055);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 6:
if (bParam45)
{
if (iParam44 == 2147483647)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else if (iParam44 >= 3600000 || iParam44 <= -3600000)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam44, 14);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam44, 2055);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 2:
case 10:
if (bParam45)
{
iParam44 = (iParam44 * -1);
if (iParam44 >= 3600000 || iParam44 <= -3600000)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam44, 14);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else if (Param0.f_29[bParam43] == 10)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam44, 6);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TIME(iParam44, 2055);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 3:
if (bParam46)
{
if (STREAMING::IS_MODEL_IN_CDIMAGE(iParam44))
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SCLB_VEH_CUST");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(VEHICLE::GET_DISPLAY_NAME_FROM_VEHICLE_MODEL(iParam44));
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
}
else if (STREAMING::IS_MODEL_IN_CDIMAGE(iParam44))
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(VEHICLE::GET_DISPLAY_NAME_FROM_VEHICLE_MODEL(iParam44));
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 8:
if (func_117(iParam44) != 0)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(func_114(func_117(iParam44), 0));
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 13:
case 15:
case 14:
case 16:
if (bParam45)
{
if (Param0.f_29[bParam43] == 14 || Param0.f_29[bParam43] == 16)
{
iParam44 = (iParam44 * -1);
}
if (!MISC::SHOULD_USE_METRIC_MEASUREMENTS())
{
if (Param0.f_29[bParam43] == 15 || Param0.f_29[bParam43] == 16)
{
iParam44 = SYSTEM::FLOOR(func_108(SYSTEM::TO_FLOAT(iParam44)));
}
else
{
iParam44 = SYSTEM::FLOOR(func_107(SYSTEM::TO_FLOAT(iParam44)));
}
}
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("NUMBER");
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam44);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 21:
if (iParam44 > 20)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
Var0 = { func_113(iParam44) };
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(&Var0);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 22:
if (bParam45)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("NUMBER");
HUD::ADD_TEXT_COMPONENT_INTEGER(func_110(iParam44));
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
break;
case 0:
break;
}
}
int func_110(int iParam0)
{
int iVar0;
float fVar1;
int iVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
iVar0 = func_112(199);
if (iParam0 < 100)
{
return 1;
}
else if (iParam0 > iVar0)
{
fVar1 = (SYSTEM::TO_FLOAT(iParam0) - SYSTEM::TO_FLOAT(iVar0));
iVar2 = SYSTEM::FLOOR((fVar1 / SYSTEM::TO_FLOAT(Global_262145.f_30738)));
return (199 + iVar2);
}
fVar3 = (SYSTEM::TO_FLOAT(Global_262145.f_30737) / 2f);
fVar4 = (-(fVar3 * 3f) + fVar3);
fVar5 = fVar3;
fVar6 = ((-(fVar3 * 3f) + fVar4) + 100f);
fVar7 = ((-3f * fVar4) - 100f);
fVar7 = (IntToFloat(iParam0) - fVar7);
return SYSTEM::FLOOR(func_111(-fVar5, -fVar6, fVar7, 1));
}
float func_111(float fParam0, float fParam1, float fParam2, bool bParam3)
{
if (bParam3)
{
return ((-fParam1 - SYSTEM::SQRT(((fParam1 * fParam1) - ((4f * fParam0) * fParam2)))) / (2f * fParam0));
}
return ((-fParam1 + SYSTEM::SQRT(((fParam1 * fParam1) - ((4f * fParam0) * fParam2)))) / (2f * fParam0));
}
int func_112(int iParam0)
{
float fVar0;
float fVar1;
fVar0 = SYSTEM::TO_FLOAT(iParam0);
fVar1 = (SYSTEM::TO_FLOAT(Global_262145.f_30737) / 2f);
return SYSTEM::ROUND((((fVar0 * 100f) - 100f) + ((fVar0 - 3f) * ((fVar1 * (fVar0 - 3f)) + fVar1))));
}
struct<4> func_113(int iParam0)
{
struct<4> Var0;
StringCopy(&Var0, "ARENA_C_SL", 16);
if (iParam0 > 20)
{
StringCopy(&Var0, "**INVALID**", 16);
return Var0;
}
if (iParam0 < 0)
{
iParam0 = 0;
}
StringIntConCat(&Var0, iParam0, 16);
return Var0;
}
char* func_114(int iParam0, bool bParam1)
{
struct<32> Var0;
switch (iParam0)
{
case 0:
if (bParam1)
{
return "WTU_INVALID";
}
else
{
return "WT_INVALID";
}
break;
case joaat("weapon_unarmed"):
if (bParam1)
{
return "WTU_UNARMED";
}
else
{
return "WT_UNARMED";
}
break;
case joaat("weapon_pistol"):
if (bParam1)
{
return "WTU_PIST";
}
else
{
return "WT_PIST";
}
break;
case joaat("weapon_combatpistol"):
if (bParam1)
{
return "WTU_PIST_CBT";
}
else
{
return "WT_PIST_CBT";
}
break;
case joaat("weapon_appistol"):
if (bParam1)
{
return "WTU_PIST_AP";
}
else
{
return "WT_PIST_AP";
}
break;
case joaat("weapon_smg"):
if (bParam1)
{
return "WTU_SMG";
}
else
{
return "WT_SMG";
}
break;
case joaat("weapon_microsmg"):
if (bParam1)
{
return "WTU_SMG_MCR";
}
else
{
return "WT_SMG_MCR";
}
break;
case joaat("weapon_assaultrifle"):
if (bParam1)
{
return "WTU_RIFLE_ASL";
}
else
{
return "WT_RIFLE_ASL";
}
break;
case joaat("weapon_carbinerifle"):
if (bParam1)
{
return "WTU_RIFLE_CBN";
}
else
{
return "WT_RIFLE_CBN";
}
break;
case joaat("weapon_advancedrifle"):
if (bParam1)
{
return "WTU_RIFLE_ADV";
}
else
{
return "WT_RIFLE_ADV";
}
break;
case joaat("weapon_mg"):
if (bParam1)
{
return "WTU_MG";
}
else
{
return "WT_MG";
}
break;
case joaat("weapon_combatmg"):
if (bParam1)
{
return "WTU_MG_CBT";
}
else
{
return "WT_MG_CBT";
}
break;
case joaat("weapon_pumpshotgun"):
if (bParam1)
{
return "WTU_SG_PMP";
}
else
{
return "WT_SG_PMP";
}
break;
case joaat("weapon_sawnoffshotgun"):
if (bParam1)
{
return "WTU_SG_SOF";
}
else
{
return "WT_SG_SOF";
}
break;
case joaat("weapon_assaultshotgun"):
if (bParam1)
{
return "WTU_SG_ASL";
}
else
{
return "WT_SG_ASL";
}
break;
case joaat("weapon_heavysniper"):
if (bParam1)
{
return "WTU_SNIP_HVY";
}
else
{
return "WT_SNIP_HVY";
}
break;
case joaat("weapon_remotesniper"):
if (bParam1)
{
return "WTU_SNIP_RMT";
}
else
{
return "WT_SNIP_RMT";
}
break;
case joaat("weapon_sniperrifle"):
if (bParam1)
{
return "WTU_SNIP_RIF";
}
else
{
return "WT_SNIP_RIF";
}
break;
case joaat("weapon_grenadelauncher"):
if (bParam1)
{
return "WTU_GL";
}
else
{
return "WT_GL";
}
break;
case joaat("weapon_rpg"):
if (bParam1)
{
return "WTU_RPG";
}
else
{
return "WT_RPG";
}
break;
case joaat("weapon_minigun"):
if (bParam1)
{
return "WTU_MINIGUN";
}
else
{
return "WT_MINIGUN";
}
break;
case joaat("weapon_grenade"):
if (bParam1)
{
return "WTU_GNADE";
}
else
{
return "WT_GNADE";
}
break;
case joaat("weapon_smokegrenade"):
if (bParam1)
{
return "WTU_GNADE_SMK";
}
else
{
return "WT_GNADE_SMK";
}
break;
case joaat("weapon_stickybomb"):
if (bParam1)
{
return "WTU_GNADE_STK";
}
else
{
return "WT_GNADE_STK";
}
break;
case joaat("weapon_molotov"):
if (bParam1)
{
return "WTU_MOLOTOV";
}
else
{
return "WT_MOLOTOV";
}
break;
case joaat("weapon_stungun"):
if (bParam1)
{
return "WTU_STUN";
}
else
{
return "WT_STUN";
}
break;
case joaat("weapon_petrolcan"):
if (bParam1)
{
return "WTU_PETROL";
}
else
{
return "WT_PETROL";
}
break;
case joaat("weapon_electric_fence"):
if (bParam1)
{
return "WTU_ELCFEN";
}
else
{
return "WT_ELCFEN";
}
break;
case joaat("vehicle_weapon_tank"):
if (bParam1)
{
return "WTU_V_TANK";
}
else
{
return "WT_V_TANK";
}
break;
case joaat("vehicle_weapon_space_rocket"):
if (bParam1)
{
return "WTU_V_SPACERKT";
}
else
{
return "WT_V_SPACERKT";
}
break;
case joaat("vehicle_weapon_player_laser"):
if (bParam1)
{
return "WTU_V_PLRLSR";
}
else
{
return "WT_V_PLRLSR";
}
break;
case joaat("object"):
if (bParam1)
{
return "WTU_OBJECT";
}
else
{
return "WT_OBJECT";
}
break;
case joaat("gadget_parachute"):
if (bParam1)
{
return "WTU_PARA";
}
else
{
return "WT_PARA";
}
break;
case joaat("AMMO_RPG"):
if (bParam1)
{
return "WTU_A_RPG";
}
else
{
return "WT_A_RPG";
}
break;
case joaat("AMMO_TANK"):
if (bParam1)
{
return "WTU_A_TANK";
}
else
{
return "WT_A_TANK";
}
break;
case joaat("AMMO_SPACE_ROCKET"):
if (bParam1)
{
return "WTU_A_SPACERKT";
}
else
{
return "WT_A_SPACERKT";
}
break;
case joaat("AMMO_PLAYER_LASER"):
if (bParam1)
{
return "WTU_A_PLRLSR";
}
else
{
return "WT_A_PLRLSR";
}
break;
case joaat("AMMO_ENEMY_LASER"):
if (bParam1)
{
return "WTU_A_ENMYLSR";
}
else
{
return "WT_A_ENMYLSR";
}
break;
case joaat("weapon_knife"):
if (bParam1)
{
return "WTU_KNIFE";
}
else
{
return "WT_KNIFE";
}
break;
case joaat("weapon_nightstick"):
if (bParam1)
{
return "WTU_NGTSTK";
}
else
{
return "WT_NGTSTK";
}
break;
case joaat("weapon_hammer"):
if (bParam1)
{
return "WTU_HAMMER";
}
else
{
return "WT_HAMMER";
}
break;
case joaat("weapon_bat"):
if (bParam1)
{
return "WTU_BAT";
}
else
{
return "WT_BAT";
}
break;
case joaat("weapon_crowbar"):
if (bParam1)
{
return "WTU_CROWBAR";
}
else
{
return "WT_CROWBAR";
}
break;
case joaat("weapon_golfclub"):
if (bParam1)
{
return "WTU_GOLFCLUB";
}
else
{
return "WT_GOLFCLUB";
}
break;
case joaat("weapon_rammed_by_car"):
if (bParam1)
{
return "WTU_PIST";
}
else
{
return "WT_PIST";
}
break;
case joaat("weapon_run_over_by_car"):
if (bParam1)
{
return "WTU_PIST";
}
else
{
return "WT_PIST";
}
break;
case joaat("weapon_assaultsmg"):
if (bParam1)
{
return "WTU_SMG_ASL";
}
else
{
return "WT_SMG_ASL";
}
break;
case joaat("weapon_bullpupshotgun"):
if (bParam1)
{
return "WTU_SG_BLP";
}
else
{
return "WT_SG_BLP";
}
break;
case joaat("weapon_pistol50"):
if (bParam1)
{
return "WTU_PIST_50";
}
else
{
return "WT_PIST_50";
}
break;
case joaat("weapon_bottle"):
if (bParam1)
{
return "WTU_BOTTLE";
}
else
{
return "WT_BOTTLE";
}
break;
case joaat("weapon_gusenberg"):
if (bParam1)
{
return "WTU_GUSENBERG";
}
else
{
return "WT_GUSENBERG";
}
break;
case joaat("weapon_snspistol"):
if (bParam1)
{
return "WTU_SNSPISTOL";
}
else
{
return "WT_SNSPISTOL";
}
break;
case joaat("weapon_vintagepistol"):
if (bParam1)
{
return "WTU_VPISTOL";
}
else
{
return "WT_VPISTOL";
}
break;
case joaat("weapon_dagger"):
if (bParam1)
{
return "WTU_DAGGER";
}
else
{
return "WT_DAGGER";
}
break;
case joaat("weapon_flaregun"):
if (bParam1)
{
return "WTU_FLAREGUN";
}
else
{
return "WT_FLAREGUN";
}
break;
case joaat("weapon_heavypistol"):
if (bParam1)
{
return "WTU_HEAVYPSTL";
}
else
{
return "WT_HEAVYPSTL";
}
break;
case joaat("weapon_specialcarbine"):
if (bParam1)
{
return "WTU_RIFLE_SCBN";
}
else
{
return "WT_RIFLE_SCBN";
}
break;
case joaat("weapon_musket"):
if (bParam1)
{
return "WTU_MUSKET";
}
else
{
return "WT_MUSKET";
}
break;
case joaat("weapon_firework"):
if (bParam1)
{
return "WTU_FWRKLNCHR";
}
else
{
return "WT_FWRKLNCHR";
}
break;
case joaat("weapon_marksmanrifle"):
if (bParam1)
{
return "WTU_MKRIFLE";
}
else
{
return "WT_MKRIFLE";
}
break;
case joaat("weapon_heavyshotgun"):
if (bParam1)
{
return "WTU_HVYSHOT";
}
else
{
return "WT_HVYSHOT";
}
break;
case joaat("weapon_proxmine"):
if (bParam1)
{
return "WTU_PRXMINE";
}
else
{
return "WT_PRXMINE";
}
break;
case joaat("weapon_hominglauncher"):
if (bParam1)
{
return "WTU_HOMLNCH";
}
else
{
return "WT_HOMLNCH";
}
break;
case joaat("weapon_hatchet"):
if (bParam1)
{
return "WTU_HATCHET";
}
else
{
return "WT_HATCHET";
}
break;
case joaat("weapon_railgun"):
if (bParam1)
{
return "WTU_RAILGUN";
}
else
{
return "WT_RAILGUN";
}
break;
case joaat("weapon_combatpdw"):
if (bParam1)
{
return "WTU_COMBATPDW";
}
else
{
return "WT_COMBATPDW";
}
break;
case joaat("weapon_knuckle"):
if (bParam1)
{
return "WTU_KNUCKLE";
}
else
{
return "WT_KNUCKLE";
}
break;
case joaat("weapon_marksmanpistol"):
if (bParam1)
{
return "WTU_MKPISTOL";
}
else
{
return "WT_MKPISTOL";
}
break;
case joaat("weapon_bullpuprifle"):
if (bParam1)
{
return "WTU_BULLRIFLE";
}
else
{
return "WT_BULLRIFLE";
}
break;
case joaat("weapon_machete"):
if (bParam1)
{
return "WTU_MACHETE";
}
else
{
return "WT_MACHETE";
}
break;
case joaat("weapon_machinepistol"):
if (bParam1)
{
return "WTU_MCHPIST";
}
else
{
return "WT_MCHPIST";
}
break;
case joaat("weapon_flashlight"):
if (bParam1)
{
return "WTU_FLASHLIGHT";
}
else
{
return "WT_FLASHLIGHT";
}
break;
case joaat("weapon_dbshotgun"):
if (bParam1)
{
return "WTU_DBSHGN";
}
else
{
return "WT_DBSHGN";
}
break;
case joaat("weapon_compactrifle"):
if (bParam1)
{
return "WTU_CMPRIFLE";
}
else
{
return "WT_CMPRIFLE";
}
break;
case joaat("weapon_switchblade"):
if (bParam1)
{
return "WTU_SWBLADE";
}
else
{
return "WT_SWBLADE";
}
break;
case joaat("weapon_revolver"):
if (bParam1)
{
return "WTU_REVOLVER";
}
else
{
return "WT_REVOLVER";
}
break;
case joaat("weapon_autoshotgun"):
if (bParam1)
{
return "WTU_AUTOSHGN";
}
else
{
return "WT_AUTOSHGN";
}
break;
case joaat("weapon_battleaxe"):
if (bParam1)
{
return "WTU_BATTLEAXE";
}
else
{
return "WT_BATTLEAXE";
}
break;
case joaat("weapon_compactlauncher"):
if (bParam1)
{
return "WTU_CMPGL";
}
else
{
return "WT_CMPGL";
}
break;
case joaat("weapon_minismg"):
if (bParam1)
{
return "WTU_MINISMG";
}
else
{
return "WT_MINISMG";
}
break;
case joaat("weapon_pipebomb"):
if (bParam1)
{
return "WTU_PIPEBOMB";
}
else
{
return "WT_PIPEBOMB";
}
break;
case joaat("weapon_poolcue"):
if (bParam1)
{
return "WTU_POOLCUE";
}
else
{
return "WT_POOLCUE";
}
break;
case joaat("weapon_wrench"):
if (bParam1)
{
return "WTU_WRENCH";
}
else
{
return "WT_WRENCH";
}
break;
case joaat("weapon_cougar"):
return "WT_RAGE";
break;
case -159960575:
return "WT_VEH_WEP";
break;
case joaat("weapon_pistol_mk2"):
if (bParam1)
{
return "WTU_PIST2";
}
else
{
return "WT_PIST2";
}
break;
case joaat("weapon_smg_mk2"):
if (bParam1)
{
return "WTU_SMG2";
}
else
{
return "WT_SMG2";
}
break;
case joaat("weapon_heavysniper_mk2"):
if (bParam1)
{
return "WTU_SNIP_HVY2";
}
else
{
return "WT_SNIP_HVY2";
}
break;
case joaat("weapon_combatmg_mk2"):
if (bParam1)
{
return "WTU_MG_CBT2";
}
else
{
return "WT_MG_CBT2";
}
break;
case joaat("weapon_assaultrifle_mk2"):
if (bParam1)
{
return "WTU_RIFLE_ASL2";
}
else
{
return "WT_RIFLE_ASL2";
}
break;
case joaat("weapon_carbinerifle_mk2"):
if (bParam1)
{
return "WTU_RIFLE_CBN2";
}
else
{
return "WT_RIFLE_CBN2";
}
break;
case joaat("weapon_pumpshotgun_mk2"):
if (bParam1)
{
return "WTU_SG_PMP2";
}
else
{
return "WT_SG_PMP2";
}
break;
case joaat("weapon_specialcarbine_mk2"):
if (bParam1)
{
return "WTU_SPCARBINE2";
}
else
{
return "WT_SPCARBINE2";
}
break;
case joaat("weapon_snspistol_mk2"):
if (bParam1)
{
return "WTU_SNSPISTOL2";
}
else
{
return "WT_SNSPISTOL2";
}
break;
case joaat("weapon_marksmanrifle_mk2"):
if (bParam1)
{
return "WTU_MKRIFLE2";
}
else
{
return "WT_MKRIFLE2";
}
break;
case joaat("weapon_revolver_mk2"):
if (bParam1)
{
return "WTU_REVOLVER2";
}
else
{
return "WT_REVOLVER2";
}
break;
case joaat("weapon_bullpuprifle_mk2"):
if (bParam1)
{
return "WTU_BULLRIFLE2";
}
else
{
return "WT_BULLRIFLE2";
}
break;
case joaat("weapon_doubleaction"):
if (bParam1)
{
return "WTU_REV_DA";
}
else
{
return "WT_REV_DA";
}
break;
case joaat("weapon_stone_hatchet"):
if (bParam1)
{
return "WTU_SHATCHET";
}
else
{
return "WT_SHATCHET";
}
break;
case joaat("weapon_raypistol"):
if (bParam1)
{
return "WTU_RAYPISTOL";
}
else
{
return "WT_RAYPISTOL";
}
break;
case joaat("weapon_raycarbine"):
if (bParam1)
{
return "WTU_RAYCARBINE";
}
else
{
return "WT_RAYCARBINE";
}
break;
case joaat("weapon_rayminigun"):
if (bParam1)
{
return "WTU_RAYMINIGUN";
}
else
{
return "WT_RAYMINIGUN";
}
break;
case joaat("weapon_navyrevolver"):
if (bParam1)
{
return "WTU_REV_NV";
}
else
{
return "WT_REV_NV";
}
break;
case joaat("weapon_ceramicpistol"):
if (bParam1)
{
return "WTU_CERPST";
}
else
{
return "WT_CERPST";
}
break;
case joaat("weapon_gadgetpistol"):
if (bParam1)
{
return "WTU_GDGTPST";
}
else
{
return "WT_GDGTPST";
}
break;
case joaat("weapon_militaryrifle"):
if (bParam1)
{
return "WTU_MLTRYRFL";
}
else
{
return "WT_MLTRYRFL";
}
break;
case joaat("weapon_combatshotgun"):
if (bParam1)
{
return "WTU_CMBSHGN";
}
else
{
return "WT_CMBSHGN";
}
break;
case joaat("vehicle_weapon_turret_dinghy5_50cal"):
if (bParam1)
{
return "WTU_VEH_DINGHY_50C";
}
else
{
return "WTU_VEH_DINGHY_50C";
}
break;
case joaat("weapon_fertilizercan"):
if (bParam1)
{
return "WTU_FERTCAN";
}
else
{
return "WT_FERTCAN";
}
break;
case joaat("weapon_heavyrifle"):
if (bParam1)
{
return "WTU_HEAVYRIFLE";
}
else
{
return "WT_HEAVYRIFLE";
}
break;
case joaat("weapon_emplauncher"):
if (bParam1)
{
return "WTU_EMPL";
}
else
{
return "WT_EMPL";
}
break;
case joaat("weapon_stungun_mp"):
if (bParam1)
{
return "WTU_STNGUNMP";
}
else
{
return "WT_STNGUNMP";
}
break;
default:
if (func_116(iParam0, &Var0) != -1)
{
if (bParam1)
{
return func_115(&(Var0.f_31));
}
else
{
return func_115(&(Var0.f_7));
}
}
break;
}
return "WT_INVALID";
}
var func_115(var uParam0)
{
return uParam0;
}
int func_116(int iParam0, var* uParam1)
{
int iVar0;
int iVar1;
iVar1 = FILES::GET_NUM_DLC_WEAPONS();
iVar0 = 0;
while (iVar0 < iVar1)
{
if (FILES::GET_DLC_WEAPON_DATA(iVar0, uParam1))
{
if (uParam1->f_1 == iParam0)
{
return iVar0;
}
}
iVar0++;
}
return -1;
}
int func_117(int iParam0)
{
if (iParam0 == 600)
{
return joaat("weapon_railgun");
}
else if (iParam0 == 500)
{
return joaat("weapon_minigun");
}
else if (iParam0 == 400)
{
return joaat("weapon_mg");
}
else if (iParam0 == 401)
{
return joaat("weapon_combatmg");
}
else if (iParam0 == 402)
{
return -572349828;
}
else if (iParam0 == 300)
{
return joaat("weapon_assaultrifle");
}
else if (iParam0 == 301)
{
return joaat("weapon_carbinerifle");
}
else if (iParam0 == 302)
{
return joaat("weapon_advancedrifle");
}
else if (iParam0 == 303)
{
return joaat("weapon_heavyrifle");
}
else if (iParam0 == 200)
{
return joaat("weapon_pumpshotgun");
}
else if (iParam0 == 201)
{
return joaat("weapon_sawnoffshotgun");
}
else if (iParam0 == 202)
{
return joaat("weapon_assaultshotgun");
}
else if (iParam0 == 203)
{
return joaat("weapon_bullpupshotgun");
}
else if (iParam0 == 100)
{
return joaat("weapon_microsmg");
}
else if (iParam0 == 101)
{
return joaat("weapon_smg");
}
else if (iParam0 == 102)
{
return joaat("weapon_assaultsmg");
}
else if (iParam0 == 0)
{
return joaat("weapon_pistol");
}
else if (iParam0 == 1)
{
return joaat("weapon_combatpistol");
}
else if (iParam0 == 2)
{
return joaat("weapon_appistol");
}
else if (iParam0 == 3)
{
return joaat("weapon_pistol50");
}
return 0;
}
void func_118(int iParam0, int iParam1, int iParam2, int iParam3, char* sParam4, char* sParam5)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iParam1);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iParam2);
if (iParam3 > 0)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("NUMBER");
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam3);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING("SC_LB_EMPTY");
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_PLAYER_NAME_STRING(sParam4);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_PLAYER_NAME_STRING(sParam5);
}
int func_119(var* uParam0, var* uParam1)
{
if (!func_120(*uParam0))
{
return 0;
}
if (!func_120(*uParam1))
{
return 0;
}
if (NETWORK::NETWORK_ARE_HANDLES_THE_SAME(uParam0, uParam1))
{
return 1;
}
return 0;
}
bool func_120(var uParam0, var uParam1, var uParam2, var uParam3, var uParam4, var uParam5, var uParam6, var uParam7, var uParam8, var uParam9, var uParam10, var uParam11, var uParam12)
{
return NETWORK::NETWORK_IS_HANDLE_VALID(&uParam0, 13);
}
void func_121(var uParam0, var uParam1)
{
int iVar0;
int iVar1;
struct<75> Var2;
var uVar77;
Var2.f_60 = 6;
Var2.f_67 = 6;
if (!BitTest(uParam0->f_42, 5) && !BitTest(uParam0->f_42, 6))
{
iVar0 = 0;
while (iVar0 < 12)
{
if ((uParam1[iVar0 /*100*/])->f_75 != 0)
{
iVar1 = iVar0 + 1;
while (iVar1 <= 11)
{
if ((uParam1[iVar1 /*100*/])->f_75 != 0)
{
if ((uParam1[iVar1 /*100*/])->f_75 < (uParam1[iVar0 /*100*/])->f_75)
{
uVar77 = (uParam1[iVar1 /*100*/])->f_75;
(uParam1[iVar1 /*100*/])->f_75 = (uParam1[iVar0 /*100*/])->f_75;
(uParam1[iVar0 /*100*/])->f_75 = uVar77;
Var2 = { *(uParam1[iVar1 /*100*/]) };
*(uParam1[iVar1 /*100*/]) = { *(uParam1[iVar0 /*100*/]) };
*(uParam1[iVar0 /*100*/]) = { Var2 };
}
else if ((uParam1[iVar1 /*100*/])->f_75 == (uParam1[iVar0 /*100*/])->f_75)
{
if ((uParam1[iVar1 /*100*/])->f_59 != -1)
{
if ((uParam1[iVar1 /*100*/])->f_59 < (uParam1[iVar0 /*100*/])->f_59 || (uParam1[iVar0 /*100*/])->f_59 == -1)
{
uVar77 = (uParam1[iVar1 /*100*/])->f_75;
(uParam1[iVar1 /*100*/])->f_75 = (uParam1[iVar0 /*100*/])->f_75;
(uParam1[iVar0 /*100*/])->f_75 = uVar77;
Var2 = { *(uParam1[iVar1 /*100*/]) };
*(uParam1[iVar1 /*100*/]) = { *(uParam1[iVar0 /*100*/]) };
*(uParam1[iVar0 /*100*/]) = { Var2 };
}
}
}
}
iVar1++;
}
}
iVar0++;
}
}
}
void func_122(var uParam0, var uParam1)
{
var uVar0;
var uVar1;
var uVar2;
int iVar3;
int iVar4;
if (!BitTest(uParam0->f_42, 5) && !BitTest(uParam0->f_42, 6))
{
iVar4 = 0;
while (iVar4 < 12)
{
if (func_125(uParam1, iVar3, &uVar0, 0))
{
(uParam1[iVar3 /*100*/])->f_75 = 1;
iVar3++;
if (iVar3 >= 12)
{
return;
}
}
if (func_125(uParam1, iVar3, &uVar1, 1))
{
(uParam1[iVar3 /*100*/])->f_75 = 2;
iVar3++;
if (iVar3 >= 12)
{
return;
}
}
if (func_125(uParam1, iVar3, &uVar2, 2))
{
(uParam1[iVar3 /*100*/])->f_75 = 3;
iVar3++;
if (iVar3 >= 12)
{
return;
}
}
iVar4++;
}
}
else
{
func_123(uParam1);
}
}
void func_123(var uParam0)
{
int iVar0;
bool bVar1;
int iVar2;
struct<13> Var3;
int iVar16;
iVar0 = 0;
while (iVar0 < 3)
{
Global_2097536.f_2704[iVar0] = 0;
Global_2097536.f_2775[iVar0] = -1;
iVar0++;
}
Var3 = { func_60(PLAYER::PLAYER_ID()) };
if (STATS::LEADERBOARDS_GET_CACHE_EXISTS(Global_2097536.f_2826))
{
iVar16 = STATS::LEADERBOARDS_GET_CACHE_NUMBER_OF_ROWS(Global_2097536.f_2826);
iVar0 = 0;
iVar0 = 0;
while (iVar0 < iVar16)
{
if (iVar0 < 12)
{
func_124(&Global_2101737);
iVar2 = 0;
STATS::LEADERBOARDS_GET_CACHE_DATA_ROW(Global_2097536.f_2826, iVar0, &Global_2101737);
*(uParam0[iVar0 /*100*/]) = { Global_2101737.f_1 };
(uParam0[iVar0 /*100*/])->f_16 = { Global_2101737.f_17 };
(uParam0[iVar0 /*100*/])->f_32 = { Global_2101737.f_33 };
(uParam0[iVar0 /*100*/])->f_45 = { Global_2101737.f_46 };
(uParam0[iVar0 /*100*/])->f_58 = Global_2101737.f_59;
(uParam0[iVar0 /*100*/])->f_59 = Global_2101737.f_60;
Global_2097536.f_2708 = Global_2101737.f_62;
Global_2097536.f_2769 = Global_2101737.f_63;
iVar2 = 0;
if (BitTest(Global_2101737.f_61, 1))
{
iVar2 = 1;
}
else if (BitTest(Global_2101737.f_61, 2))
{
iVar2 = 2;
}
else if (BitTest(Global_2101737.f_61, 3))
{
iVar2 = 3;
}
Global_2097536.f_2704[(iVar2 - 1)]++;
(uParam0[iVar0 /*100*/])->f_75 = iVar2;
if ((uParam0[iVar0 /*100*/])->f_59 != -1)
{
if (BitTest(Global_2101737.f_61, 0))
{
(uParam0[iVar0 /*100*/])->f_74 = 1;
}
else
{
(uParam0[iVar0 /*100*/])->f_74 = 0;
}
if (func_119(&((uParam0[iVar0 /*100*/])->f_32), &Var3))
{
Global_2097536.f_2775[(iVar2 - 1)] = 0;
}
}
bVar1 = false;
while (bVar1 < Global_2101737.f_62)
{
if (BitTest(Global_2101737.f_63, bVar1))
{
(uParam0[iVar0 /*100*/])->f_67[bVar1] = Global_2101737.f_97[bVar1];
}
else
{
(uParam0[iVar0 /*100*/])->f_60[bVar1] = Global_2101737.f_64[bVar1];
}
bVar1++;
}
}
iVar0++;
}
}
}
void func_124(var uParam0)
{
struct<13> Var0;
int iVar13;
*uParam0 = 0;
StringCopy(&(uParam0->f_1), "", 64);
StringCopy(&(uParam0->f_17), "", 64);
uParam0->f_33 = { Var0 };
uParam0->f_46 = { Var0 };
uParam0->f_59 = 0;
uParam0->f_60 = 0;
uParam0->f_61 = 0;
uParam0->f_62 = 0;
uParam0->f_63 = 0;
iVar13 = 0;
while (iVar13 < 32)
{
uParam0->f_64[iVar13] = 0f;
uParam0->f_97[iVar13] = 0;
iVar13++;
}
}
int func_125(var uParam0, int iParam1, var uParam2, int iParam3)
{
int iVar0;
if (*uParam2 == 0)
{
if (Global_2097536[iParam3 /*901*/][0 /*75*/].f_59 > 0)
{
*(uParam0[iParam1 /*100*/]) = { Global_2097536[iParam3 /*901*/][0 /*75*/] };
Global_2101680[iParam3 /*16*/] = { Global_2097536[iParam3 /*901*/][0 /*75*/] };
Global_2101680.f_49[iParam3] = Global_2097536[iParam3 /*901*/][0 /*75*/].f_67[Global_2097536.f_2779];
Global_2101680.f_53[iParam3] = Global_2097536[iParam3 /*901*/][0 /*75*/].f_60[Global_2097536.f_2779];
*uParam2++;
return 1;
}
}
else if (*uParam2 == 1)
{
if (Global_2097536.f_2775[iParam3] > 0)
{
*(uParam0[iParam1 /*100*/]) = { Global_2097536[iParam3 /*901*/][Global_2097536.f_2775[iParam3] /*75*/] };
*uParam2++;
return 1;
}
else
{
if (Global_2097536.f_2775[iParam3] < 0)
{
StringCopy(uParam0[iParam1 /*100*/], PLAYER::GET_PLAYER_NAME(PLAYER::PLAYER_ID()), 64);
(uParam0[iParam1 /*100*/])->f_32 = { func_60(PLAYER::PLAYER_ID()) };
(uParam0[iParam1 /*100*/])->f_59 = -1;
(uParam0[iParam1 /*100*/])->f_67[0] = -1;
(uParam0[iParam1 /*100*/])->f_67[1] = -1;
(uParam0[iParam1 /*100*/])->f_67[2] = -1;
(uParam0[iParam1 /*100*/])->f_67[3] = -1;
(uParam0[iParam1 /*100*/])->f_60[0] = -1f;
(uParam0[iParam1 /*100*/])->f_60[1] = -1f;
(uParam0[iParam1 /*100*/])->f_60[2] = -1f;
(uParam0[iParam1 /*100*/])->f_60[3] = -1f;
*uParam2++;
return 1;
}
*uParam2++;
}
}
else if ((*uParam2 % 2) == 0)
{
iVar0 = (*uParam2 / 2);
if ((Global_2097536.f_2775[iParam3] - iVar0) >= 1)
{
if (Global_2097536[iParam3 /*901*/][(Global_2097536.f_2775[iParam3] - iVar0) /*75*/].f_59 > 0)
{
*(uParam0[iParam1 /*100*/]) = { Global_2097536[iParam3 /*901*/][(Global_2097536.f_2775[iParam3] - iVar0) /*75*/] };
*uParam2++;
return 1;
}
}
}
else
{
iVar0 = SYSTEM::FLOOR(SYSTEM::TO_FLOAT((*uParam2 / 2)));
if ((Global_2097536.f_2775[iParam3] + iVar0) < 12 && (Global_2097536.f_2775[iParam3] + iVar0) > 0)
{
if (Global_2097536[iParam3 /*901*/][(Global_2097536.f_2775[iParam3] + iVar0) /*75*/].f_59 > 1)
{
*(uParam0[iParam1 /*100*/]) = { Global_2097536[iParam3 /*901*/][(Global_2097536.f_2775[iParam3] + iVar0) /*75*/] };
*uParam2++;
return 1;
}
}
}
*uParam2++;
return 0;
}
void func_126(var uParam0)
{
struct<13> Var0;
int iVar13;
int iVar14;
iVar13 = 0;
while (iVar13 < 12)
{
StringCopy(uParam0[iVar13 /*100*/], "", 64);
StringCopy(&((uParam0[iVar13 /*100*/])->f_16), "", 64);
(uParam0[iVar13 /*100*/])->f_32 = { Var0 };
(uParam0[iVar13 /*100*/])->f_45 = { Var0 };
(uParam0[iVar13 /*100*/])->f_58 = 0;
(uParam0[iVar13 /*100*/])->f_59 = 0;
iVar14 = 0;
while (iVar14 < 6)
{
(uParam0[iVar13 /*100*/])->f_60[iVar14] = 0f;
(uParam0[iVar13 /*100*/])->f_67[iVar14] = 0;
iVar14++;
}
(uParam0[iVar13 /*100*/])->f_75 = 0;
(uParam0[iVar13 /*100*/])->f_74 = 0;
(uParam0[iVar13 /*100*/])->f_76 = 0;
(uParam0[iVar13 /*100*/])->f_77 = 0;
(uParam0[iVar13 /*100*/])->f_78 = 0;
(uParam0[iVar13 /*100*/])->f_79 = 0;
StringCopy(&((uParam0[iVar13 /*100*/])->f_80), "", 16);
iVar13++;
}
func_94(&(Global_2097536.f_2830));
}
void func_127(int iParam0, int iParam1, int iParam2, char* sParam3)
{
MISC::SET_BIT(&iParam2, 7);
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iParam1);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iParam2);
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sParam3);
GRAPHICS::_END_TEXT_COMMAND_SCALEFORM_STRING_2();
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
int func_128(var uParam0)
{
if (!Global_2097532)
{
if (!func_84(&(Global_2097536.f_2827)))
{
func_83(&(Global_2097536.f_2827), 1, 0);
return 0;
}
else if (!func_82(&(Global_2097536.f_2827), 1000, 1))
{
return 0;
}
}
if (((!NETWORK::NETWORK_HAS_VALID_ROS_CREDENTIALS() || !PLAYER::IS_PLAYER_ONLINE()) || (!NETWORK::NETWORK_HAVE_ONLINE_PRIVILEGES() && NETWORK::_NETWORK_HAS_AGE_RESTRICTED_PROFILE())) || Global_2097536.f_2832 != 0)
{
MISC::CLEAR_BIT(&(uParam0->f_42), 4);
return 1;
}
if (!BitTest(uParam0->f_42, 4))
{
func_164(uParam0);
MISC::SET_BIT(&(uParam0->f_42), 4);
return 0;
}
else if (BitTest(uParam0->f_42, 5))
{
(*uParam0)[0] = 2;
(*uParam0)[1] = 1;
(*uParam0)[2] = 3;
return 1;
}
if (!func_162(uParam0))
{
return 0;
}
if (!func_160(uParam0))
{
return 0;
}
if (!func_146(uParam0))
{
return 0;
}
if (!BitTest(uParam0->f_42, 6))
{
func_126(&Global_2101867);
func_122(uParam0, &Global_2101867);
func_121(uParam0, &Global_2101867);
MISC::SET_BIT(&(uParam0->f_42), 6);
}
if (!BitTest(uParam0->f_42, 7))
{
if (!func_84(&(Global_2097536.f_2830)))
{
func_83(&(Global_2097536.f_2830), 1, 0);
}
else if (func_82(&(Global_2097536.f_2830), 30000, 1))
{
MISC::SET_BIT(&(uParam0->f_42), 7);
}
if (func_143(&Global_2101867))
{
}
else
{
return 0;
}
if (func_139(&Global_2101867))
{
}
else
{
return 0;
}
if (func_133(&Global_2101867))
{
func_129(&Global_2101867);
MISC::SET_BIT(&(uParam0->f_42), 7);
func_129(&Global_2101867);
}
else
{
return 0;
}
}
return 1;
}
void func_129(var uParam0)
{
int iVar0;
bool bVar1;
int iVar2;
iVar2 = func_132(Global_2097536.f_2826);
if (Global_2100721.f_81[iVar2] != 0)
{
func_131(-1, iVar2);
}
iVar0 = 0;
while (iVar0 < 12)
{
func_124(&Global_2101737);
if ((uParam0[iVar0 /*100*/])->f_75 != 0)
{
Global_2101737 = Global_2097536.f_2826;
Global_2101737.f_1 = { *(uParam0[iVar0 /*100*/]) };
if (MISC::ARE_STRINGS_EQUAL(&((uParam0[iVar0 /*100*/])->f_16), ""))
{
Global_2101737.f_17 = { *(uParam0[iVar0 /*100*/]) };
}
else
{
Global_2101737.f_17 = { (uParam0[iVar0 /*100*/])->f_16 };
}
Global_2101737.f_33 = { (uParam0[iVar0 /*100*/])->f_32 };
if (func_120((uParam0[iVar0 /*100*/])->f_45))
{
Global_2101737.f_46 = { (uParam0[iVar0 /*100*/])->f_45 };
}
else
{
Global_2101737.f_46 = { (uParam0[iVar0 /*100*/])->f_32 };
}
Global_2101737.f_59 = (uParam0[iVar0 /*100*/])->f_58;
Global_2101737.f_60 = (uParam0[iVar0 /*100*/])->f_59;
Global_2101737.f_62 = Global_2097536.f_2708;
Global_2101737.f_63 = Global_2097536.f_2770;
if ((uParam0[iVar0 /*100*/])->f_74)
{
MISC::SET_BIT(&(Global_2101737.f_61), false);
}
else
{
MISC::CLEAR_BIT(&(Global_2101737.f_61), false);
}
MISC::SET_BIT(&(Global_2101737.f_61), (uParam0[iVar0 /*100*/])->f_75);
bVar1 = false;
while (bVar1 < Global_2101737.f_62)
{
if (BitTest(Global_2101737.f_63, bVar1))
{
Global_2101737.f_97[bVar1] = (uParam0[iVar0 /*100*/])->f_67[bVar1];
}
else
{
Global_2101737.f_64[bVar1] = (uParam0[iVar0 /*100*/])->f_60[bVar1];
}
bVar1++;
}
Global_2100721.f_81[iVar2] = Global_2097536.f_2826;
STATS::LEADERBOARDS_CACHE_DATA_ROW(&Global_2101737);
}
iVar0++;
}
Global_2100721.f_87[iVar2 /*3*/] = { func_130(PLAYER::PLAYER_ID()) };
}
Vector3 func_130(int iParam0)
{
return ENTITY::GET_ENTITY_COORDS(PLAYER::GET_PLAYER_PED(iParam0), false);
}
void func_131(int iParam0, int iParam1)
{
int iVar0;
if (iParam1 != -1)
{
if (STATS::LEADERBOARDS_GET_CACHE_EXISTS(Global_2100721.f_81[iParam1]))
{
STATS::_0x8EC74CEB042E7CFF(Global_2100721.f_81[iParam1]);
}
Global_2100721.f_81[iParam1] = 0;
}
else if (iParam0 != -1)
{
if (STATS::LEADERBOARDS_GET_CACHE_EXISTS(iParam0))
{
STATS::_0x8EC74CEB042E7CFF(iParam0);
}
iVar0 = 0;
while (iVar0 < 5)
{
if (Global_2100721.f_81[iVar0] == iParam0)
{
Global_2100721.f_81[iVar0] = 0;
}
iVar0++;
}
}
}
int func_132(int iParam0)
{
int iVar0;
int iVar1;
int iVar2;
int iVar3;
iVar0 = 0;
while (iVar0 < 5)
{
if (Global_2100721.f_81[iVar0] == iParam0)
{
return iVar0;
}
iVar0++;
}
iVar0 = 0;
iVar0 = 0;
while (iVar0 < 5)
{
if (Global_2100721.f_81[iVar0] == 0)
{
return iVar0;
}
else if (STATS::LEADERBOARDS_GET_CACHE_EXISTS(Global_2100721.f_81[iVar0]))
{
iVar3 = STATS::LEADERBOARDS_GET_CACHE_TIME(Global_2100721.f_81[iVar0]);
if (iVar3 > iVar2)
{
iVar1 = iVar0;
iVar2 = iVar3;
}
}
else
{
return iVar0;
}
iVar0++;
}
return iVar1;
}
int func_133(var uParam0)
{
int iVar0;
int iVar1;
switch ((uParam0[0 /*100*/])->f_76)
{
case 0:
func_137(uParam0);
if (func_92() && !NETWORK::NETWORK_HAVE_USER_CONTENT_PRIVILEGES(0))
{
(uParam0[0 /*100*/])->f_76 = 3;
return 0;
}
iVar0 = 0;
while (iVar0 < 12)
{
if (func_120((uParam0[iVar0 /*100*/])->f_32))
{
if (!func_136(&((uParam0[iVar0 /*100*/])->f_32), &Global_2103169))
{
Global_2103169[Global_2103169.f_206 /*13*/] = { (uParam0[iVar0 /*100*/])->f_32 };
Global_2103169.f_206++;
}
}
iVar0++;
}
if (Global_2103169.f_206 > 0)
{
(uParam0[0 /*100*/])->f_76 = 1;
}
else
{
(uParam0[0 /*100*/])->f_76 = 3;
}
break;
case 1:
if (func_134(&((uParam0[1 /*100*/])->f_76), &(Global_2103169.f_206), &Global_2103169, &(Global_2103169.f_157)))
{
(uParam0[0 /*100*/])->f_76 = 2;
}
break;
case 2:
if (Global_2103169.f_206 > 12)
{
Global_2103169.f_206 = 12;
}
iVar0 = 0;
while (iVar0 < 12)
{
iVar1 = 0;
while (iVar1 < Global_2103169.f_206)
{
if (func_120((uParam0[iVar0 /*100*/])->f_32) && func_120(Global_2103169[iVar1 /*13*/]))
{
if (NETWORK::NETWORK_ARE_HANDLES_THE_SAME(&((uParam0[iVar0 /*100*/])->f_32), &(Global_2103169[iVar1 /*13*/])))
{
(uParam0[iVar0 /*100*/])->f_80 = { Global_2103169.f_157[iVar1 /*4*/] };
}
}
iVar1++;
}
iVar0++;
}
(uParam0[0 /*100*/])->f_76 = 3;
break;
case 3:
return 1;
break;
}
return 0;
}
int func_134(var uParam0, var uParam1, var* uParam2, var uParam3)
{
var* uVar0;
int iVar35;
switch (*uParam0)
{
case 0:
if (NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_PENDING())
{
}
else
{
NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_CLEAR();
NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_START(uParam2, *uParam1);
*uParam0 = 1;
}
break;
case 1:
if (!NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_PENDING())
{
if (NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_SUCCESS())
{
*uParam0 = 2;
}
else
{
*uParam0 = 3;
}
}
break;
case 2:
iVar35 = 0;
while (iVar35 < *uParam1)
{
if (NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_NEW(uParam2[iVar35 /*13*/], &uVar0))
{
func_135(&uVar0, uParam3[iVar35 /*4*/]);
}
iVar35++;
}
if (NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_PENDING())
{
NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_CANCEL();
}
else
{
NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_CLEAR();
}
*uParam0 = 3;
break;
case 3:
return 1;
break;
}
return 0;
}
void func_135(var* uParam0, char* sParam1)
{
NETWORK::NETWORK_CLAN_GET_UI_FORMATTED_TAG(uParam0, 35, sParam1);
}
int func_136(var* uParam0, var uParam1)
{
int iVar0;
iVar0 = 0;
while (iVar0 < 12)
{
if (func_120(*(uParam1[iVar0 /*13*/])))
{
if (NETWORK::NETWORK_ARE_HANDLES_THE_SAME(uParam0, uParam1[iVar0 /*13*/]))
{
return 1;
}
}
iVar0++;
}
return 0;
}
void func_137(var uParam0)
{
int iVar0;
iVar0 = 0;
while (iVar0 < 12)
{
func_138(&(Global_2103169[iVar0 /*13*/]));
StringCopy(&(Global_2103169.f_157[iVar0 /*4*/]), "", 16);
iVar0++;
}
if ((uParam0[0 /*100*/])->f_76 > 0)
{
(uParam0[0 /*100*/])->f_76 = 0;
(uParam0[1 /*100*/])->f_76 = 0;
if (!NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_PENDING())
{
NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_CLEAR();
}
}
if (NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_PENDING())
{
NETWORK::NETWORK_GET_PRIMARY_CLAN_DATA_CANCEL();
}
Global_2103169.f_206 = 0;
}
void func_138(var uParam0)
{
*uParam0 = 0;
uParam0->f_1 = 0;
uParam0->f_2 = 0;
uParam0->f_3 = 0;
uParam0->f_4 = 0;
uParam0->f_5 = 0;
uParam0->f_6 = 0;
uParam0->f_7 = 0;
uParam0->f_8 = 0;
uParam0->f_9 = 0;
uParam0->f_10 = 0;
uParam0->f_11 = 0;
uParam0->f_12 = 0;
}
int func_139(var uParam0)
{
int iVar0;
if (MISC::IS_PC_VERSION())
{
return 1;
}
else if (func_142() || func_92())
{
if (!func_141(uParam0))
{
return 0;
}
}
else
{
iVar0 = 0;
while (iVar0 < 12)
{
if (!func_140(&((uParam0[iVar0 /*100*/])->f_78), &((uParam0[iVar0 /*100*/])->f_32), uParam0[iVar0 /*100*/]))
{
return 0;
}
iVar0++;
}
}
return 1;
}
int func_140(var uParam0, var* uParam1, char* sParam2)
{
if (*uParam0 == 2)
{
return 1;
}
switch (*uParam0)
{
case 0:
if (func_120(*uParam1))
{
if (!NETWORK::NETWORK_IS_GAMER_IN_MY_SESSION(uParam1))
{
if (func_142() || func_92())
{
if (NETWORK::NETWORK_GAMERTAG_FROM_HANDLE_START(uParam1))
{
*uParam0 = 1;
}
}
else if (MISC::IS_XBOX360_VERSION())
{
if (NETWORK::NETWORK_GAMERTAG_FROM_HANDLE_START(uParam1))
{
*uParam0 = 1;
}
}
else
{
StringCopy(sParam2, NETWORK::NETWORK_GET_GAMERTAG_FROM_HANDLE(uParam1), 64);
if (MISC::IS_PS3_VERSION())
{
}
else if (func_92())
{
}
else if (MISC::IS_PC_VERSION())
{
}
*uParam0 = 2;
}
}
else
{
StringCopy(sParam2, PLAYER::GET_PLAYER_NAME(NETWORK::NETWORK_GET_PLAYER_FROM_GAMER_HANDLE(uParam1)), 64);
*uParam0 = 2;
}
}
else
{
*uParam0 = 2;
}
break;
case 1:
if (!NETWORK::NETWORK_IS_GAMER_IN_MY_SESSION(uParam1))
{
if (!NETWORK::NETWORK_GAMERTAG_FROM_HANDLE_PENDING())
{
if (NETWORK::NETWORK_GAMERTAG_FROM_HANDLE_SUCCEEDED())
{
StringCopy(sParam2, NETWORK::NETWORK_GET_GAMERTAG_FROM_HANDLE(uParam1), 64);
}
*uParam0 = 2;
return 1;
}
}
else
{
StringCopy(sParam2, PLAYER::GET_PLAYER_NAME(NETWORK::NETWORK_GET_PLAYER_FROM_GAMER_HANDLE(uParam1)), 64);
*uParam0 = 2;
}
break;
case 2:
return 1;
break;
}
return 0;
}
int func_141(var uParam0)
{
int iVar0;
int iVar1;
int iVar2;
if (!func_142() && !func_92())
{
return 1;
}
if ((uParam0[0 /*100*/])->f_78 == 2)
{
return 1;
}
switch ((uParam0[0 /*100*/])->f_78)
{
case 0:
Global_2097536.f_3183 = 0;
iVar1 = 0;
while (iVar1 < 12)
{
StringCopy(&(Global_2097536.f_2833[iVar1 /*16*/]), "", 64);
func_138(&(Global_2097536.f_3026[iVar1 /*13*/]));
if (func_120((uParam0[iVar1 /*100*/])->f_32))
{
Global_2097536.f_3026[Global_2097536.f_3183 /*13*/] = { (uParam0[iVar1 /*100*/])->f_32 };
Global_2097536.f_3183++;
}
iVar1++;
}
if (Global_2097536.f_3183 > 0)
{
(uParam0[0 /*100*/])->f_79 = NETWORK::NETWORK_DISPLAYNAMES_FROM_HANDLES_START(&(Global_2097536.f_3026), Global_2097536.f_3183);
(uParam0[0 /*100*/])->f_78 = 1;
}
else
{
(uParam0[0 /*100*/])->f_78 = 2;
}
break;
case 1:
iVar0 = NETWORK::NETWORK_GET_DISPLAYNAMES_FROM_HANDLES((uParam0[0 /*100*/])->f_79, &(Global_2097536.f_2833), Global_2097536.f_3183);
if (iVar0 == 0)
{
iVar1 = 0;
while (iVar1 < 12)
{
if (func_120((uParam0[iVar1 /*100*/])->f_32))
{
*(uParam0[iVar1 /*100*/]) = { Global_2097536.f_2833[iVar2 /*16*/] };
iVar2++;
}
iVar1++;
}
(uParam0[0 /*100*/])->f_78 = 2;
}
else if (iVar0 == -1)
{
(uParam0[0 /*100*/])->f_78 = 2;
}
else
{
return 0;
}
break;
case 2:
(uParam0[0 /*100*/])->f_79 = -1;
return 1;
break;
}
return 0;
}
bool func_142()
{
return (MISC::IS_DURANGO_VERSION() || unk_0xC545AB1CF97ABB34());
}
int func_143(var uParam0)
{
int iVar0;
if (func_142() || func_92())
{
iVar0 = 0;
while (iVar0 < 12)
{
if (!func_145(&((uParam0[iVar0 /*100*/])->f_77), &((uParam0[iVar0 /*100*/])->f_16), &((uParam0[iVar0 /*100*/])->f_84), &(Global_2097536.f_2833), &((uParam0[iVar0 /*100*/])->f_79)))
{
return 0;
}
iVar0++;
}
}
else
{
iVar0 = 0;
while (iVar0 < 12)
{
if (!func_144(&((uParam0[iVar0 /*100*/])->f_77), (uParam0[iVar0 /*100*/])->f_16, &((uParam0[iVar0 /*100*/])->f_84)))
{
return 0;
}
iVar0++;
}
}
return 1;
}
int func_144(var uParam0, var uParam1, var uParam2, var uParam3, var uParam4, var uParam5, var uParam6, var uParam7, var uParam8, var uParam9, var uParam10, var uParam11, var uParam12, var uParam13, var uParam14, var uParam15, var uParam16, char* sParam17)
{
struct<13> Var0;
if (*uParam0 == 2)
{
return 1;
}
else if (MISC::IS_STRING_NULL_OR_EMPTY(&uParam1))
{
*uParam0 = 2;
return 1;
}
NETWORK::NETWORK_HANDLE_FROM_USER_ID(&uParam1, &Var0, 13);
switch (*uParam0)
{
case 0:
if (func_120(Var0))
{
if (!NETWORK::NETWORK_IS_GAMER_IN_MY_SESSION(&Var0))
{
if ((MISC::IS_XBOX360_VERSION() || func_142()) || func_92())
{
if (NETWORK::NETWORK_GAMERTAG_FROM_HANDLE_START(&Var0))
{
*uParam0 = 1;
}
}
else
{
StringCopy(sParam17, NETWORK::NETWORK_GET_GAMERTAG_FROM_HANDLE(&Var0), 64);
if (MISC::IS_PS3_VERSION())
{
}
else if (func_92())
{
}
else if (MISC::IS_PC_VERSION())
{
}
*uParam0 = 2;
}
}
else
{
StringCopy(sParam17, PLAYER::GET_PLAYER_NAME(NETWORK::NETWORK_GET_PLAYER_FROM_GAMER_HANDLE(&Var0)), 64);
*uParam0 = 2;
}
}
else
{
*uParam0 = 2;
}
break;
case 1:
if (!NETWORK::NETWORK_IS_GAMER_IN_MY_SESSION(&Var0))
{
if (!NETWORK::NETWORK_GAMERTAG_FROM_HANDLE_PENDING())
{
if (NETWORK::NETWORK_GAMERTAG_FROM_HANDLE_SUCCEEDED())
{
StringCopy(sParam17, NETWORK::NETWORK_GET_GAMERTAG_FROM_HANDLE(&Var0), 64);
}
*uParam0 = 2;
return 1;
}
}
else
{
StringCopy(sParam17, PLAYER::GET_PLAYER_NAME(NETWORK::NETWORK_GET_PLAYER_FROM_GAMER_HANDLE(&Var0)), 64);
*uParam0 = 2;
}
break;
case 2:
return 1;
break;
}
return 0;
}
int func_145(var uParam0, char* sParam1, char* sParam2, int iParam3, var uParam4)
{
int iVar0;
struct<13> Var1[1];
if (!func_142() && !func_92())
{
return 1;
}
if (*uParam0 == 2)
{
return 1;
}
else if (MISC::IS_STRING_NULL_OR_EMPTY(sParam1))
{
*uParam0 = 2;
return 1;
}
NETWORK::NETWORK_HANDLE_FROM_USER_ID(sParam1, &(Var1[0 /*13*/]), 13);
switch (*uParam0)
{
case 0:
StringCopy(iParam3[0 /*16*/], "", 64);
if (func_120(Var1[0 /*13*/]))
{
if (!NETWORK::NETWORK_IS_GAMER_IN_MY_SESSION(&(Var1[0 /*13*/])))
{
*uParam4 = NETWORK::NETWORK_DISPLAYNAMES_FROM_HANDLES_START(&Var1, 1);
*uParam0 = 1;
}
else
{
StringCopy(sParam2, PLAYER::GET_PLAYER_NAME(NETWORK::NETWORK_GET_PLAYER_FROM_GAMER_HANDLE(&(Var1[0 /*13*/]))), 64);
*uParam0 = 2;
}
}
else
{
*uParam0 = 2;
}
break;
case 1:
iVar0 = NETWORK::NETWORK_GET_DISPLAYNAMES_FROM_HANDLES(*uParam4, iParam3, 1);
if (iVar0 == 0)
{
*sParam2 = { *(iParam3[0 /*16*/]) };
*uParam0 = 2;
}
else if (iVar0 == -1)
{
*uParam0 = 2;
}
else
{
return 0;
}
break;
case 2:
*uParam4 = -1;
return 1;
break;
}
return 0;
}
int func_146(var uParam0)
{
struct<97> Var0;
struct<6> Var98;
int iVar106;
int iVar107;
int iVar108;
int iVar109;
int iVar110;
int iVar111;
bool bVar112;
bool bVar113;
bool bVar114;
int iVar115;
struct<13> Var116;
Var0.f_19.f_1 = 4;
iVar109 = -1;
bVar113 = 2;
Var116 = { func_60(PLAYER::PLAYER_ID()) };
switch ((*uParam0)[bVar113])
{
case 0:
Global_2097536.f_2775[bVar113] = -1;
Global_2097536.f_2704[bVar113] = 0;
Global_2097157.f_374 = -1;
if (NETWORK::NETWORK_CLAN_SERVICE_IS_VALID())
{
if (NETWORK::NETWORK_CLAN_PLAYER_IS_ACTIVE(&Var116))
{
if (NETWORK::NETWORK_CLAN_PLAYER_GET_DESC(&(uParam0->f_7), 35, &Var116))
{
uParam0->f_44.f_2 = uParam0->f_7;
uParam0->f_44.f_1 = 3;
(*uParam0)[bVar113] = 1;
return 0;
}
}
else
{
(*uParam0)[bVar113] = 3;
return 1;
}
}
else
{
(*uParam0)[bVar113] = 3;
return 1;
}
break;
case 1:
uParam0->f_44.f_1 = 3;
Var98.f_0 = uParam0->f_44;
Var98.f_1 = uParam0->f_44.f_1;
if (func_158(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44), 11, &Var116, func_159(), 0, 0, 0))
{
func_157(&Var98, &(uParam0->f_44));
if (uParam0->f_5 && STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_START(&Var98))
{
if (Var98.f_3 > 0)
{
iVar111 = 0;
iVar106 = 0;
if (func_159())
{
iVar111 = 0;
while (iVar111 < Var98.f_3)
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(iVar111, &Var0);
if (Global_2097157.f_374 < 0)
{
if (func_119(&Var0, &Var116) || func_119(&Var0, &(Global_2097157.f_361)))
{
Global_2097157.f_374 = Var0.f_96;
}
}
if (iVar109 < 0)
{
if (BitTest(Global_2097157.f_142.f_2, 0))
{
if (Global_2097157.f_211.f_36[0] >= STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar111, false))
{
iVar109 = iVar111;
}
}
else if (Global_2097157.f_211.f_3[0] >= STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar111, false))
{
iVar109 = iVar111;
}
}
func_156(&Var0);
iVar111++;
}
if (iVar109 < 0)
{
iVar109 = Var98.f_3;
}
}
iVar111 = 0;
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(0, &Var0);
if (Var0.f_96 <= 1)
{
if (Global_2097536.f_2704[bVar113] < 11)
{
if (func_159() && iVar109 == 0)
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), Var0.f_96);
Global_2097536.f_2775[bVar113] = 0;
Global_2097536.f_2704[bVar113]++;
}
if (func_159() && (func_119(&Var0, &Var116) || func_119(&Var0, &(Global_2097157.f_361))))
{
}
else
{
if (func_119(&Var0, &Var116))
{
iVar109 = 0;
Global_2097536.f_2775[bVar113] = 0;
}
MemCopy(&(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), {Var0.f_13}, 16);
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_32 = { Var0 };
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_59 = Var0.f_96;
if (func_154(uParam0->f_44))
{
iVar108 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2709);
if (iVar108 == 1)
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_58 = 1;
}
else
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_16), {Var0.f_19.f_1[1 /*16*/].f_8}, 16);
}
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_74 = 1;
iVar107 = 0;
iVar107 = 0;
while (iVar107 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar107]))
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_67[iVar107] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2710[iVar107]);
}
else
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_60[iVar107] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(0, Global_2097536.f_2710[iVar107]);
}
iVar107++;
}
Global_2097536.f_2704[bVar113]++;
}
bVar112 = true;
}
}
if (!bVar112)
{
Global_2097536.f_2704[bVar113]++;
}
if (!func_159())
{
iVar109 = Var98.f_5;
}
if (iVar109 > 6)
{
iVar110 = (iVar109 - 6);
}
else if (bVar112)
{
iVar110 = 1;
}
else
{
iVar110 = 0;
}
iVar111 = iVar110;
func_156(&Var0);
iVar111 = iVar110;
while (iVar111 <= (Var98.f_3 - 1))
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(iVar111, &Var0);
if (Global_2097536.f_2704[bVar113] < 11 && Var0.f_96 > 1)
{
if (func_159() && iVar109 == iVar111)
{
if (!func_119(&(Global_2097536[bVar113 /*901*/][0 /*75*/].f_32), &Var116))
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), Var0.f_96);
Global_2097536.f_2775[bVar113] = Global_2097536.f_2704[bVar113];
Global_2097536.f_2704[bVar113]++;
}
}
if (func_159() && (func_119(&Var0, &Var116) || func_119(&Var0, &(Global_2097157.f_361))))
{
}
else if (Global_2097536.f_2704[bVar113] < 11)
{
if (func_120(Var0) && !func_119(&Var0, &(Global_2097536[bVar113 /*901*/][0 /*75*/].f_32)))
{
if (func_119(&Var0, &Var116))
{
if (Global_2097536.f_2775[bVar113] < 0)
{
Global_2097536.f_2775[bVar113] = Global_2097536.f_2704[bVar113];
}
}
MemCopy(&(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), {Var0.f_13}, 16);
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_32 = { Var0 };
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_59 = Var0.f_96;
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_74 = 1;
if (func_154(uParam0->f_44))
{
iVar108 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar111, Global_2097536.f_2709);
if (iVar108 == 1)
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_58 = 1;
}
else
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_16), {Var0.f_19.f_1[1 /*16*/].f_8}, 16);
}
iVar106 = 0;
iVar106 = 0;
while (iVar106 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar106]))
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_67[iVar106] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar111, Global_2097536.f_2710[iVar106]);
}
else
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_60[iVar106] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar111, Global_2097536.f_2710[iVar106]);
}
iVar106++;
}
Global_2097536.f_2704[bVar113]++;
}
}
}
func_156(&Var0);
iVar111++;
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
if (bVar112)
{
if (Global_2097536.f_2775[bVar113] == -1 && func_159())
{
if (Global_2097536.f_2704[bVar113] >= 1)
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), Global_2097536[bVar113 /*901*/][(Global_2097536.f_2704[bVar113] - 1) /*75*/].f_59 + 1);
}
else
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), 1);
}
Global_2097536.f_2775[bVar113] = Global_2097536.f_2704[bVar113];
Global_2097536.f_2704[bVar113]++;
}
(*uParam0)[bVar113] = 3;
}
else
{
(*uParam0)[bVar113] = 2;
}
}
else
{
if (!bVar112)
{
Global_2097536.f_2704[bVar113]++;
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
Global_2097536.f_2775[bVar113] = -1;
(*uParam0)[bVar113] = 2;
}
}
else
{
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
Global_2097536.f_2775[bVar113] = -1;
(*uParam0)[bVar113] = 2;
MISC::SET_BIT(&(Global_2097536.f_2832), bVar113);
}
}
break;
case 2:
if (Global_2097536.f_2775[bVar113] == -1)
{
iVar115 = 11;
}
else
{
iVar115 = 1;
}
uParam0->f_44.f_1 = 3;
Var98.f_0 = uParam0->f_44;
Var98.f_1 = uParam0->f_44.f_1;
if (func_148(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44), 1, iVar115))
{
func_157(&Var98, &(uParam0->f_44));
if (uParam0->f_5 && STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_START(&Var98))
{
if (Var98.f_3 > 0)
{
iVar106 = 0;
while (iVar106 < Var98.f_3)
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(iVar106, &Var0);
bVar114 = false;
if (Global_2097536[bVar113 /*901*/][0 /*75*/].f_59 > 1 || Global_2097536[bVar113 /*901*/][0 /*75*/].f_59 <= 0)
{
bVar114 = true;
}
if (Global_2097536.f_2704[bVar113] < 11 || bVar114)
{
if (func_159() && (func_119(&Var0, &Var116) || func_119(&Var0, &(Global_2097157.f_361))))
{
}
else if (iVar106 == 0 || bVar114)
{
MemCopy(&(Global_2097536[bVar113 /*901*/][0 /*75*/]), {Var0.f_13}, 16);
Global_2097536[bVar113 /*901*/][0 /*75*/].f_32 = { Var0 };
Global_2097536[bVar113 /*901*/][0 /*75*/].f_59 = Var0.f_96;
if (func_154(uParam0->f_44))
{
iVar108 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2709);
if (iVar108 == 1)
{
Global_2097536[bVar113 /*901*/][0 /*75*/].f_58 = 1;
}
else
{
Global_2097536[bVar113 /*901*/][0 /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[bVar113 /*901*/][0 /*75*/].f_16), {Var0.f_19.f_1[1 /*16*/].f_8}, 16);
}
Global_2097536[bVar113 /*901*/][0 /*75*/].f_74 = 1;
iVar107 = 0;
iVar107 = 0;
while (iVar107 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar107]))
{
Global_2097536[bVar113 /*901*/][0 /*75*/].f_67[iVar107] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2710[iVar107]);
}
else
{
Global_2097536[bVar113 /*901*/][0 /*75*/].f_60[iVar107] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(0, Global_2097536.f_2710[iVar107]);
}
iVar107++;
}
if (Global_2097536.f_2704[bVar113] == 0)
{
if (bVar114)
{
}
else
{
Global_2097536.f_2704[bVar113]++;
}
}
}
else if (Global_2097536.f_2704[bVar113] < 11)
{
MemCopy(&(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), {Var0.f_13}, 16);
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_32 = { Var0 };
if (func_154(uParam0->f_44))
{
iVar108 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar106, Global_2097536.f_2709);
if (iVar108 == 1)
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_58 = 1;
}
else
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_16), {Var0.f_19.f_1[1 /*16*/].f_8}, 16);
}
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_59 = Var0.f_96;
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_74 = 1;
iVar107 = 0;
iVar107 = 0;
while (iVar107 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar107]))
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_67[iVar107] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar106, Global_2097536.f_2710[iVar107]);
}
else
{
Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_60[iVar107] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar106, Global_2097536.f_2710[iVar107]);
}
iVar107++;
}
if (iVar106 != 0)
{
Global_2097536.f_2704[bVar113]++;
}
}
}
func_156(&Var0);
iVar106++;
}
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
(*uParam0)[bVar113] = 3;
}
else
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
MISC::SET_BIT(&(Global_2097536.f_2832), bVar113);
Global_2097536.f_2704[bVar113] = 0;
(*uParam0)[bVar113] = 3;
}
if (Global_2097536.f_2775[bVar113] == -1 && func_159())
{
if (Global_2097536.f_2704[bVar113] >= 1)
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), Global_2097536[bVar113 /*901*/][(Global_2097536.f_2704[bVar113] - 1) /*75*/].f_59 + 1);
}
else
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), 1);
}
Global_2097536.f_2775[bVar113] = Global_2097536.f_2704[bVar113];
Global_2097536.f_2704[bVar113]++;
}
}
break;
case 3:
func_147(bVar113, Global_2097157.f_374);
(*uParam0)[bVar113] = 4;
break;
case 4:
return 1;
break;
}
return 0;
}
void func_147(bool bParam0, int iParam1)
{
int iVar0;
if ((func_159() && Global_2097536.f_2704[bParam0] > Global_2097536.f_2775[bParam0]) && Global_2097536.f_2775[bParam0] >= 0)
{
if (iParam1 != Global_2097536[bParam0 /*901*/][Global_2097536.f_2775[bParam0] /*75*/].f_59)
{
iVar0 = 0;
while (iVar0 < Global_2097536.f_2704[bParam0])
{
if (iVar0 != Global_2097536.f_2775[bParam0])
{
if (Global_2097536[bParam0 /*901*/][iVar0 /*75*/].f_59 >= Global_2097536[bParam0 /*901*/][Global_2097536.f_2775[bParam0] /*75*/].f_59)
{
if (Global_2097536[bParam0 /*901*/][iVar0 /*75*/].f_59 < iParam1 || iParam1 == -1)
{
Global_2097536[bParam0 /*901*/][iVar0 /*75*/].f_59++;
}
}
}
iVar0++;
}
}
}
else
{
if (!func_159())
{
}
if (Global_2097536.f_2704[bParam0] <= Global_2097536.f_2775[bParam0])
{
}
if (Global_2097536.f_2775[bParam0] < 0)
{
}
}
}
int func_148(var uParam0, var uParam1, var* uParam2, int iParam3, int iParam4)
{
switch (*uParam0)
{
case 0:
if (!func_151() && !func_150())
{
func_149(*uParam2);
if (STATS::LEADERBOARDS2_READ_BY_RANK(uParam2, iParam3, iParam4))
{
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0 = 3;
}
}
break;
case 1:
if (!STATS::LEADERBOARDS_READ_PENDING(*uParam2, uParam2->f_1, -1))
{
*uParam0++;
}
break;
case 2:
if (STATS::LEADERBOARDS_READ_SUCCESSFUL(*uParam2, uParam2->f_1, 0))
{
*uParam1 = 1;
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0++;
}
break;
case 3:
return 1;
break;
}
return 0;
}
void func_149(struct<2> Param0, var uParam2, var uParam3, var uParam4, var uParam5, var uParam6, var uParam7, var uParam8, var uParam9, var uParam10, var uParam11, var uParam12, var uParam13, var uParam14, var uParam15, var uParam16, var uParam17, var uParam18, var uParam19, var uParam20, var uParam21, var uParam22, var uParam23, var uParam24, var uParam25, var uParam26, var uParam27, var uParam28, var uParam29, var uParam30, var uParam31, var uParam32, var uParam33, var uParam34, var uParam35, var uParam36, var uParam37, var uParam38, var uParam39, var uParam40, var uParam41, var uParam42, var uParam43, var uParam44, var uParam45, var uParam46, var uParam47, var uParam48, var uParam49, var uParam50, var uParam51, var uParam52, var uParam53, var uParam54, var uParam55, var uParam56, var uParam57, var uParam58, var uParam59, var uParam60, var uParam61, var uParam62, var uParam63, var uParam64, var uParam65, var uParam66, var uParam67, var uParam68)
{
Global_2097152 = 1;
func_180(&(Global_2097152.f_1), 1, 0);
Global_2097152.f_3 = Param0.f_0;
Global_2097152.f_4 = Param0.f_1;
}
int func_150()
{
if (HUD::IS_PAUSE_MENU_ACTIVE() && !func_172())
{
return 1;
}
return 0;
}
int func_151()
{
if (STATS::LEADERBOARDS_READ_ANY_PENDING() || Global_2097152)
{
func_152();
return 1;
}
return 0;
}
void func_152()
{
if (func_82(&(Global_2097152.f_1), 120000, 1))
{
STATS::LEADERBOARDS_READ_CLEAR(Global_2097152.f_3, Global_2097152.f_4, -1);
Global_2097152 = 0;
func_94(&(Global_2097152.f_1));
}
}
void func_153(var uParam0, var uParam1, var uParam2)
{
*uParam0 = 0;
*uParam1 = 0;
Global_2097152 = 0;
func_94(&(Global_2097152.f_1));
STATS::LEADERBOARDS_READ_CLEAR(*uParam2, uParam2->f_1, -1);
}
int func_154(int iParam0)
{
if ((((((iParam0 == 815 || iParam0 == 824) || iParam0 == 825) || iParam0 == 826) || iParam0 == 827) || iParam0 == 828) || iParam0 == 849)
{
return 1;
}
return 0;
}
void func_155(var uParam0, char* sParam1, int iParam2)
{
int iVar0;
int iVar1;
if (func_169(uParam0->f_44))
{
MemCopy(sParam1, {Global_2097157.f_355}, 16);
sParam1->f_32 = { Global_2097157.f_361 };
MemCopy(&(sParam1->f_16), {Global_2097157.f_349}, 16);
}
else
{
StringCopy(sParam1, PLAYER::GET_PLAYER_NAME(PLAYER::PLAYER_ID()), 64);
sParam1->f_32 = { func_60(PLAYER::PLAYER_ID()) };
}
sParam1->f_59 = iParam2;
if (func_154(uParam0->f_44))
{
iVar0 = Global_2097157.f_211.f_36[Global_2097536.f_2709];
if (iVar0 == 1)
{
sParam1->f_58 = 1;
}
else
{
sParam1->f_58 = 0;
}
}
sParam1->f_74 = 1;
iVar1 = 0;
while (iVar1 < Global_2097536.f_2708)
{
if (BitTest(Global_2097157.f_142.f_2, Global_2097536.f_2710[iVar1]))
{
sParam1->f_67[iVar1] = Global_2097157.f_211.f_36[Global_2097536.f_2710[iVar1]];
}
else
{
sParam1->f_60[iVar1] = Global_2097157.f_211.f_3[Global_2097536.f_2710[iVar1]];
}
iVar1++;
}
}
void func_156(var uParam0)
{
int iVar0;
*uParam0 = 0;
uParam0->f_1 = 0;
uParam0->f_2 = 0;
uParam0->f_3 = 0;
uParam0->f_4 = 0;
uParam0->f_5 = 0;
uParam0->f_6 = 0;
uParam0->f_7 = 0;
uParam0->f_8 = 0;
uParam0->f_9 = 0;
uParam0->f_10 = 0;
uParam0->f_11 = 0;
uParam0->f_12 = 0;
StringCopy(&(uParam0->f_13), "", 24);
uParam0->f_19 = 0;
iVar0 = 0;
while (iVar0 < 4)
{
StringCopy(&(uParam0->f_19.f_1[iVar0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_19.f_1[iVar0 /*16*/].f_8), "", 32);
iVar0++;
}
uParam0->f_85 = 0;
StringCopy(&(uParam0->f_86), "", 32);
StringCopy(&(uParam0->f_94), "", 8);
uParam0->f_96 = 0;
uParam0->f_97 = 0;
}
void func_157(var uParam0, var uParam1)
{
*uParam0 = *uParam1;
uParam0->f_1 = uParam1->f_1;
uParam0->f_2 = 0;
}
int func_158(var uParam0, var uParam1, var* uParam2, int iParam3, var* uParam4, bool bParam5, bool bParam6, int iParam7, int iParam8)
{
int iVar0;
float fVar1;
iVar0 = Global_2097157.f_211.f_36[0];
fVar1 = Global_2097157.f_211.f_3[0];
if (bParam6)
{
iVar0 = iParam7;
fVar1 = iParam8;
}
switch (*uParam0)
{
case 0:
if (!func_151() && !func_150())
{
func_149(*uParam2);
if (bParam5)
{
if (BitTest(Global_2097157.f_142.f_2, 0))
{
if (STATS::LEADERBOARDS2_READ_BY_SCORE_INT(uParam2, iVar0, iParam3))
{
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0 = 3;
}
}
else if (STATS::LEADERBOARDS2_READ_BY_SCORE_FLOAT(uParam2, fVar1, iParam3))
{
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0 = 3;
}
}
else if (STATS::LEADERBOARDS2_READ_BY_RADIUS(uParam2, iParam3, uParam4))
{
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0 = 3;
}
}
break;
case 1:
if (!STATS::LEADERBOARDS_READ_PENDING(*uParam2, uParam2->f_1, -1))
{
*uParam0++;
}
break;
case 2:
if (STATS::LEADERBOARDS_READ_SUCCESSFUL(*uParam2, uParam2->f_1, 0))
{
*uParam1 = 1;
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0++;
}
break;
case 3:
return 1;
break;
}
return 0;
}
int func_159()
{
if (Global_2097532 && Global_2097533)
{
return 1;
}
return 0;
}
int func_160(var uParam0)
{
struct<20> Var0;
struct<6> Var98;
int iVar106;
int iVar107;
int iVar108;
int iVar109;
int iVar110;
int iVar111;
bool bVar112;
bool bVar113;
struct<13> Var114;
Var0.f_19.f_1 = 4;
iVar108 = -1;
bVar113 = true;
Var114 = { func_60(PLAYER::PLAYER_ID()) };
switch ((*uParam0)[1])
{
case 0:
iVar107 = NETWORK::NETWORK_GET_FRIEND_COUNT();
Global_2097536.f_2775[1] = -1;
Global_2097157.f_374 = -1;
Global_2097536.f_2704[bVar113] = 0;
if (iVar107 > 0)
{
if (func_159())
{
bVar112 = false;
}
else
{
bVar112 = true;
}
if (func_161(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44), &(uParam0->f_113), uParam0->f_113[0 /*66*/], bVar112, 0, 100))
{
func_157(&Var98, &(uParam0->f_44));
if (uParam0->f_5 && STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_START(&Var98))
{
if (func_159())
{
iVar110 = 0;
iVar110 = 0;
while (iVar110 < Var98.f_3)
{
if (iVar108 < 0)
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(iVar110, &Var0);
if (func_169(uParam0->f_44))
{
if (Global_2097157.f_374 < 0)
{
if (func_119(&Var0, &(Global_2097157.f_361)))
{
Global_2097157.f_374 = Var0.f_96;
}
}
}
if (BitTest(Global_2097157.f_142.f_2, 0))
{
if (Global_2097157.f_211.f_36[0] >= STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar110, false))
{
iVar108 = iVar110;
}
}
else if (Global_2097157.f_211.f_3[0] >= STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar110, false))
{
iVar108 = iVar110;
}
func_156(&Var0);
}
iVar110++;
}
if (iVar108 < 0)
{
iVar108 = Var98.f_3;
}
}
iVar110 = 0;
if (func_159() && iVar108 == 0)
{
if (Global_2097536.f_2704[bVar113] < 11)
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), 1);
Global_2097536.f_2775[bVar113] = 0;
Global_2097536.f_2704[bVar113]++;
}
}
if (Var98.f_3 > 0)
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(0, &Var0);
if (func_159() && (func_119(&Var0, &Var114) || func_119(&Var0, &(Global_2097157.f_361))))
{
}
else if (func_120(Var0) && Global_2097536.f_2704[bVar113] < 11)
{
if (func_119(&Var0, &Var114))
{
iVar108 = 0;
Global_2097536.f_2775[1] = 0;
}
MemCopy(&(Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), {Var0.f_13}, 16);
Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_32 = { Var0 };
Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_59 = 1;
if (func_154(uParam0->f_44))
{
iVar111 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2709);
if (iVar111 == 1)
{
Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_58 = 1;
}
else
{
Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_16), {Var0.f_19.f_1[1 /*16*/].f_8}, 16);
}
Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_74 = 1;
iVar106 = 0;
while (iVar106 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar106]))
{
Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_67[iVar106] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2710[iVar106]);
}
else
{
Global_2097536[1 /*901*/][Global_2097536.f_2704[bVar113] /*75*/].f_60[iVar106] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(0, Global_2097536.f_2710[iVar106]);
}
iVar106++;
}
Global_2097536.f_2704[1]++;
}
else
{
func_156(&Var0);
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
Global_2097536.f_2704[1] = 0;
(*uParam0)[1] = 1;
if (Global_2097536.f_2775[bVar113] == -1 && func_159())
{
if (Global_2097536.f_2704[bVar113] >= 1)
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), Global_2097536[bVar113 /*901*/][(Global_2097536.f_2704[bVar113] - 1) /*75*/].f_59 + 1);
}
else
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), 1);
}
Global_2097536.f_2775[bVar113] = Global_2097536.f_2704[bVar113];
Global_2097536.f_2704[bVar113]++;
}
return 0;
}
func_156(&Var0);
}
else
{
Global_2097536.f_2704[1] = 0;
func_156(&Var0);
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
if (Global_2097536.f_2775[bVar113] == -1 && func_159())
{
if (Global_2097536.f_2704[bVar113] >= 1)
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), Global_2097536[bVar113 /*901*/][(Global_2097536.f_2704[bVar113] - 1) /*75*/].f_59 + 1);
}
else
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), 1);
}
Global_2097536.f_2775[bVar113] = Global_2097536.f_2704[bVar113];
Global_2097536.f_2704[bVar113]++;
}
(*uParam0)[1] = 1;
return 0;
}
if (!func_159())
{
iVar108 = Var98.f_5;
}
if (iVar108 > 6)
{
iVar109 = (iVar108 - 6);
}
else
{
iVar109 = 1;
}
iVar110 = iVar109;
iVar110 = iVar109;
while (iVar110 <= (Var98.f_3 - 1))
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(iVar110, &Var0);
if (Global_2097536.f_2704[bVar113] < 11 && Var0.f_96 > 1)
{
if (func_159() && iVar108 == iVar110)
{
if (!func_119(&(Global_2097536[bVar113 /*901*/][0 /*75*/].f_32), &Var114))
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), Var0.f_96);
Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_59 = iVar110 + 1;
Global_2097536.f_2775[bVar113] = Global_2097536.f_2704[bVar113];
Global_2097536.f_2704[bVar113]++;
}
}
if (func_159() && (func_119(&Var0, &Var114) || func_119(&Var0, &(Global_2097157.f_361))))
{
}
else if (Global_2097536.f_2704[1] < 12)
{
if (func_120(Var0) && !func_119(&Var0, &(Global_2097536[bVar113 /*901*/][0 /*75*/].f_32)))
{
if (func_119(&Var0, &Var114))
{
if (Global_2097536.f_2775[1] < 0)
{
Global_2097536.f_2775[1] = Global_2097536.f_2704[1];
}
}
MemCopy(&(Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/]), {Var0.f_13}, 16);
Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_32 = { Var0 };
Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_59 = iVar110 + 1;
Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_74 = 1;
if (func_154(uParam0->f_44))
{
iVar111 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar110, Global_2097536.f_2709);
if (iVar111 == 1)
{
Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_58 = 1;
}
else
{
Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_16), {Var0.f_19.f_1[1 /*16*/].f_8}, 16);
}
iVar106 = 0;
while (iVar106 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar106]))
{
Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_67[iVar106] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar110, Global_2097536.f_2710[iVar106]);
}
else
{
Global_2097536[1 /*901*/][Global_2097536.f_2704[1] /*75*/].f_60[iVar106] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar110, Global_2097536.f_2710[iVar106]);
}
iVar106++;
}
Global_2097536.f_2704[1]++;
}
}
}
func_156(&Var0);
iVar110++;
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
(*uParam0)[1] = 1;
if (Global_2097536.f_2775[bVar113] == -1 && func_159())
{
if (Global_2097536.f_2704[bVar113] >= 1)
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), Global_2097536[bVar113 /*901*/][(Global_2097536.f_2704[bVar113] - 1) /*75*/].f_59 + 1);
}
else
{
func_155(uParam0, &(Global_2097536[bVar113 /*901*/][Global_2097536.f_2704[bVar113] /*75*/]), 1);
}
Global_2097536.f_2775[bVar113] = Global_2097536.f_2704[bVar113];
Global_2097536.f_2704[bVar113]++;
}
return 0;
}
else
{
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
Global_2097536.f_2704[1] = 0;
(*uParam0)[1] = 1;
MISC::SET_BIT(&(Global_2097536.f_2832), true);
return 0;
}
}
}
else
{
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
Global_2097536.f_2704[1] = 0;
(*uParam0)[1] = 1;
return 0;
}
break;
case 1:
func_147(bVar113, Global_2097157.f_374);
(*uParam0)[1] = 2;
break;
case 2:
return 1;
break;
}
return 0;
}
int func_161(var uParam0, var uParam1, var* uParam2, var* uParam3, int iParam4, bool bParam5, int iParam6, int iParam7)
{
switch (*uParam0)
{
case 0:
if (!func_151() && !func_150())
{
func_149(*uParam2);
if (STATS::LEADERBOARDS2_READ_FRIENDS_BY_ROW(uParam2, uParam3, iParam4, bParam5, iParam6, iParam7))
{
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0 = 3;
}
}
break;
case 1:
if (!STATS::LEADERBOARDS_READ_PENDING(*uParam2, uParam2->f_1, -1))
{
*uParam0++;
}
break;
case 2:
if (STATS::LEADERBOARDS_READ_SUCCESSFUL(*uParam2, uParam2->f_1, 0))
{
*uParam1 = 1;
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0++;
}
break;
case 3:
return 1;
break;
}
return 0;
}
int func_162(var uParam0)
{
struct<13> Var0;
struct<97> Var13;
struct<6> Var111;
int iVar119;
int iVar120;
int iVar121;
int iVar122;
int iVar123;
int iVar124;
bool bVar125;
bool bVar126;
bool bVar127;
int iVar128;
Var13.f_19.f_1 = 4;
iVar122 = -1;
bVar126 = false;
Var0 = { func_60(PLAYER::PLAYER_ID()) };
switch ((*uParam0)[bVar126])
{
case 0:
Global_2097536.f_2775[bVar126] = -1;
Global_2097536.f_2704[bVar126] = 0;
Global_2097157.f_374 = -1;
Global_2097533 = 0;
if (func_163(uParam0->f_44))
{
if (!Global_2097533)
{
Global_2097533 = 1;
}
}
else if (Global_2097533)
{
Global_2097533 = 0;
}
if (!Global_2097533)
{
}
if (func_158(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44), 11, &Var0, func_159(), 0, 0, 0))
{
func_157(&Var111, &(uParam0->f_44));
if (uParam0->f_5 && STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_START(&Var111))
{
if (Var111.f_3 > 0)
{
iVar124 = 0;
iVar119 = 0;
if (func_159())
{
iVar124 = 0;
while (iVar124 < Var111.f_3)
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(iVar124, &Var13);
if (Global_2097157.f_374 < 0)
{
if (func_119(&Var13, &Var0) || func_119(&Var13, &(Global_2097157.f_361)))
{
Global_2097157.f_374 = Var13.f_96;
}
}
if (iVar122 < 0)
{
if (BitTest(Global_2097157.f_142.f_2, 0))
{
if (Global_2097157.f_211.f_36[0] >= STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar124, false))
{
iVar122 = iVar124;
}
}
else if (Global_2097157.f_211.f_3[0] >= STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar124, false))
{
iVar122 = iVar124;
}
}
func_156(&Var13);
iVar124++;
}
if (iVar122 < 0)
{
iVar122 = Var111.f_3;
}
}
iVar124 = 0;
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(0, &Var13);
if (Var13.f_96 <= 1)
{
if (Global_2097536.f_2704[bVar126] < 11)
{
if (func_159() && iVar122 == 0)
{
func_155(uParam0, &(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), Var13.f_96);
Global_2097536.f_2775[bVar126] = 0;
Global_2097536.f_2704[bVar126]++;
}
if (func_159() && (func_119(&Var13, &Var0) || func_119(&Var13, &(Global_2097157.f_361))))
{
}
else
{
if (func_119(&Var13, &Var0))
{
iVar122 = 0;
Global_2097536.f_2775[bVar126] = 0;
}
MemCopy(&(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), {Var13.f_13}, 16);
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_32 = { Var13 };
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_59 = Var13.f_96;
if (func_154(uParam0->f_44))
{
iVar121 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2709);
if (iVar121 == 1)
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_58 = 1;
}
else
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_16), {Var13.f_19.f_1[1 /*16*/].f_8}, 16);
}
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_74 = 1;
iVar119 = 0;
while (iVar119 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar119]))
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_67[iVar119] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2710[iVar119]);
}
else
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_60[iVar119] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(0, Global_2097536.f_2710[iVar119]);
}
iVar119++;
}
Global_2097536.f_2704[bVar126]++;
}
bVar125 = true;
}
}
if (!bVar125)
{
Global_2097536.f_2704[bVar126]++;
}
if (!func_159())
{
iVar122 = Var111.f_5;
}
if (iVar122 > 6)
{
iVar123 = (iVar122 - 6);
}
else if (bVar125)
{
iVar123 = 1;
}
else
{
iVar123 = 0;
}
iVar124 = iVar123;
func_156(&Var13);
iVar124 = iVar123;
while (iVar124 <= (Var111.f_3 - 1))
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(iVar124, &Var13);
if (Global_2097536.f_2704[bVar126] < 11 && Var13.f_96 > 1)
{
if (func_159() && iVar122 == iVar124)
{
if (!func_119(&(Global_2097536[bVar126 /*901*/][0 /*75*/].f_32), &Var13))
{
func_155(uParam0, &(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), Var13.f_96);
Global_2097536.f_2775[bVar126] = Global_2097536.f_2704[bVar126];
Global_2097536.f_2704[bVar126]++;
}
}
if (func_159() && (func_119(&Var13, &Var0) || func_119(&Var13, &(Global_2097157.f_361))))
{
}
else if (Global_2097536.f_2704[bVar126] < 11)
{
if (func_120(Var13) && !func_119(&(Global_2097536[bVar126 /*901*/][0 /*75*/].f_32), &Var13))
{
if (func_119(&Var13, &Var0))
{
if (Global_2097536.f_2775[bVar126] < 0)
{
Global_2097536.f_2775[bVar126] = Global_2097536.f_2704[bVar126];
}
}
MemCopy(&(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), {Var13.f_13}, 16);
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_32 = { Var13 };
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_59 = Var13.f_96;
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_74 = 1;
if (func_154(uParam0->f_44))
{
iVar121 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar124, Global_2097536.f_2709);
if (iVar121 == 1)
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_58 = 1;
}
else
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_16), {Var13.f_19.f_1[1 /*16*/].f_8}, 16);
}
iVar119 = 0;
iVar119 = 0;
while (iVar119 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar119]))
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_67[iVar119] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar124, Global_2097536.f_2710[iVar119]);
}
else
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_60[iVar119] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar124, Global_2097536.f_2710[iVar119]);
}
iVar119++;
}
Global_2097536.f_2704[bVar126]++;
}
}
}
func_156(&Var13);
iVar124++;
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
if (bVar125)
{
if (Global_2097536.f_2775[bVar126] == -1 && func_159())
{
if (Global_2097536.f_2704[bVar126] >= 1)
{
func_155(uParam0, &(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), Global_2097536[bVar126 /*901*/][(Global_2097536.f_2704[bVar126] - 1) /*75*/].f_59 + 1);
}
else
{
func_155(uParam0, &(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), 1);
}
Global_2097536.f_2775[bVar126] = Global_2097536.f_2704[bVar126];
Global_2097536.f_2704[bVar126]++;
}
(*uParam0)[bVar126] = 2;
}
else
{
(*uParam0)[bVar126] = 1;
}
}
else
{
if (!bVar125)
{
Global_2097536.f_2704[bVar126]++;
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
Global_2097536.f_2775[bVar126] = -1;
(*uParam0)[bVar126] = 1;
}
}
else
{
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
Global_2097536.f_2775[bVar126] = -1;
(*uParam0)[bVar126] = 1;
MISC::SET_BIT(&(Global_2097536.f_2832), bVar126);
}
}
break;
case 1:
if (Global_2097536.f_2775[bVar126] == -1)
{
iVar128 = 11;
}
else
{
iVar128 = 1;
}
if (func_148(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44), 1, iVar128))
{
func_157(&Var111, &(uParam0->f_44));
if (uParam0->f_5 && STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_START(&Var111))
{
if (Var111.f_3 > 0)
{
iVar119 = 0;
while (iVar119 < Var111.f_3)
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(iVar119, &Var13);
if (func_159() && (func_119(&Var13, &Var0) || func_119(&Var13, &(Global_2097157.f_361))))
{
}
else
{
bVar127 = false;
if (Global_2097536[bVar126 /*901*/][0 /*75*/].f_59 > 1 || Global_2097536[bVar126 /*901*/][0 /*75*/].f_59 <= 0)
{
bVar127 = true;
}
if (Global_2097536.f_2704[bVar126] < 11 || bVar127)
{
if (iVar119 == 0 || bVar127)
{
MemCopy(&(Global_2097536[bVar126 /*901*/][0 /*75*/]), {Var13.f_13}, 16);
Global_2097536[bVar126 /*901*/][0 /*75*/].f_32 = { Var13 };
Global_2097536[bVar126 /*901*/][0 /*75*/].f_59 = Var13.f_96;
if (func_154(uParam0->f_44))
{
iVar121 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, Global_2097536.f_2709);
if (iVar121 == 1)
{
Global_2097536[bVar126 /*901*/][0 /*75*/].f_58 = 1;
}
else
{
Global_2097536[bVar126 /*901*/][0 /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[bVar126 /*901*/][0 /*75*/].f_16), {Var13.f_19.f_1[1 /*16*/].f_8}, 16);
}
Global_2097536[bVar126 /*901*/][0 /*75*/].f_74 = 1;
iVar120 = 0;
iVar120 = 0;
while (iVar120 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar120]))
{
Global_2097536[bVar126 /*901*/][iVar119 /*75*/].f_67[iVar120] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar119, Global_2097536.f_2710[iVar120]);
}
else
{
Global_2097536[bVar126 /*901*/][iVar119 /*75*/].f_60[iVar120] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar119, Global_2097536.f_2710[iVar120]);
}
iVar120++;
}
if (Global_2097536.f_2704[bVar126] == 0)
{
if (bVar127)
{
}
else
{
Global_2097536.f_2704[bVar126]++;
}
}
else if (Global_2097536.f_2704[bVar126] == 1 && Global_2097536.f_2775[bVar126] == -1)
{
Global_2097536.f_2704[bVar126]++;
}
}
else if (Global_2097536.f_2704[bVar126] < 11)
{
MemCopy(&(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), {Var13.f_13}, 16);
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_32 = { Var13 };
if (func_154(uParam0->f_44))
{
iVar121 = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar119, Global_2097536.f_2709);
if (iVar121 == 1)
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_58 = 1;
}
else
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_58 = 0;
}
}
if (func_169(uParam0->f_44))
{
MemCopy(&(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_16), {Var13.f_19.f_1[1 /*16*/].f_8}, 16);
}
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_59 = Var13.f_96;
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_74 = 1;
iVar120 = 0;
iVar120 = 0;
while (iVar120 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[iVar120]))
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_67[iVar120] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(iVar119, Global_2097536.f_2710[iVar120]);
}
else
{
Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/].f_60[iVar120] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(iVar119, Global_2097536.f_2710[iVar120]);
}
iVar120++;
}
if (iVar119 != 0)
{
Global_2097536.f_2704[bVar126]++;
}
}
}
}
func_156(&Var13);
iVar119++;
}
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
(*uParam0)[bVar126] = 2;
}
else
{
MISC::SET_BIT(&(Global_2097536.f_2832), bVar126);
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
Global_2097536.f_2704[bVar126] = 0;
(*uParam0)[bVar126] = 2;
Global_2097536.f_2704[1] = 0;
(*uParam0)[1] = 1;
Global_2097536.f_2704[2] = 0;
(*uParam0)[2] = 3;
}
}
if (Global_2097536.f_2775[bVar126] == -1 && func_159())
{
if (Global_2097536.f_2704[bVar126] >= 1)
{
func_155(uParam0, &(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), Global_2097536[bVar126 /*901*/][(Global_2097536.f_2704[bVar126] - 1) /*75*/].f_59 + 1);
}
else
{
func_155(uParam0, &(Global_2097536[bVar126 /*901*/][Global_2097536.f_2704[bVar126] /*75*/]), 1);
}
Global_2097536.f_2775[bVar126] = Global_2097536.f_2704[bVar126];
Global_2097536.f_2704[bVar126]++;
}
break;
case 2:
func_147(bVar126, Global_2097157.f_374);
(*uParam0)[bVar126] = 3;
break;
case 3:
return 1;
break;
}
return 0;
}
int func_163(struct<4> Param0, var uParam4, var uParam5, var uParam6, var uParam7, var uParam8, var uParam9, var uParam10, var uParam11, var uParam12, var uParam13, var uParam14, var uParam15, var uParam16, var uParam17, var uParam18, var uParam19, var uParam20, var uParam21, var uParam22, var uParam23, var uParam24, var uParam25, var uParam26, var uParam27, var uParam28, var uParam29, var uParam30, var uParam31, var uParam32, var uParam33, var uParam34, var uParam35, var uParam36, var uParam37, var uParam38, var uParam39, var uParam40, var uParam41, var uParam42, var uParam43, var uParam44, var uParam45, var uParam46, var uParam47, var uParam48, var uParam49, var uParam50, var uParam51, var uParam52, var uParam53, var uParam54, var uParam55, var uParam56, var uParam57, var uParam58, var uParam59, var uParam60, var uParam61, var uParam62, var uParam63, var uParam64, var uParam65, var uParam66, var uParam67, var uParam68)
{
int iVar0;
if (Global_2097532)
{
if (Global_2097157.f_5 != 0)
{
if (Global_2097157.f_5 == Param0.f_0)
{
if (Global_2097157.f_5.f_2 == Param0.f_3)
{
iVar0 = 0;
while (iVar0 < Param0.f_3)
{
if (!MISC::ARE_STRINGS_EQUAL(&(Global_2097157.f_5.f_2.f_1[iVar0 /*16*/]), &(Param0.f_3.f_1[iVar0 /*16*/])) || !MISC::ARE_STRINGS_EQUAL(&(Global_2097157.f_5.f_2.f_1[iVar0 /*16*/].f_8), &(Param0.f_3.f_1[iVar0 /*16*/].f_8)))
{
return 0;
}
iVar0++;
}
return 1;
}
}
}
}
return 0;
}
void func_164(var uParam0)
{
int iVar0;
if (STATS::LEADERBOARDS_GET_CACHE_EXISTS(Global_2097536.f_2826))
{
iVar0 = STATS::LEADERBOARDS_GET_CACHE_TIME(Global_2097536.f_2826);
if (iVar0 < 300000)
{
MISC::SET_BIT(&(uParam0->f_42), 5);
}
else
{
MISC::CLEAR_BIT(&(uParam0->f_42), 5);
func_131(Global_2097536.f_2826, -1);
}
}
}
void func_165(int iParam0)
{
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(iParam0))
{
GRAPHICS::DRAW_SCALEFORM_MOVIE_FULLSCREEN(iParam0, 255, 255, 255, 0, 0);
}
}
void func_166(int iParam0, int iParam1, int iParam2, bool bParam3, bool bParam4)
{
char* sVar0;
struct<2> Var1;
struct<16> Var36;
bool bVar52;
struct<13> Var53;
int iVar66;
struct<13> Var67;
int iVar80;
sVar0 = "";
if (BitTest(iParam2, 4))
{
sVar0 = "SCLB_GLOBAL";
}
else if (BitTest(iParam2, 5))
{
*iParam1++;
sVar0 = "SCLB_FRIENDS";
}
else if (BitTest(iParam2, 6))
{
*iParam1++;
if (NETWORK::NETWORK_IS_SIGNED_ONLINE() && NETWORK::NETWORK_CLAN_SERVICE_IS_VALID())
{
if (func_92() && !NETWORK::NETWORK_HAVE_USER_CONTENT_PRIVILEGES(0))
{
sVar0 = "SCLB_CREW";
}
else
{
Var53 = { func_60(PLAYER::PLAYER_ID()) };
if (NETWORK::NETWORK_CLAN_PLAYER_IS_ACTIVE(&Var53))
{
NETWORK::NETWORK_CLAN_PLAYER_GET_DESC(&Var1, 35, &Var53);
if (!MISC::IS_STRING_NULL_OR_EMPTY(&(Var1.f_1)))
{
sVar0 = "STRING";
Var36 = { Var1.f_1 };
bVar52 = true;
}
else
{
sVar0 = "SCLB_CREW";
}
}
else
{
sVar0 = "SCLB_CREW";
}
}
}
else
{
sVar0 = "SCLB_CREW";
}
}
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(*iParam1);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iParam2);
if (bVar52)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sVar0);
HUD::ADD_TEXT_COMPONENT_SUBSTRING_KEYBOARD_DISPLAY(&Var36);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sVar0);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
}
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
*iParam1++;
if (bParam4)
{
iVar66 = 0;
MISC::SET_BIT(&iVar66, 7);
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(*iParam1);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iVar66);
if (!NETWORK::NETWORK_IS_SIGNED_ONLINE())
{
sVar0 = "SCLB_NOT_ONL";
}
else if (!NETWORK::NETWORK_HAS_VALID_ROS_CREDENTIALS())
{
sVar0 = "SCLB_NO_ROS";
}
else if (Global_2097536.f_2832 != 0)
{
sVar0 = "SCLB_READ_FAIL";
}
else
{
sVar0 = "HUD_PERM";
}
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sVar0);
GRAPHICS::_END_TEXT_COMMAND_SCALEFORM_STRING_2();
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
*iParam1++;
}
else if (bParam3)
{
if (BitTest(iParam2, 4))
{
sVar0 = "SCLB_NO_GLOBAL";
}
else if (BitTest(iParam2, 5))
{
if (NETWORK::NETWORK_GET_FRIEND_COUNT() > 0)
{
sVar0 = "SCLB_NO_FRNDS";
}
else
{
sVar0 = "SCLB_NO_FRNDSb";
}
}
else if (BitTest(iParam2, 6))
{
if (NETWORK::NETWORK_HAS_SOCIAL_CLUB_ACCOUNT())
{
if (NETWORK::NETWORK_ARE_SOCIAL_CLUB_POLICIES_CURRENT())
{
if (NETWORK::NETWORK_IS_SIGNED_ONLINE() && NETWORK::NETWORK_CLAN_SERVICE_IS_VALID())
{
if (func_92() && !NETWORK::NETWORK_HAVE_USER_CONTENT_PRIVILEGES(0))
{
sVar0 = "SCLB_NO_CREWc";
}
else
{
Var67 = { func_60(PLAYER::PLAYER_ID()) };
if (NETWORK::NETWORK_CLAN_PLAYER_IS_ACTIVE(&Var67))
{
NETWORK::NETWORK_CLAN_PLAYER_GET_DESC(&Var1, 35, &Var67);
if (!MISC::IS_STRING_NULL_OR_EMPTY(&(Var1.f_1)))
{
sVar0 = "SCLB_NO_CREWb";
Var36 = { Var1.f_1 };
bVar52 = true;
}
else
{
sVar0 = "SCLB_NO_CREWc";
}
}
else
{
sVar0 = "SCLB_NO_CREWa";
}
}
}
else
{
sVar0 = "SCLB_NO_CREWa";
}
}
else
{
sVar0 = "SCLB_NO_CREWe";
}
}
else
{
sVar0 = "SCLB_NO_CREWd";
}
}
iVar80 = 0;
MISC::SET_BIT(&iVar80, 7);
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(*iParam1);
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iVar80);
if (bVar52)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sVar0);
HUD::ADD_TEXT_COMPONENT_SUBSTRING_KEYBOARD_DISPLAY(&Var36);
GRAPHICS::_END_TEXT_COMMAND_SCALEFORM_STRING_2();
}
else
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sVar0);
GRAPHICS::_END_TEXT_COMMAND_SCALEFORM_STRING_2();
}
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
*iParam1++;
}
}
void func_167(int iParam0, char* sParam1, var uParam2, int iParam3)
{
int iVar0;
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_TITLE");
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sParam1);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
iVar0 = 0;
while (iVar0 < iParam3)
{
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(uParam2[iVar0 /*6*/]);
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
iVar0++;
}
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
void func_168(int iParam0, char* sParam1, char* sParam2, char* sParam3, bool bParam4, int iParam5)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_MULTIPLAYER_TITLE");
GRAPHICS::BEGIN_TEXT_COMMAND_SCALEFORM_STRING(sParam1);
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam2))
{
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(sParam2);
}
if (iParam5 == -1)
{
if (bParam4)
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
HUD::ADD_TEXT_COMPONENT_SUBSTRING_KEYBOARD_DISPLAY(sParam3);
}
}
else if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(sParam3);
}
}
else
{
if (bParam4)
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
HUD::ADD_TEXT_COMPONENT_SUBSTRING_KEYBOARD_DISPLAY(sParam3);
}
}
else if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(sParam3);
}
HUD::ADD_TEXT_COMPONENT_INTEGER(iParam5);
}
GRAPHICS::END_TEXT_COMMAND_SCALEFORM_STRING();
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
int func_169(int iParam0)
{
if (iParam0 == 825 || iParam0 == 828)
{
return 1;
}
return 0;
}
void func_170(int iParam0, int iParam1)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(iParam0, "SET_DISPLAY_TYPE");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(iParam1);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
int func_171()
{
return GRAPHICS::REQUEST_SCALEFORM_MOVIE("SC_LEADERBOARD");
}
bool func_172()
{
return func_173(PLAYER::PLAYER_ID());
}
int func_173(int iParam0)
{
switch (func_174(iParam0))
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 6:
case 5:
case 7:
case 42:
case 37:
case 40:
case 43:
return 0;
default:
}
return 1;
}
int func_174(int iParam0)
{
return Global_1853131[iParam0 /*888*/].f_192;
}
void func_175(int iParam0)
{
Global_1577892 = iParam0;
}
void func_176(int iParam0)
{
Global_1645748.f_1121 = iParam0;
}
void func_177(bool bParam0)
{
if (bParam0)
{
func_179();
}
func_178(4, -1);
func_178(6, -1);
func_178(7, -1);
func_178(3, -1);
func_178(1, -1);
func_178(2, -1);
func_178(11, -1);
func_178(13, -1);
func_178(14, -1);
func_178(16, -1);
}
void func_178(bool bParam0, int iParam1)
{
MISC::SET_BIT(&(Global_1644218.f_1047), bParam0);
switch (bParam0)
{
case 5:
if (iParam1 > -1)
{
Global_1644218.f_170[iParam1] = 1;
}
break;
}
}
void func_179()
{
Global_2810701.f_4599 = 0;
}
void func_180(var uParam0, bool bParam1, bool bParam2)
{
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS() && !bParam1)
{
if (!bParam2)
{
*uParam0 = NETWORK::GET_NETWORK_TIME();
}
else
{
*uParam0 = NETWORK::GET_NETWORK_TIME_ACCURATE();
}
}
else
{
*uParam0 = MISC::GET_GAME_TIMER();
}
uParam0->f_1 = 1;
}
int func_181(var uParam0, bool bParam1, int iParam2)
{
uParam0->f_12 = iParam2;
func_184(uParam0);
func_183(uParam0);
if (MISC::ARE_STRINGS_EQUAL(&(uParam0->f_550), "SPR_RESULT") || (MISC::ARE_STRINGS_EQUAL(&(uParam0->f_550), "") && uParam0->f_56 > 0))
{
uParam0->f_570 = 1;
}
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
GRAPHICS::REQUEST_STREAMED_TEXTURE_DICT("MPHud", false);
}
if (uParam0->f_1 == 0)
{
GRAPHICS::REQUEST_STREAMED_TEXTURE_DICT("CommonMenu", false);
GRAPHICS::REQUEST_STREAMED_TEXTURE_DICT("MPLeaderboard", false);
GRAPHICS::REQUEST_STREAMED_TEXTURE_DICT("MPHud", false);
uParam0->f_1 = GRAPHICS::REQUEST_SCALEFORM_MOVIE("MP_BIG_MESSAGE_FREEMODE");
uParam0->f_2 = 0;
uParam0->f_3 = 0;
}
uParam0->f_4 = GRAPHICS::REQUEST_SCALEFORM_MOVIE_INSTANCE("INSTRUCTIONAL_BUTTONS");
if (bParam1)
{
while (((!GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(uParam0->f_1) || !GRAPHICS::HAS_STREAMED_TEXTURE_DICT_LOADED("CommonMenu")) || !GRAPHICS::HAS_STREAMED_TEXTURE_DICT_LOADED("MPLeaderboard")) || !GRAPHICS::HAS_STREAMED_TEXTURE_DICT_LOADED("MPHud"))
{
SYSTEM::WAIT(0);
}
if (uParam0->f_566 || uParam0->f_571)
{
while (!GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(uParam0->f_4))
{
SYSTEM::WAIT(0);
}
}
}
else
{
if (((!GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(uParam0->f_1) || !GRAPHICS::HAS_STREAMED_TEXTURE_DICT_LOADED("CommonMenu")) || !GRAPHICS::HAS_STREAMED_TEXTURE_DICT_LOADED("MPLeaderboard")) || !GRAPHICS::HAS_STREAMED_TEXTURE_DICT_LOADED("MPHud"))
{
return 0;
}
if (uParam0->f_566)
{
if (!GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(uParam0->f_4))
{
return 0;
}
}
}
if (uParam0->f_566)
{
if (uParam0->f_571)
{
func_182(uParam0);
}
else if (uParam0->f_56 != 0)
{
func_48(uParam0, 1);
}
else
{
func_48(uParam0, 0);
}
}
Global_78119 = 1;
return 1;
}
void func_182(var uParam0)
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "CLEAR_ALL");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
if (MISC::IS_PC_VERSION())
{
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "TOGGLE_MOUSE_BUTTONS");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(true);
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "SET_DATA_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(2);
func_9(PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, 188, true));
func_14("ES_HELP_TU");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "SET_DATA_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(1);
func_9(PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, 187, true));
func_14("ES_HELP_TD");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "SET_DATA_SLOT");
GRAPHICS::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(0);
func_9(PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, 202, true));
func_14("ES_HELP_AB");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
GRAPHICS::BEGIN_SCALEFORM_MOVIE_METHOD(uParam0->f_4, "DRAW_INSTRUCTIONAL_BUTTONS");
GRAPHICS::END_SCALEFORM_MOVIE_METHOD();
}
void func_183(var uParam0)
{
float fVar0;
int iVar1;
int iVar2;
int iVar3;
fVar0 = 0f;
HUD::SET_TEXT_JUSTIFICATION(0);
HUD::SET_TEXT_SCALE(1f, func_64(16f));
if (uParam0->f_31 == 0)
{
if (uParam0->f_29)
{
HUD::_BEGIN_TEXT_COMMAND_GET_WIDTH("STRING");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(&(uParam0->f_13));
fVar0 = HUD::_END_TEXT_COMMAND_GET_WIDTH(true);
}
else
{
HUD::_BEGIN_TEXT_COMMAND_GET_WIDTH(&(uParam0->f_13));
fVar0 = HUD::_END_TEXT_COMMAND_GET_WIDTH(true);
}
}
else
{
HUD::_BEGIN_TEXT_COMMAND_GET_WIDTH("STRING");
iVar1 = 0;
iVar2 = 0;
iVar3 = 0;
iVar3 = 0;
while (iVar3 < uParam0->f_31)
{
switch (uParam0->f_32[iVar3])
{
case 0:
HUD::ADD_TEXT_COMPONENT_INTEGER(uParam0->f_53[iVar1]);
iVar1++;
break;
case 1:
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(&(uParam0->f_36[iVar2 /*16*/]));
iVar2++;
break;
case 2:
HUD::ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(&(uParam0->f_36[iVar2 /*16*/]));
iVar2++;
break;
}
iVar3++;
}
fVar0 = HUD::_END_TEXT_COMMAND_GET_WIDTH(true);
}
if (fVar0 > ((0.1125f * 2f) - (0.006f * 2f)))
{
*uParam0 = ((fVar0 / 2f) + (0.006f * 2f));
}
}
void func_184(var uParam0)
{
uParam0->f_547 = 1f;
uParam0->f_546 = 0;
uParam0->f_572 = 0f;
uParam0->f_562 = 0;
uParam0->f_30 = 0f;
uParam0->f_548 = 0f;
uParam0->f_563 = 0f;
uParam0->f_564 = 0f;
uParam0->f_545 = 0;
uParam0->f_567 = 0;
uParam0->f_576 = 0;
uParam0->f_568 = 0;
uParam0->f_569 = 0;
uParam0->f_570 = 0;
*uParam0 = 0.1125f;
uParam0->f_2 = 0;
uParam0->f_3 = 0;
uParam0->f_578 = 0;
uParam0->f_579 = 0;
uParam0->f_577 = 1f;
}
void func_185(int* iParam0, char* sParam1, int iParam2, int iParam3, int iParam4, var uParam5, float fParam6)
{
int iVar0;
int iVar1;
int iVar2;
int iVar3;
if (func_263(iParam0, 4))
{
return;
}
else
{
func_188(&(iParam0->f_26));
func_187(&(iParam0->f_26), "BJ_SC_PASS", sParam1, 0);
func_221(iParam0, 4, 1);
}
*uParam5 = 0;
if (iParam3 > 1)
{
if (iParam2 == iParam3)
{
iVar0 = SYSTEM::CEIL((100f * fParam6));
}
}
iVar3 = SYSTEM::CEIL((IntToFloat(iParam2 * 30) * fParam6));
iVar1 = SYSTEM::CEIL((fParam6 * 50f));
iVar2 = SYSTEM::CEIL(((fParam6 * 1.5f) * SYSTEM::TO_FLOAT(iParam4)));
*uParam5 = (((iVar1 + iVar2) + iVar0) + iVar3);
if (iParam3 > 1)
{
if (iVar0 > 0)
{
func_186(&(iParam0->f_26), 3, "BJ_SC_ALLG_RWD", "", iVar0, 0, 2, 0);
}
else
{
func_186(&(iParam0->f_26), 3, "BJ_SC_ALLG_RWD", "", 0, 0, 1, 0);
}
func_186(&(iParam0->f_26), 2, "BJ_SC_GATES", "", iParam2, iParam3, 0, 0);
}
func_186(&(iParam0->f_26), 11, "BJ_SC_LAND_ACC", "", iParam4, 0, 0, 0);
if (iParam3 > 1)
{
func_186(&(iParam0->f_26), 3, "BJ_SC_GATE_RWD", "", iVar3, 0, 0, 0);
}
func_186(&(iParam0->f_26), 3, "BJ_SC_ACC_RWD", "", SYSTEM::ROUND(((50f + (1.5f * IntToFloat(iParam4))) * fParam6)), 0, 0, 0);
func_186(&(iParam0->f_26), 3, "BJ_SC_TOT_RWD", "", *uParam5, 0, 0, 0);
}
void func_186(var uParam0, int iParam1, char* sParam2, char* sParam3, int iParam4, int iParam5, int iParam6, int iParam7)
{
int iVar0;
if (uParam0->f_56 == 13)
{
return;
}
iVar0 = uParam0->f_56;
uParam0->f_57[iVar0] = iParam1;
StringCopy(&(uParam0->f_71[iVar0 /*16*/]), sParam2, 64);
StringCopy(&(uParam0->f_280[iVar0 /*16*/]), sParam3, 64);
uParam0->f_489[iVar0] = iParam4;
uParam0->f_503[iVar0] = iParam5;
uParam0->f_517[iVar0] = iParam6;
uParam0->f_531[iVar0] = iParam7;
uParam0->f_56++;
}
void func_187(var uParam0, char* sParam1, char* sParam2, int iParam3)
{
StringCopy(&(uParam0->f_5), sParam1, 16);
StringCopy(&(uParam0->f_13), sParam2, 64);
uParam0->f_29 = iParam3;
uParam0->f_11 = 0;
}
void func_188(var uParam0)
{
func_184(uParam0);
uParam0->f_574 = 0;
uParam0->f_31 = 0;
uParam0->f_56 = 0;
uParam0->f_571 = 0;
uParam0->f_573 = 0;
}
char* func_189(int iParam0)
{
switch (iParam0)
{
case 0:
return "BJ_JUMP_01";
case 1:
return "BJ_JUMP_02";
case 2:
return "BJ_JUMP_03";
case 3:
return "BJ_JUMP_04";
case 4:
return "BJ_JUMP_05";
case 5:
return "BJ_JUMP_06";
case 6:
return "BJ_JUMP_07";
case 7:
return "BJ_JUMP_08";
case 8:
return "BJ_JUMP_09";
case 9:
return "BJ_JUMP_10";
case 10:
return "BJ_JUMP_11";
case 11:
return "BJ_JUMP_12";
case 12:
return "BJ_JUMP_13";
default:
}
return "";
}
int func_190(bool bParam0, int iParam1, float fParam2, int iParam3)
{
if (Global_2097157.f_1 && !Global_2097157.f_2)
{
func_199(bParam0, iParam1, fParam2, iParam3);
Global_2097157.f_2 = 1;
}
if (func_191(&uLocal_144))
{
Global_2097532 = 1;
return 1;
}
return 0;
}
int func_191(var uParam0)
{
struct<98> Var0;
struct<4> Var98;
struct<37> Var106;
struct<13> Var175;
bool bVar188;
Var0.f_19.f_1 = 4;
Var106.f_3 = 32;
Var106.f_36 = 32;
if (func_169(uParam0->f_44))
{
Var175 = { Global_2097157.f_361 };
}
else
{
Var175 = { func_60(PLAYER::PLAYER_ID()) };
}
switch (Global_2097157)
{
case 0:
if (func_198(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44), &Var175))
{
func_157(&Var98, &(uParam0->f_44));
Global_2097157.f_142 = uParam0->f_44;
Global_2097157.f_142.f_1 = STATS::LEADERBOARDS_GET_NUMBER_OF_COLUMNS(uParam0->f_44, 0);
bVar188 = false;
while (bVar188 < Global_2097157.f_142.f_1)
{
if (!func_197(uParam0->f_44, bVar188))
{
if (func_196(uParam0->f_44, 4, bVar188))
{
MISC::SET_BIT(&(Global_2097157.f_142.f_2), bVar188);
}
else
{
MISC::CLEAR_BIT(&(Global_2097157.f_142.f_2), bVar188);
}
}
bVar188++;
}
if (uParam0->f_5 && STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_START(&Var98))
{
if (Var98.f_3 > 0)
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(0, &Var0);
if (Var0.f_97 != Global_2097157.f_142.f_1)
{
}
if (!func_120(Var0))
{
Global_2097157.f_4 = 1;
}
else
{
bVar188 = false;
while (bVar188 < Global_2097157.f_142.f_1)
{
if (!func_197(uParam0->f_44, bVar188))
{
if (func_196(uParam0->f_44, 4, bVar188))
{
Global_2097157.f_73.f_36[bVar188] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INT(0, bVar188);
if (Global_2097157.f_73.f_36[bVar188] == -1)
{
if (bVar188 > Var0.f_97)
{
Global_2097157.f_73.f_36[bVar188] = 0;
}
}
}
else
{
Global_2097157.f_73.f_3[bVar188] = STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_FLOAT(0, bVar188);
if (Global_2097157.f_73.f_3[bVar188] == -1f)
{
if (bVar188 > Var0.f_97)
{
Global_2097157.f_73.f_3[bVar188] = 0f;
}
}
}
}
bVar188++;
}
}
}
else
{
Global_2097157.f_4 = 1;
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
}
else
{
Global_2097157.f_4 = 1;
}
Global_2097157 = 1;
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
}
break;
case 1:
Global_2097157.f_1 = 1;
if (Global_2097157.f_2)
{
func_195();
if (Global_2097157.f_4)
{
if (func_194(uParam0->f_44))
{
Global_2097157 = 3;
}
else
{
Global_2097157 = 2;
}
}
else
{
Global_2097157 = 2;
}
}
break;
case 2:
STATS::LEADERBOARDS2_READ_RANK_PREDICTION(&(Global_2097157.f_73), &(Global_2097157.f_142), &(Global_2097157.f_211));
Global_2097157 = 4;
uParam0->f_4 = 0;
uParam0->f_5 = 0;
break;
case 3:
Global_2097157.f_211 = { Global_2097157.f_142 };
Global_2097157 = 4;
uParam0->f_4 = 0;
uParam0->f_5 = 0;
break;
case 4:
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS() && func_193())
{
if (func_192())
{
Global_2097157 = 99;
}
else
{
Global_2097157 = 999;
return 1;
}
}
else
{
Global_2097157 = 999;
return 1;
}
break;
case 99:
if (func_194(uParam0->f_44))
{
Global_2097157.f_280 = { Global_2097157.f_142 };
}
else
{
Var106.f_0 = Global_2097157.f_142;
Var106.f_1 = Global_2097157.f_142.f_1;
Var106.f_2 = Global_2097157.f_142.f_2;
STATS::LEADERBOARDS2_READ_RANK_PREDICTION(&Var106, &(Global_2097157.f_142), &(Global_2097157.f_280));
}
Global_2097157 = 100;
uParam0->f_4 = 0;
uParam0->f_5 = 0;
break;
case 100:
if (func_158(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44), 1, &Var175, 1, 1, Global_2097157.f_280.f_36[0], Global_2097157.f_280.f_3[0]))
{
func_157(&Var98, &(uParam0->f_44));
if (uParam0->f_5 && STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_START(&Var98))
{
if (Var98.f_3 > 0)
{
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_INFO(0, &Var0);
if (MISC::ARE_STRINGS_EQUAL(&(Var0.f_13), ""))
{
Global_1057163.f_1 = -1;
}
else
{
Global_1057163.f_1 = Var0.f_96;
}
}
else
{
Global_1057163.f_1 = -1;
}
STATS::LEADERBOARDS2_READ_BY_HELP_PURPLE_END();
}
else
{
Global_1057163.f_1 = -1;
}
Global_2097157 = 999;
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
}
break;
case 999:
return 1;
break;
}
return 0;
}
bool func_192()
{
return BitTest(Global_1048576.f_10, 1);
}
var func_193()
{
return Global_2723442.f_3;
}
int func_194(int iParam0)
{
switch (iParam0)
{
case 817:
case 850:
case 824:
case 827:
case 815:
case 826:
case 777:
case 825:
case 828:
case 849:
case 928:
case 795:
case 202:
case 811:
case 193:
case 975:
case 976:
case 970:
case 973:
case 968:
case 969:
case 966:
case 974:
case 971:
case 967:
case 965:
case 972:
return 1;
break;
}
if (iParam0 >= 998 && iParam0 <= 1197)
{
return 1;
}
return 0;
}
void func_195()
{
Global_2097157.f_73 = Global_2097157.f_142;
Global_2097157.f_73.f_1 = Global_2097157.f_142.f_1;
Global_2097157.f_73.f_2 = Global_2097157.f_142.f_2;
Global_2097157.f_211 = Global_2097157.f_142;
Global_2097157.f_211.f_1 = Global_2097157.f_142.f_1;
Global_2097157.f_211.f_2 = Global_2097157.f_142.f_2;
}
int func_196(int iParam0, int iParam1, bool bParam2)
{
int iVar0;
if (iParam0 == 190)
{
if (bParam2 == 0)
{
return 0;
}
}
if (iParam0 == 203)
{
if (bParam2 == 3 || bParam2 == 6)
{
return 0;
}
}
if (iParam0 == 912)
{
if (bParam2 == 0 || bParam2 == 3)
{
return 0;
}
}
if ((iParam0 == 762 || iParam0 == 822) || iParam0 == 823)
{
if (bParam2 == 0 || bParam2 == 3)
{
return 0;
}
}
if (iParam0 == 791)
{
if (bParam2 == 4)
{
return 0;
}
}
if (iParam0 == 780)
{
if (bParam2 == 3)
{
return 0;
}
}
if (iParam0 == 777)
{
if (bParam2 == 3 || bParam2 == 7)
{
return 0;
}
}
if (iParam0 == 1200)
{
if (bParam2 == 4)
{
return 0;
}
}
iVar0 = STATS::LEADERBOARDS_GET_COLUMN_TYPE(iParam0, iParam1, bParam2);
switch (iVar0)
{
case 1:
case 2:
return 1;
break;
}
return 0;
}
int func_197(int iParam0, bool bParam1)
{
if (STATS::LEADERBOARDS_GET_COLUMN_ID(iParam0, 4, bParam1) == 156)
{
return 1;
}
switch (iParam0)
{
case 912:
if (bParam1 == 5)
{
return 1;
}
break;
case 780:
if (bParam1 == 4)
{
return 1;
}
break;
case 1200:
if (bParam1 == 5)
{
return 1;
}
break;
}
return 0;
}
int func_198(var uParam0, var uParam1, var* uParam2, var* uParam3)
{
switch (*uParam0)
{
case 0:
if (!func_151() && !func_150())
{
func_149(*uParam2);
if (STATS::LEADERBOARDS2_READ_BY_HANDLE(uParam2, uParam3))
{
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0 = 3;
}
}
break;
case 1:
if (!STATS::LEADERBOARDS_READ_PENDING(*uParam2, uParam2->f_1, -1))
{
*uParam0++;
}
break;
case 2:
if (STATS::LEADERBOARDS_READ_SUCCESSFUL(*uParam2, uParam2->f_1, 0))
{
*uParam1 = 1;
*uParam0++;
}
else
{
*uParam1 = 0;
*uParam0++;
}
break;
case 3:
return 1;
break;
}
return 0;
}
void func_199(int iParam0, int iParam1, float fParam2, int iParam3)
{
struct<6> Var0[1];
struct<8> Var7[1];
StringCopy(&(Var7[0 /*8*/]), "Location", 32);
switch (iParam0)
{
case 0:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_01", 24);
break;
case 1:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_02", 24);
break;
case 2:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_03", 24);
break;
case 3:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_04", 24);
break;
case 4:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_05", 24);
break;
case 5:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_06", 24);
break;
case 6:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_07", 24);
break;
case 7:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_08", 24);
break;
case 8:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_09", 24);
break;
case 9:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_10", 24);
break;
case 10:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_11", 24);
break;
case 11:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_12", 24);
break;
case 12:
StringCopy(&(Var0[0 /*6*/]), "BJUMP_13", 24);
break;
}
if (func_201(274, &Var0, &Var7, 1, -1, 1, 0))
{
func_200(274, 131, iParam3, 0f, 0);
if (iParam1 == 100)
{
func_200(274, 98, 1, 0f, 0);
}
else
{
func_200(274, 98, 0, 0f, 0);
}
func_200(274, 109, 1, 0f, 0);
func_200(274, 8, iParam3, 0f, 0);
func_200(274, 93, 0, fParam2, 0);
}
}
void func_200(int iParam0, int iParam1, int iParam2, float fParam3, bool bParam4)
{
bool bVar0;
bool bVar1;
if (!bParam4)
{
STATS::LEADERBOARDS_WRITE_ADD_COLUMN(iParam1, iParam2, fParam3);
}
if (!Global_2097157.f_3)
{
Global_2097157.f_142 = iParam0;
Global_2097157.f_142.f_1 = STATS::LEADERBOARDS_GET_NUMBER_OF_COLUMNS(Global_2097157.f_142, 0);
bVar1 = false;
while (bVar1 < 32)
{
if (bVar1 < Global_2097157.f_142.f_1)
{
if (iParam1 == 156)
{
}
else if (func_196(iParam0, 4, bVar1))
{
MISC::SET_BIT(&(Global_2097157.f_142.f_2), bVar1);
}
else
{
MISC::CLEAR_BIT(&(Global_2097157.f_142.f_2), bVar1);
}
}
else
{
MISC::CLEAR_BIT(&(Global_2097157.f_142.f_2), bVar1);
}
bVar1++;
}
Global_2097157.f_3 = 1;
}
bVar1 = false;
while (bVar1 < 32)
{
if (iParam1 == STATS::LEADERBOARDS_GET_COLUMN_ID(iParam0, 4, bVar1))
{
bVar0 = bVar1;
bVar1 = 32;
}
bVar1++;
}
Global_2097157.f_142.f_36[bVar0] = iParam2;
Global_2097157.f_142.f_3[bVar0] = fParam3;
if (iParam2 != 0)
{
MISC::SET_BIT(&(Global_2097157.f_142.f_2), bVar0);
}
else if (fParam3 != 0f)
{
MISC::CLEAR_BIT(&(Global_2097157.f_142.f_2), bVar0);
}
}
int func_201(int iParam0, var uParam1, var uParam2, int iParam3, int iParam4, bool bParam5, bool bParam6)
{
struct<68> Var0;
int iVar68;
struct<13> Var69;
var uVar82;
if (!NETWORK::NETWORK_IS_SIGNED_ONLINE())
{
}
if ((!NETWORK::NETWORK_PLAYER_IS_CHEATER() && (NETWORK::NETWORK_HAVE_ONLINE_PRIVILEGES() || !NETWORK::_NETWORK_HAS_AGE_RESTRICTED_PROFILE())) && NETWORK::NETWORK_HAVE_ROS_LEADERBOARD_WRITE_PRIV())
{
Var0.f_2.f_1 = 4;
Var0.f_0 = iParam0;
if (iParam4 == -1)
{
if (NETWORK::NETWORK_CLAN_SERVICE_IS_VALID())
{
Var69 = { func_60(PLAYER::PLAYER_ID()) };
if (NETWORK::NETWORK_CLAN_PLAYER_IS_ACTIVE(&Var69))
{
if (NETWORK::NETWORK_CLAN_PLAYER_GET_DESC(&uVar82, 35, &Var69))
{
Var0.f_1 = uVar82;
}
}
}
}
else
{
Var0.f_1 = iParam4;
}
Var0.f_2 = iParam3;
iVar68 = 0;
while (iVar68 < iParam3)
{
Var0.f_2.f_1[iVar68 /*16*/] = { *(uParam2[iVar68 /*8*/]) };
MemCopy(&(Var0.f_2.f_1[iVar68 /*16*/].f_8), {*(uParam1[iVar68 /*6*/])}, 8);
iVar68++;
}
if (bParam5)
{
Global_2097157.f_5 = { Var0 };
}
if (!bParam6)
{
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS() && Global_2723442.f_3)
{
STATS::LEADERBOARDS2_WRITE_DATA_FOR_EVENT_TYPE(&Var0, &(Global_1932346.f_10));
}
else
{
STATS::LEADERBOARDS2_WRITE_DATA(&Var0);
}
}
return 1;
}
if (NETWORK::NETWORK_PLAYER_IS_CHEATER())
{
}
if (!NETWORK::NETWORK_HAVE_ONLINE_PRIVILEGES())
{
}
if (NETWORK::_NETWORK_HAS_AGE_RESTRICTED_PROFILE())
{
}
if (!NETWORK::NETWORK_HAVE_ROS_LEADERBOARD_WRITE_PRIV())
{
}
return 0;
}
void func_202(bool bParam0)
{
struct<3> Var0;
switch (bParam0)
{
case 0:
StringCopy(&Var0, "BJUMP_01", 24);
break;
case 1:
StringCopy(&Var0, "BJUMP_02", 24);
break;
case 2:
StringCopy(&Var0, "BJUMP_03", 24);
break;
case 3:
StringCopy(&Var0, "BJUMP_04", 24);
break;
case 4:
StringCopy(&Var0, "BJUMP_05", 24);
break;
case 5:
StringCopy(&Var0, "BJUMP_06", 24);
break;
case 6:
StringCopy(&Var0, "BJUMP_07", 24);
break;
case 7:
StringCopy(&Var0, "BJUMP_08", 24);
break;
case 8:
StringCopy(&Var0, "BJUMP_09", 24);
break;
case 9:
StringCopy(&Var0, "BJUMP_10", 24);
break;
case 10:
StringCopy(&Var0, "BJUMP_11", 24);
break;
case 11:
StringCopy(&Var0, "BJUMP_12", 24);
break;
case 12:
StringCopy(&Var0, "BJUMP_13", 24);
break;
}
func_203(&uLocal_144, 85, &Var0, func_189(bParam0), bParam0, -1, 0, 0);
}
void func_203(var uParam0, int iParam1, char* sParam2, char* sParam3, int iParam4, int iParam5, bool bParam6, bool bParam7)
{
struct<8> Var0;
struct<8> Var8;
bool bVar16;
struct<6> Var17;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam2))
{
StringCopy(&Var0, sParam2, 32);
}
if (bParam7)
{
}
Global_2097536.f_2769 = 0;
Global_2097536.f_2770 = 0;
Global_2097536.f_2768 = 0;
switch (iParam1)
{
case 2:
if (iParam4 == 0)
{
if (iParam5 > 0 && !func_212())
{
uParam0->f_44 = 826;
}
else
{
uParam0->f_44 = 815;
}
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
if (iParam5 > 0 && !func_212())
{
uParam0->f_44.f_3 = 2;
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "Laps", 32);
StringCopy(&Var8, "", 32);
StringIntConCat(&Var8, iParam5, 32);
uParam0->f_44.f_3.f_1[1 /*16*/].f_8 = { Var8 };
Global_2097536.f_2780.f_26 = iParam5;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_L1", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_LM", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
}
else if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_NN_L1", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_NN_LM", 32);
}
}
else
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_NN", 32);
}
Global_2097536.f_2780.f_26 = -1;
}
Global_2097536.f_2780 = 1;
if (iParam5 <= 0 || func_212())
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RANK", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "", 24);
Global_2097536.f_2710[0] = 1;
Global_2097536.f_2710[1] = 3;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2709 = 4;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 3;
Global_2097536.f_2780.f_29[2] = 5;
}
else
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_RT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 2;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2709 = 4;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 1;
Global_2097536.f_2780.f_29[2] = 3;
Global_2097536.f_2780.f_29[3] = 5;
}
Global_2097536.f_2779 = 0;
}
else if (iParam4 == 1)
{
if (iParam5 > 0 && !func_212())
{
uParam0->f_44 = 827;
}
else
{
uParam0->f_44 = 824;
}
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
if (iParam5 > 0 && !func_212())
{
uParam0->f_44.f_3 = 2;
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "Laps", 32);
StringCopy(&Var8, "", 32);
StringIntConCat(&Var8, iParam5, 32);
uParam0->f_44.f_3.f_1[1 /*16*/].f_8 = { Var8 };
Global_2097536.f_2780.f_26 = iParam5;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_GRCE_L1", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_GRCE_LM", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
}
else if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_GRCE_NN_L1", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_GRCE_NN_LM", 32);
}
}
else
{
Global_2097536.f_2780.f_26 = -1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_GRCE", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_GRCE_NN", 32);
}
}
Global_2097536.f_2780 = 1;
if (iParam5 <= 0 || func_212())
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RANK", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "", 24);
Global_2097536.f_2710[0] = 1;
Global_2097536.f_2710[1] = 5;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2709 = 6;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 3;
Global_2097536.f_2780.f_29[2] = 5;
}
else
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_RT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 2;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 5;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
Global_2097536.f_2709 = 6;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 1;
Global_2097536.f_2780.f_29[2] = 3;
Global_2097536.f_2780.f_29[3] = 5;
}
Global_2097536.f_2779 = 0;
}
else if (iParam4 == 2)
{
if (iParam5 > 0 && !func_212())
{
uParam0->f_44 = 828;
}
else
{
uParam0->f_44 = 825;
}
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 2;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
if (!bParam6)
{
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "CoDriver", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "", 32);
}
else
{
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "CoDriver", 32);
NETWORK::NETWORK_PLAYER_GET_USERID(PLAYER::PLAYER_ID(), &Var17);
MemCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), {Var17}, 8);
Global_2097536.f_2780.f_27 = 1;
}
if (iParam5 > 0 && !func_212())
{
uParam0->f_44.f_3 = 3;
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/]), "Laps", 32);
StringCopy(&Var8, "", 32);
StringIntConCat(&Var8, iParam5, 32);
uParam0->f_44.f_3.f_1[2 /*16*/].f_8 = { Var8 };
Global_2097536.f_2780.f_26 = iParam5;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RRCE_L1", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RRCE_LM", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
}
else if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RRCE_NN_L1", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RRCE_NN_LM", 32);
}
}
else
{
Global_2097536.f_2780.f_26 = -1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RRCE", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RRCE_NN", 32);
}
}
if (iParam5 <= 0 || func_212())
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RANK", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "", 24);
Global_2097536.f_2710[0] = 1;
Global_2097536.f_2710[1] = 3;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2709 = 4;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 3;
Global_2097536.f_2780.f_29[2] = 5;
}
else
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_RT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 2;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
Global_2097536.f_2709 = 4;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 1;
Global_2097536.f_2780.f_29[2] = 3;
Global_2097536.f_2780.f_29[3] = 5;
}
Global_2097536.f_2779 = 0;
}
else if (iParam4 == 10 || iParam4 == 11)
{
if (iParam5 > 0 && !func_212())
{
uParam0->f_44 = 928;
}
else
{
uParam0->f_44 = 849;
}
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
if (iParam5 > 0 && !func_212())
{
uParam0->f_44.f_3 = 2;
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "Laps", 32);
StringCopy(&Var8, "", 32);
StringIntConCat(&Var8, iParam5, 32);
uParam0->f_44.f_3.f_1[1 /*16*/].f_8 = { Var8 };
Global_2097536.f_2780.f_26 = iParam5;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_FRCE_L1", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_FRCE_LM", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
}
else if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_FRCE_NN_L1", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_FRCE_NN_LM", 32);
}
}
else
{
Global_2097536.f_2780.f_26 = -1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_FRCE", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_FRCE_NN", 32);
}
}
Global_2097536.f_2780 = 1;
if (iParam5 <= 0 || func_212())
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RANK", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "", 24);
Global_2097536.f_2710[0] = 1;
Global_2097536.f_2710[1] = 0;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2709 = 0;
Global_2097536.f_2708 = 1;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 5;
}
else
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_RT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 2;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 1;
Global_2097536.f_2780.f_29[2] = 5;
}
Global_2097536.f_2779 = 0;
}
else if (iParam4 == 3)
{
if (iParam5 > 0 && !func_212())
{
uParam0->f_44 = (998 + (iParam5 - 1));
}
else
{
uParam0->f_44 = 975;
}
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
if (iParam5 > 0 && !func_212())
{
Global_2097536.f_2780.f_26 = iParam5;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_L1", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_LM", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
}
else if (iParam5 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_NN_L1", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_NN_LM", 32);
}
}
else
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_RCE_NN", 32);
}
Global_2097536.f_2780.f_26 = -1;
}
Global_2097536.f_2780 = 1;
if (iParam5 <= 0 || func_212())
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RANK", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "", 24);
Global_2097536.f_2710[0] = 1;
Global_2097536.f_2710[1] = 3;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2709 = 4;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 3;
Global_2097536.f_2780.f_29[2] = 5;
}
else
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_RT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 2;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2709 = 4;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 1;
Global_2097536.f_2780.f_29[2] = 3;
Global_2097536.f_2780.f_29[3] = 5;
}
Global_2097536.f_2779 = 0;
}
break;
case 1:
if (iParam4 == 0 || iParam4 == 3)
{
uParam0->f_44 = 762;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (iParam4 == 3)
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_KOTH", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_KOTH_NN", 32);
}
}
else if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_DM", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_DM_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WLRAT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_LOSES", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_KD", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[5 /*6*/]), "SCLB_C_DEATH", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 6;
Global_2097536.f_2710[3] = 3;
Global_2097536.f_2710[4] = 1;
Global_2097536.f_2710[5] = 2;
Global_2097536.f_2708 = 6;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[4]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[5]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 4;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 4;
Global_2097536.f_2780.f_29[4] = 5;
Global_2097536.f_2780.f_29[5] = 5;
}
else if (iParam4 == 1 || iParam4 == 4)
{
uParam0->f_44 = 822;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (iParam4 == 4)
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_TKOTH", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_TKOTH_NN", 32);
}
}
else if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_TDM", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_TDM_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WLRAT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_LOSES", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_KD", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[5 /*6*/]), "SCLB_C_DEATH", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 6;
Global_2097536.f_2710[3] = 3;
Global_2097536.f_2710[4] = 1;
Global_2097536.f_2710[5] = 2;
Global_2097536.f_2708 = 6;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[4]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[5]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 4;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 4;
Global_2097536.f_2780.f_29[4] = 5;
Global_2097536.f_2780.f_29[5] = 5;
}
else if (iParam4 == 2)
{
uParam0->f_44 = 823;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_VEHDM", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_VEHDM_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WLRAT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_LOSES", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_KD", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[5 /*6*/]), "SCLB_C_DEATH", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 6;
Global_2097536.f_2710[3] = 3;
Global_2097536.f_2710[4] = 1;
Global_2097536.f_2710[5] = 2;
Global_2097536.f_2708 = 6;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[4]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[5]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 4;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 4;
Global_2097536.f_2780.f_29[4] = 5;
Global_2097536.f_2780.f_29[5] = 5;
}
break;
case 11:
uParam0->f_44 = 193;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "MP", 32);
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_GOLF", 32);
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_GOLF0", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_GOLF1", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_GAMES", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 7;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 94:
uParam0->f_44 = 193;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "SP", 32);
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_GOLF", 32);
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_GOLF0", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_GOLF1", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_GAMES", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 7;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 92:
uParam0->f_44 = 811;
uParam0->f_44.f_1 = 1;
uParam0->f_44.f_3 = 0;
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_HUNTING", 32);
StringCopy(&(Global_2097536.f_2780.f_9), "CMSW", 64);
Global_2097536.f_2780.f_25 = 0;
Global_2097536.f_2780 = 0;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_HSCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_TIMEHUNT", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_EKILLS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_PHOTOS", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_MONEY", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 5;
Global_2097536.f_2710[2] = 2;
Global_2097536.f_2710[3] = 4;
Global_2097536.f_2710[4] = 6;
Global_2097536.f_2708 = 5;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[4]);
Global_2097536.f_2780.f_28 = 6;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 6;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
Global_2097536.f_2780.f_29[4] = 5;
break;
case 15:
uParam0->f_44 = 749;
uParam0->f_44.f_1 = 1;
uParam0->f_44.f_3 = 0;
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_ARM", 32);
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_LOSES", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_WLRAT", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 2;
Global_2097536.f_2710[1] = 5;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 4;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 14:
uParam0->f_44 = 190;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
if (iParam4 == -1)
{
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "MP", 32);
}
else
{
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "SP", 32);
}
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_DARTS", 32);
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WLRAT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_LOSES", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 7;
Global_2097536.f_2710[2] = 5;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 4;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 12:
uParam0->f_44 = 283;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "MP", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_TENNIS", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
if (MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_9), "HUD_MG_TENNIS", 64);
StringIntConCat(&(Global_2097536.f_2780.f_9), iParam4 + 1, 64);
}
Global_2097536.f_2780.f_25 = 0;
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_LOSES", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_TEN1", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_TEN2", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_TEN0", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 9;
Global_2097536.f_2710[2] = 7;
Global_2097536.f_2710[3] = 5;
Global_2097536.f_2710[4] = 2;
Global_2097536.f_2708 = 5;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[4]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
Global_2097536.f_2780.f_29[4] = 5;
break;
case 87:
uParam0->f_44 = 283;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "SP", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_TENNIS", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
Global_2097536.f_2780.f_25 = 0;
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_LOSES", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_TEN1", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_TEN2", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_TEN0", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 9;
Global_2097536.f_2710[2] = 7;
Global_2097536.f_2710[3] = 5;
Global_2097536.f_2710[4] = 2;
Global_2097536.f_2708 = 5;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[4]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
Global_2097536.f_2780.f_29[4] = 5;
break;
case 13:
uParam0->f_44 = 912;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 2;
switch (iParam4)
{
case 0:
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Type", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "RANDOM", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_RANGEa", 32);
break;
case 1:
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Type", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "GRID", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_RANGEb", 32);
break;
case 2:
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Type", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "COVERED", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_RANGEc", 32);
break;
default:
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Type", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "RANDOM", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_RANGEa", 32);
break;
}
switch (iParam5)
{
case 0:
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "WeaponId", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "Pistols", 32);
StringCopy(&(Global_2097536.f_2780.f_9), "HUD_MG_PISTOL", 64);
break;
case 1:
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "WeaponId", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "SMGs", 32);
StringCopy(&(Global_2097536.f_2780.f_9), "HUD_MG_SMG", 64);
break;
case 2:
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "WeaponId", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "AssaultRifles", 32);
StringCopy(&(Global_2097536.f_2780.f_9), "HUD_MG_ASSAULT", 64);
break;
case 3:
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "WeaponId", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "Shotguns", 32);
StringCopy(&(Global_2097536.f_2780.f_9), "HUD_MG_SHOTGUN", 64);
break;
case 4:
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "WeaponId", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "LMGs", 32);
StringCopy(&(Global_2097536.f_2780.f_9), "HUD_MG_LMG", 64);
break;
case 5:
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "WeaponId", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "Heavies", 32);
StringCopy(&(Global_2097536.f_2780.f_9), "HUD_MG_HEAVY", 64);
break;
default:
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "WeaponId", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "Pistols", 32);
StringCopy(&(Global_2097536.f_2780.f_9), "HUD_MG_PISTOL", 64);
break;
}
Global_2097536.f_2780.f_25 = 0;
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WLRAT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_HITS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_SHOTS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_ACC", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 2;
Global_2097536.f_2710[2] = 1;
Global_2097536.f_2710[3] = 3;
Global_2097536.f_2708 = 4;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 4;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 4;
break;
case 38:
case 39:
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
case 48:
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 206:
case 207:
case 208:
case 209:
uParam0->f_44 = 203;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Type", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_RANGE", 32);
MemCopy(&(Global_2097536.f_2780.f_9), {func_211(iParam1)}, 16);
Global_2097536.f_2780.f_25 = 0;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WEAP", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 7;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 8;
break;
case 69:
case 71:
case 70:
uParam0->f_44 = 202;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Location", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2780.f_1), "HUD_MG_TRI", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
Global_2097536.f_2780.f_25 = 0;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_TIME", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_RANK", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 0;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 1;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
Global_2097536.f_2780.f_28 = 3;
Global_2097536.f_2780.f_29[0] = 2;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 0;
Global_2097536.f_2780.f_29[3] = 0;
break;
case 80:
uParam0->f_44 = 817;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 3;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "SP", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "Location", 32);
uParam0->f_44.f_3.f_1[1 /*16*/].f_8 = { Var0 };
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/]), "Type", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "OffroadRace", 32);
Global_2097536.f_2780.f_25 = 0;
Global_2097536.f_2780 = 1;
StringCopy(&(Global_2097536.f_2780.f_1), "OFFR_TITLE", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_TIME", 24);
Global_2097536.f_2710[0] = 3;
Global_2097536.f_2708 = 1;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
Global_2097536.f_2780.f_28 = 3;
Global_2097536.f_2780.f_29[0] = 1;
break;
case 3:
uParam0->f_44 = 791;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_HRD", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_HRD_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WAVE", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_TKILLS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_TDEATH", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 2;
Global_2097536.f_2710[3] = 3;
Global_2097536.f_2708 = 4;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 0:
if (iParam4 == 7 || iParam4 == 1)
{
uParam0->f_44 = 1200;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
if (iParam4 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_HEIST", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_HEISTP", 32);
}
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else if (iParam4 == 1)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_HEIST_NN", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_HEISTPNN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_TIME", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_ACC", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_HEADSHOT", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_KILLS", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 4;
Global_2097536.f_2710[3] = 5;
Global_2097536.f_2710[4] = 6;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[4]);
Global_2097536.f_2780.f_28 = 6;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 11;
Global_2097536.f_2780.f_29[2] = 4;
Global_2097536.f_2780.f_29[3] = 5;
Global_2097536.f_2780.f_29[4] = 5;
}
else if (Global_4718592.f_551 == 1)
{
uParam0->f_44 = 777;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
if (Global_4718592.f_2 == 5)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_LTS", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_MIS", 32);
}
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else if (Global_4718592.f_2 == 5)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_LTS_NN", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_MIS_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_TIME", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_DEATH", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 2;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 2;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
}
else
{
uParam0->f_44 = 780;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
if (Global_4718592.f_2 == 5)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_LTS", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_MIS", 32);
}
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else if (Global_4718592.f_2 == 5)
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_LTS_NN", 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_MIS_NN", 32);
}
if (func_210(Global_4718592.f_138376) || func_207(Global_4718592.f_138376))
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_DEATH", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 2;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
}
else if (func_206(Global_4718592.f_138376))
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_DEATH", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 2;
Global_2097536.f_2710[2] = 0;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
}
else
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_DEATH", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 2;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
}
}
break;
case 8:
uParam0->f_44 = 795;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_BJ", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_BJ_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_TIME", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_JUMPS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_RANK", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
MISC::SET_BIT(&(Global_2097536.f_2768), true);
Global_2097536.f_2754[1] = -1;
Global_2097536.f_2710[2] = 2;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 11;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 85:
uParam0->f_44 = 274;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Location", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
Global_2097536.f_2780.f_25 = 0;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_BJ", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_BJ_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_CASH", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_TOTCASH", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 3;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 3;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
break;
case 122:
switch (iParam4)
{
case 0:
case 9:
case 4:
case 8:
switch (iParam4)
{
case 0:
uParam0->f_44 = 965;
break;
case 9:
uParam0->f_44 = 966;
break;
case 4:
uParam0->f_44 = 967;
break;
case 8:
uParam0->f_44 = 968;
break;
}
uParam0->f_44.f_1 = 1;
uParam0->f_44.f_3 = 0;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "", 32);
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), sParam3, 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "PS_TITLE", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_TIME", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_MEDAL1", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_MEDAL2", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_MEDAL3", 24);
Global_2097536.f_2710[0] = 1;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 2;
Global_2097536.f_2708 = 4;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 1:
case 2:
case 3:
switch (iParam4)
{
case 1:
uParam0->f_44 = 969;
break;
case 2:
uParam0->f_44 = 970;
break;
case 3:
uParam0->f_44 = 973;
break;
}
uParam0->f_44.f_1 = 1;
uParam0->f_44.f_3 = 0;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "", 32);
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), sParam3, 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "PS_TITLE", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_DIST", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_MEDAL1", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_MEDAL2", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_MEDAL3", 24);
Global_2097536.f_2710[0] = 1;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 2;
Global_2097536.f_2708 = 4;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_29[0] = 4;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 7:
uParam0->f_44 = 971;
uParam0->f_44.f_1 = 1;
uParam0->f_44.f_3 = 0;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "", 32);
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), sParam3, 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "PS_TITLE", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_AVG_HEI", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_MEDAL1", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_MEDAL2", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_MEDAL3", 24);
Global_2097536.f_2710[0] = 1;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 2;
Global_2097536.f_2708 = 4;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_29[0] = 4;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 6:
case 5:
switch (iParam4)
{
case 6:
uParam0->f_44 = 972;
break;
case 5:
uParam0->f_44 = 974;
break;
}
uParam0->f_44.f_1 = 1;
uParam0->f_44.f_3 = 0;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "", 32);
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), sParam3, 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "PS_TITLE", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_MEDAL1", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_MEDAL2", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_MEDAL3", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 3;
Global_2097536.f_2710[2] = 2;
Global_2097536.f_2710[3] = 1;
Global_2097536.f_2708 = 4;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_29[0] = 12;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
}
break;
case 83:
uParam0->f_44 = 192;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Location", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), sParam3, 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "PS_TITLE", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_DIST", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_MEDAL1", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_MEDAL2", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_MEDAL3", 24);
Global_2097536.f_2710[0] = 2;
Global_2097536.f_2710[1] = 5;
Global_2097536.f_2710[2] = 4;
Global_2097536.f_2710[3] = 3;
Global_2097536.f_2708 = 4;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_29[0] = 17;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 82:
uParam0->f_44 = 850;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Location", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
Global_2097536.f_2780.f_25 = 0;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), sParam3, 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_MIS_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_TIME", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_MEDAL1", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_MEDAL2", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_MEDAL3", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 2;
Global_2097536.f_2708 = 4;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_29[0] = 10;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 84:
uParam0->f_44 = 820;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "Location", 32);
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
Global_2097536.f_2780 = 1;
Global_2097536.f_2780.f_25 = 0;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), "PS_TITLE", 32);
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_MIS_NN", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_SCORE", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_TIME", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_ACC", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_MEDAL1", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_MEDAL2", 24);
StringCopy(&(Global_2097536.f_2717[4 /*6*/]), "SCLB_C_MEDAL3", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 2;
Global_2097536.f_2710[3] = 5;
Global_2097536.f_2710[4] = 4;
Global_2097536.f_2710[5] = 3;
Global_2097536.f_2708 = 6;
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[4]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[5]);
Global_2097536.f_2780.f_29[0] = 4;
Global_2097536.f_2780.f_29[1] = 9;
Global_2097536.f_2780.f_29[2] = 4;
Global_2097536.f_2780.f_29[3] = 5;
Global_2097536.f_2780.f_29[4] = 5;
Global_2097536.f_2780.f_29[5] = 5;
break;
case 86:
uParam0->f_44 = 817;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 3;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "SP", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "Location", 32);
uParam0->f_44.f_3.f_1[1 /*16*/].f_8 = { Var0 };
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/]), "Type", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "StuntPlaneRace", 32);
Global_2097536.f_2780 = 1;
Global_2097536.f_2780.f_25 = 0;
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam3))
{
StringCopy(&(Global_2097536.f_2780.f_1), sParam3, 32);
}
else
{
StringCopy(&(Global_2097536.f_2780.f_1), "SPR_TITLE", 32);
}
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_TIME", 24);
Global_2097536.f_2710[0] = 2;
Global_2097536.f_2708 = 1;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
Global_2097536.f_2780.f_28 = 3;
Global_2097536.f_2780.f_29[0] = 1;
break;
case 91:
uParam0->f_44 = 817;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 3;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "Location", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/]), "Type", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "SP", 32);
Global_2097536.f_2780 = 1;
if (iParam5 <= 0)
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_RT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "", 24);
Global_2097536.f_2710[0] = 3;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 1;
Global_2097536.f_2710[3] = 0;
Global_2097536.f_2709 = 6;
Global_2097536.f_2708 = 2;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 3;
}
else
{
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_RT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_BL", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "", 24);
Global_2097536.f_2710[0] = 3;
Global_2097536.f_2710[1] = 2;
Global_2097536.f_2710[2] = 4;
Global_2097536.f_2710[3] = 1;
Global_2097536.f_2709 = 4;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 1;
Global_2097536.f_2780.f_29[1] = 1;
Global_2097536.f_2780.f_29[2] = 3;
}
Global_2097536.f_2779 = 0;
switch (iParam4)
{
case 0:
StringCopy(&(Global_2097536.f_2780.f_1), "MGCR_1", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGCR_1", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "StreetRace", 32);
break;
case 1:
StringCopy(&(Global_2097536.f_2780.f_1), "MGCR_2", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGCR_2", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "StreetRace", 32);
break;
case 2:
StringCopy(&(Global_2097536.f_2780.f_1), "MGCR_4", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGCR_4", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "StreetRace", 32);
break;
case 3:
StringCopy(&(Global_2097536.f_2780.f_1), "MGCR_5", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGCR_5", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "StreetRace", 32);
break;
case 4:
StringCopy(&(Global_2097536.f_2780.f_1), "MGCR_6", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGCR_6", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "StreetRace", 32);
break;
case 5:
StringCopy(&(Global_2097536.f_2780.f_1), "MGSR_1", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGSR_1", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "SeaRace", 32);
break;
case 6:
StringCopy(&(Global_2097536.f_2780.f_1), "MGSR_2", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGSR_2", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "SeaRace", 32);
break;
case 7:
StringCopy(&(Global_2097536.f_2780.f_1), "MGSR_3", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGSR_3", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "SeaRace", 32);
break;
case 8:
StringCopy(&(Global_2097536.f_2780.f_1), "MGSR_4", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/].f_8), "MGSR_4", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[2 /*16*/].f_8), "SeaRace", 32);
break;
default:
break;
}
break;
case 888:
uParam0->f_44 = 1201;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "ArenaMode", 32);
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_GAMES", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 2;
Global_2097536.f_2710[3] = 3;
MemCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), {func_205(iParam4)}, 8);
Global_2097536.f_2708 = 4;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
switch (iParam4)
{
case 1:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_BUZZ", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_TIMESUR", 24);
Global_2097536.f_2780.f_29[3] = 9;
break;
case 2:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_CARN", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_DAMDEALT", 24);
break;
case 3:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_FLAGW", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_FLAGS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_KILLS", 24);
break;
case 4:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_WRECK", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_DAMDEALT", 24);
break;
case 5:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_BOMBB", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_POINTS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_GOALS", 24);
break;
case 6:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_GAMEM", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_CPOINTS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_KILLS", 24);
break;
case 7:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_MNSTR", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_DAMDEALT", 24);
break;
case 8:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_HOTB", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_PASSES", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_TIMESUR", 24);
Global_2097536.f_2780.f_29[3] = 9;
break;
case 9:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_TAGT", 32);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_KILLS", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_TAGS", 24);
break;
}
Global_2097536.f_2780 = 1;
Global_2097536.f_2708 = 4;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 5;
break;
case 889:
uParam0->f_44 = 1202;
uParam0->f_44.f_1 = 1;
uParam0->f_44.f_3 = 0;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_ARN_CAREER", 32);
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_CARPT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WLRAT", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_MATCHES", 24);
StringCopy(&(Global_2097536.f_2717[3 /*6*/]), "SCLB_C_TITLE", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 1;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2710[3] = 4;
Global_2097536.f_2780 = 1;
Global_2097536.f_2708 = 4;
Global_2097536.f_2780.f_28 = 5;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[3]);
Global_2097536.f_2780.f_28 = 5;
Global_2097536.f_2780.f_29[0] = 5;
Global_2097536.f_2780.f_29[1] = 4;
Global_2097536.f_2780.f_29[2] = 5;
Global_2097536.f_2780.f_29[3] = 21;
break;
case 890:
uParam0->f_44 = 1203;
uParam0->f_44.f_1 = 1;
uParam0->f_44.f_3 = 0;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_CCM_CAREER", 32);
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_CCMLVL", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WLRAT", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_RACES", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 4;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2780 = 1;
Global_2097536.f_2708 = 3;
Global_2097536.f_2780.f_28 = 4;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::CLEAR_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 22;
Global_2097536.f_2780.f_29[1] = 4;
Global_2097536.f_2780.f_29[2] = 5;
break;
case 276:
uParam0->f_44 = 1204;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 1;
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&Var0, "TUNER_SANDB_SVAR", 32);
if (iParam4 == 2 || iParam4 == 3)
{
StringIntConCat(&Var0, 2, 32);
}
else
{
StringIntConCat(&Var0, iParam4, 32);
}
uParam0->f_44.f_3.f_1[0 /*16*/].f_8 = { Var0 };
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BESTT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_VEH", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 2;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2709 = 4;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2708 = 3;
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 2;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 3;
switch (iParam4)
{
case 0:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_T_TT", 32);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 3;
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BESTT", 24);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_VEH", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "", 24);
Global_2097536.f_2708 = 2;
Global_2097536.f_2780.f_28 = 3;
Global_2097536.f_2780.f_29[0] = 2;
Global_2097536.f_2780.f_29[1] = 3;
break;
case 1:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_T_CD", 32);
break;
case 2:
case 3:
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_T_HH1", 32);
break;
}
break;
case 278:
case 279:
uParam0->f_44 = 1204;
uParam0->f_44.f_1 = 5;
uParam0->f_44.f_3 = 2;
StringCopy(&(uParam0->f_44.f_3.f_1[1 /*16*/]), "Mission", 32);
uParam0->f_44.f_3.f_1[1 /*16*/].f_8 = { Var0 };
if (iParam1 == 278)
{
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "TUNER_SRS", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_T_SRS", 32);
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BL", 24);
}
else
{
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/]), "GameType", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[0 /*16*/].f_8), "TUNER_PS", 32);
StringCopy(&(Global_2097536.f_2780.f_1), "SCLB_T_PURS", 32);
StringCopy(&(Global_2097536.f_2717[0 /*6*/]), "SCLB_C_BESTT", 24);
}
StringCopy(&(Global_2097536.f_2780.f_9), sParam3, 64);
StringCopy(&(Global_2097536.f_2717[1 /*6*/]), "SCLB_C_WINS", 24);
StringCopy(&(Global_2097536.f_2717[2 /*6*/]), "SCLB_C_VEH", 24);
Global_2097536.f_2710[0] = 0;
Global_2097536.f_2710[1] = 2;
Global_2097536.f_2710[2] = 3;
Global_2097536.f_2709 = 4;
Global_2097536.f_2708 = 3;
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[0]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[1]);
MISC::SET_BIT(&(Global_2097536.f_2769), Global_2097536.f_2710[2]);
Global_2097536.f_2780.f_28 = 4;
Global_2097536.f_2780.f_29[0] = 2;
Global_2097536.f_2780.f_29[1] = 5;
Global_2097536.f_2780.f_29[2] = 3;
Global_2097536.f_2780 = 1;
break;
}
bVar16 = false;
bVar16 = false;
while (bVar16 < Global_2097536.f_2708)
{
if (BitTest(Global_2097536.f_2769, Global_2097536.f_2710[bVar16]))
{
MISC::SET_BIT(&(Global_2097536.f_2770), bVar16);
}
bVar16++;
}
Global_2097536.f_2826 = func_204(Var0, uParam0->f_44, iParam1, iParam4, iParam5, bParam6);
}
int func_204(struct<8> Param0, int iParam8, int iParam9, int iParam10, int iParam11, bool bParam12)
{
char cVar0[64];
MemCopy(&cVar0, {Param0}, 16);
StringIntConCat(&cVar0, iParam8, 64);
StringConCat(&cVar0, "_", 64);
if (func_169(iParam8))
{
if (bParam12)
{
StringConCat(&cVar0, "CoDri", 64);
}
else
{
StringConCat(&cVar0, "Dri", 64);
}
StringConCat(&cVar0, "_", 64);
}
StringIntConCat(&cVar0, iParam9, 64);
StringConCat(&cVar0, "_", 64);
StringIntConCat(&cVar0, iParam10, 64);
StringConCat(&cVar0, "_", 64);
StringIntConCat(&cVar0, iParam11, 64);
return MISC::GET_HASH_KEY(&cVar0);
}
struct<6> func_205(int iParam0)
{
struct<6> Var0;
switch (iParam0)
{
case 1:
StringCopy(&Var0, "BuzzerBeater", 24);
break;
case 2:
StringCopy(&Var0, "Carnage", 24);
break;
case 3:
StringCopy(&Var0, "FlagWar", 24);
break;
case 4:
StringCopy(&Var0, "WreckIt", 24);
break;
case 5:
StringCopy(&Var0, "BombBall", 24);
break;
case 6:
StringCopy(&Var0, "GamesMasters", 24);
break;
case 7:
StringCopy(&Var0, "Monsters", 24);
break;
case 8:
StringCopy(&Var0, "HotBomb", 24);
break;
case 9:
StringCopy(&Var0, "TagTeam", 24);
break;
default:
break;
}
return Var0;
}
bool func_206(int iParam0)
{
return iParam0 == 74;
}
var func_207(int iParam0)
{
return (func_209(iParam0) || func_208(iParam0));
}
bool func_208(int iParam0)
{
return iParam0 == 44;
}
bool func_209(int iParam0)
{
return iParam0 == 45;
}
bool func_210(int iParam0)
{
return iParam0 == 12;
}
struct<6> func_211(int iParam0)
{
struct<6> Var0;
switch (iParam0)
{
case 38:
StringCopy(&Var0, "HUD_MG_RANGE0", 24);
break;
case 39:
StringCopy(&Var0, "HUD_MG_RANGE1", 24);
break;
case 40:
StringCopy(&Var0, "HUD_MG_RANGE2", 24);
break;
case 41:
StringCopy(&Var0, "HUD_MG_RANGE3", 24);
break;
case 42:
StringCopy(&Var0, "HUD_MG_RANGE4", 24);
break;
case 43:
StringCopy(&Var0, "HUD_MG_RANGE5", 24);
break;
case 44:
StringCopy(&Var0, "HUD_MG_RANGE6", 24);
break;
case 45:
StringCopy(&Var0, "HUD_MG_RANGE7", 24);
break;
case 46:
StringCopy(&Var0, "HUD_MG_RANGE8", 24);
break;
case 47:
StringCopy(&Var0, "HUD_MG_RANGE9", 24);
break;
case 48:
StringCopy(&Var0, "HUD_MG_RANGE10", 24);
break;
case 49:
StringCopy(&Var0, "HUD_MG_RANGE11", 24);
break;
case 50:
StringCopy(&Var0, "HUD_MG_RANGE12", 24);
break;
case 51:
StringCopy(&Var0, "HUD_MG_RANGE13", 24);
break;
case 52:
StringCopy(&Var0, "HUD_MG_RANGE14", 24);
break;
case 53:
StringCopy(&Var0, "HUD_MG_RANGE15", 24);
break;
case 54:
StringCopy(&Var0, "HUD_MG_RANGE16", 24);
break;
case 55:
StringCopy(&Var0, "HUD_MG_RANGE17", 24);
break;
case 206:
StringCopy(&Var0, "HUD_MG_RANGE18", 24);
break;
case 207:
StringCopy(&Var0, "HUD_MG_RANGE19", 24);
break;
case 208:
StringCopy(&Var0, "HUD_MG_RANGE20", 24);
break;
case 209:
StringCopy(&Var0, "HUD_MG_RANGE21", 24);
break;
}
return Var0;
}
int func_212()
{
if ((((((((((((Global_4718592.f_77712 == 1 || Global_4718592.f_77712 == 3) || Global_4718592.f_77712 == 5) || Global_4718592.f_77712 == 7) || Global_4718592.f_77712 == 19) || Global_4718592.f_77712 == 8) || Global_4718592.f_77712 == 9) || Global_4718592.f_77712 == 11) || Global_4718592.f_77712 == 13) || Global_4718592.f_77712 == 21) || Global_4718592.f_77712 == 23) || Global_4718592.f_77712 == 25) || Global_4718592.f_77712 == 26)
{
return 1;
}
return 0;
}
bool func_213()
{
return NETWORK::NETWORK_IS_SIGNED_ONLINE();
}
void func_214(int* iParam0, bool bParam1, int iParam2, char* sParam3, int iParam4, char* sParam5, int iParam6, int iParam7, int iParam8, int iParam9)
{
if (*iParam0 == 0)
{
*iParam0 = GRAPHICS::REQUEST_SCALEFORM_MOVIE_INSTANCE("instructional_buttons");
}
iParam0->f_1 = 0;
iParam0->f_3[0] = iParam2;
iParam0->f_3[1] = iParam4;
iParam0->f_3[2] = iParam6;
iParam0->f_3[3] = iParam8;
iParam0->f_3[4] = 361;
iParam0->f_3[5] = 361;
iParam0->f_3[6] = 361;
iParam0->f_3[7] = 361;
iParam0->f_12[0] = func_215(iParam2 != 361, PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, iParam2, true), "");
iParam0->f_12[1] = func_215(iParam4 != 361, PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, iParam4, true), "");
iParam0->f_12[2] = func_215(iParam6 != 361, PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, iParam6, true), "");
iParam0->f_12[3] = func_215(iParam8 != 361, PAD::GET_CONTROL_INSTRUCTIONAL_BUTTON(2, iParam8, true), "");
iParam0->f_12[4] = 0;
iParam0->f_12[5] = 0;
iParam0->f_12[6] = 0;
iParam0->f_12[7] = 0;
iParam0->f_21[0] = sParam3;
iParam0->f_21[1] = sParam5;
iParam0->f_21[2] = iParam7;
iParam0->f_21[3] = iParam9;
if (bParam1)
{
iParam0->f_2 = 1;
}
else
{
iParam0->f_2 = 0;
}
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(*iParam0))
{
func_21(&(iParam0->f_1), 1);
}
}
char* func_215(bool bParam0, char* sParam1, char* sParam2)
{
if (bParam0)
{
return sParam1;
}
return sParam2;
}
void func_216()
{
func_217(PLAYER::PLAYER_PED_ID(), "GENERIC_CURSE_MED", 24);
}
void func_217(int iParam0, char* sParam1, int iParam2)
{
AUDIO::PLAY_PED_AMBIENT_SPEECH_NATIVE(iParam0, sParam1, func_218(iParam2), 1);
}
int func_218(int iParam0)
{
int iVar0;
switch (iParam0)
{
case 0:
return "SPEECH_PARAMS_STANDARD";
case 1:
return "SPEECH_PARAMS_ALLOW_REPEAT";
case 2:
return "SPEECH_PARAMS_BEAT";
case 3:
return "SPEECH_PARAMS_FORCE";
case 4:
return "SPEECH_PARAMS_FORCE_FRONTEND";
case 5:
return "SPEECH_PARAMS_FORCE_NO_REPEAT_FRONTEND";
case 6:
return "SPEECH_PARAMS_FORCE_NORMAL";
case 7:
return "SPEECH_PARAMS_FORCE_NORMAL_CLEAR";
case 8:
return "SPEECH_PARAMS_FORCE_NORMAL_CRITICAL";
case 9:
return "SPEECH_PARAMS_FORCE_SHOUTED";
case 10:
return "SPEECH_PARAMS_FORCE_SHOUTED_CLEAR";
case 11:
return "SPEECH_PARAMS_FORCE_SHOUTED_CRITICAL";
case 12:
return "SPEECH_PARAMS_FORCE_PRELOAD_ONLY";
case 13:
return "SPEECH_PARAMS_MEGAPHONE";
case 14:
return "SPEECH_PARAMS_HELI";
case 15:
return "SPEECH_PARAMS_FORCE_MEGAPHONE";
case 16:
return "SPEECH_PARAMS_FORCE_HELI";
case 17:
return "SPEECH_PARAMS_INTERRUPT";
case 18:
return "SPEECH_PARAMS_INTERRUPT_SHOUTED";
case 19:
return "SPEECH_PARAMS_INTERRUPT_SHOUTED_CLEAR";
case 20:
return "SPEECH_PARAMS_INTERRUPT_SHOUTED_CRITICAL";
case 21:
return "SPEECH_PARAMS_INTERRUPT_NO_FORCE";
case 22:
return "SPEECH_PARAMS_INTERRUPT_FRONTEND";
case 23:
return "SPEECH_PARAMS_INTERRUPT_NO_FORCE_FRONTEND";
case 24:
return "SPEECH_PARAMS_ADD_BLIP";
case 25:
return "SPEECH_PARAMS_ADD_BLIP_ALLOW_REPEAT";
case 26:
return "SPEECH_PARAMS_ADD_BLIP_FORCE";
case 27:
return "SPEECH_PARAMS_ADD_BLIP_SHOUTED";
case 28:
return "SPEECH_PARAMS_ADD_BLIP_SHOUTED_FORCE";
case 29:
return "SPEECH_PARAMS_ADD_BLIP_INTERRUPT";
case 30:
return "SPEECH_PARAMS_ADD_BLIP_INTERRUPT_FORCE";
case 31:
return "SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED";
case 32:
return "SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED_CLEAR";
case 33:
return "SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED_CRITICAL";
case 34:
return "SPEECH_PARAMS_SHOUTED";
case 35:
return "SPEECH_PARAMS_SHOUTED_CLEAR";
case 36:
return "SPEECH_PARAMS_SHOUTED_CRITICAL";
default:
}
iVar0 = 0;
return iVar0;
}
int func_219()
{
if (func_46(0))
{
return 0;
}
if (Global_100019.f_8)
{
if (Global_100019.f_10 > 0)
{
return 0;
}
}
else if (Global_100019.f_10 > 1)
{
return 0;
}
Global_100019.f_10++;
return 1;
}
void func_220(int iParam0, int iParam1)
{
Global_100019.f_7 = iParam0;
Global_100019.f_8 = iParam1;
}
void func_221(int* iParam0, bool bParam1, bool bParam2)
{
if (bParam2)
{
MISC::SET_BIT(&(iParam0->f_607), bParam1);
}
else
{
MISC::CLEAR_BIT(&(iParam0->f_607), bParam1);
}
}
int func_222(var uParam0, int iParam1, var uParam2, var uParam3, float fParam4)
{
int iVar0;
if (iParam1 > 1 && *uParam0 == (iParam1 - 1))
{
iVar0 = 100;
}
else
{
iVar0 = 0;
}
*uParam3 = 0;
*uParam3 = (*uParam3 + SYSTEM::CEIL(((fParam4 * 50f) + (fParam4 * IntToFloat(iVar0)))));
*uParam3 = (*uParam3 + SYSTEM::CEIL(((fParam4 * 1.5f) * SYSTEM::TO_FLOAT(*uParam2))));
func_223(func_428(), 1, *uParam3, 0, 0);
return 1;
}
void func_223(int iParam0, int iParam1, int iParam2, bool bParam3, bool bParam4)
{
int iVar0;
int iVar1;
if (func_256(iParam0) == 3)
{
return;
}
if (func_256(iParam0) == 4)
{
return;
}
func_224(func_256(iParam0), 1, iParam1, iParam2, 0);
if (bParam3)
{
iVar0 = 0;
if (bParam4)
{
switch (iParam0)
{
case 0:
iVar1 = joaat("sp0_money_made_from_random_peds");
break;
case 1:
iVar1 = joaat("sp1_money_made_from_random_peds");
break;
case 2:
iVar1 = joaat("sp2_money_made_from_random_peds");
break;
default:
return;
}
}
else
{
switch (iParam0)
{
case 0:
iVar1 = joaat("sp0_money_made_from_missions");
break;
case 1:
iVar1 = joaat("sp1_money_made_from_missions");
break;
case 2:
iVar1 = joaat("sp2_money_made_from_missions");
break;
default:
return;
}
}
STATS::STAT_GET_INT(iVar1, &iVar0, -1);
iVar0 = (iVar0 + iParam2);
STATS::STAT_SET_INT(iVar1, iVar0, true);
}
}
int func_224(int iParam0, int iParam1, int iParam2, int iParam3, bool bParam4)
{
float fVar0;
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
func_255();
if (iParam3 < 1)
{
return 0;
}
fVar0 = 1f;
switch (iParam1)
{
case 0:
switch (iParam0)
{
case 0:
func_363(99, 1);
func_254(joaat("sp0_money_total_spent"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_total_spent"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_total_spent"), iParam3);
break;
}
func_238(0);
switch (iParam2)
{
case 127:
case 129:
case 125:
case 126:
case 128:
if (func_235(5))
{
fVar0 = 0.9f;
bVar1 = 5;
}
break;
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
switch (iParam0)
{
case 0:
func_254(joaat("sp0_money_spent_on_tattoos"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_spent_on_tattoos"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_spent_on_tattoos"), iParam3);
break;
}
if (func_235(1))
{
fVar0 = 0f;
bVar1 = true;
}
break;
case 21:
switch (iParam0)
{
case 0:
func_254(joaat("sp0_money_spent_on_taxis"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_spent_on_taxis"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_spent_on_taxis"), iParam3);
break;
}
break;
case 25:
switch (iParam0)
{
case 0:
func_254(joaat("sp0_money_spent_in_strip_clubs"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_spent_in_strip_clubs"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_spent_in_strip_clubs"), iParam3);
break;
}
break;
case 99:
case 100:
case 101:
case 102:
case 104:
case 105:
case 106:
case 107:
case 108:
case 109:
case 110:
case 111:
case 112:
case 113:
switch (iParam0)
{
case 0:
func_254(joaat("sp0_money_spent_property"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_spent_property"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_spent_property"), iParam3);
break;
}
break;
default:
switch (SCRIPT::GET_HASH_OF_THIS_SCRIPT_NAME())
{
case joaat("clothes_shop_sp"):
switch (iParam0)
{
case 0:
func_254(joaat("sp0_money_spent_in_clothes"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_spent_in_clothes"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_spent_in_clothes"), iParam3);
break;
}
break;
case joaat("hairdo_shop_sp"):
switch (iParam0)
{
case 0:
func_254(joaat("sp0_money_spent_on_hairdos"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_spent_on_hairdos"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_spent_on_hairdos"), iParam3);
break;
}
if (func_235(0))
{
fVar0 = 0f;
bVar1 = false;
}
break;
case joaat("gunclub_shop"):
switch (iParam0)
{
case 0:
func_254(joaat("sp0_money_spent_in_buying_guns"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_spent_in_buying_guns"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_spent_in_buying_guns"), iParam3);
break;
}
break;
case joaat("carmod_shop"):
switch (iParam0)
{
case 0:
func_254(joaat("sp0_money_spent_car_mods"), iParam3);
break;
case 1:
func_254(joaat("sp1_money_spent_car_mods"), iParam3);
break;
case 2:
func_254(joaat("sp2_money_spent_car_mods"), iParam3);
break;
}
func_234(iParam3);
break;
}
break;
}
break;
case 1:
switch (iParam0)
{
case 0:
func_363(95, iParam3);
break;
case 1:
func_363(97, iParam3);
break;
case 2:
func_363(96, iParam3);
break;
}
func_363(98, iParam3);
break;
}
iVar2 = iParam0;
iParam3 = SYSTEM::FLOOR((fVar0 * SYSTEM::TO_FLOAT(iParam3)));
iVar3 = 0;
iVar4 = iParam3;
if (fVar0 == 0f)
{
func_227(bVar1);
return 1;
}
else if (fVar0 != 1f)
{
func_227(bVar1);
}
iVar5 = (Global_59870[iVar2] + iParam3);
switch (iParam1)
{
case 1:
if (Global_59870[iVar2] >= 0 && iParam3 > 0)
{
if (iVar5 <= 0)
{
Global_59870[iVar2] = 2147483647;
}
else
{
Global_59870[iVar2] = (Global_59870[iVar2] + iParam3);
}
}
switch (iParam0)
{
case 0:
func_254(joaat("sp0_total_cash_earned"), iParam3);
break;
case 1:
func_254(joaat("sp1_total_cash_earned"), iParam3);
break;
case 2:
func_254(joaat("sp2_total_cash_earned"), iParam3);
break;
}
break;
case 0:
if (!bParam4)
{
if ((Global_59870[iVar2] - iParam3) < 0)
{
return 0;
}
}
iVar3 = Global_59870[iVar2];
Global_59870[iVar2] = (Global_59870[iVar2] - iParam3);
if (bParam4)
{
iVar4 = iVar3;
}
break;
}
if (iParam2 == 1)
{
if (iVar4 > 20)
{
}
}
else
{
Global_112922.f_20564.f_233[iVar2 /*69*/].f_2[Global_112922.f_20564.f_233[iVar2 /*69*/].f_1 /*6*/] = iParam1;
Global_112922.f_20564.f_233[iVar2 /*69*/].f_2[Global_112922.f_20564.f_233[iVar2 /*69*/].f_1 /*6*/].f_1 = iParam2;
Global_112922.f_20564.f_233[iVar2 /*69*/].f_2[Global_112922.f_20564.f_233[iVar2 /*69*/].f_1 /*6*/].f_2 = iParam3;
Global_112922.f_20564.f_233[iVar2 /*69*/]++;
Global_112922.f_20564.f_233[iVar2 /*69*/].f_1++;
if (Global_112922.f_20564.f_233[iVar2 /*69*/].f_1 > 10)
{
Global_112922.f_20564.f_233[iVar2 /*69*/].f_1 = 0;
}
}
func_226(iParam0);
if (Global_42602 == 15)
{
func_225(0);
}
return 1;
}
void func_225(bool bParam0)
{
int iVar0;
int iVar1;
iVar0 = 0;
iVar1 = 0;
iVar0 = 0;
while (iVar0 < 3)
{
iVar1 = 0;
while (iVar1 < 11)
{
Global_112922.f_20564.f_233[iVar0 /*69*/].f_2[iVar1 /*6*/].f_3 = Global_112922.f_20564.f_233[iVar0 /*69*/].f_2[iVar1 /*6*/];
Global_112922.f_20564.f_233[iVar0 /*69*/].f_2[iVar1 /*6*/].f_4 = Global_112922.f_20564.f_233[iVar0 /*69*/].f_2[iVar1 /*6*/].f_1;
Global_112922.f_20564.f_233[iVar0 /*69*/].f_2[iVar1 /*6*/].f_5 = Global_112922.f_20564.f_233[iVar0 /*69*/].f_2[iVar1 /*6*/].f_2;
iVar1++;
}
iVar0++;
}
iVar0 = 0;
while (iVar0 < 10)
{
Global_59878[iVar0 /*3*/][0] = Global_112922.f_20564[iVar0];
Global_59878.f_31[iVar0 /*3*/][0] = Global_112922.f_20564.f_11[iVar0];
Global_59878.f_62[iVar0 /*3*/][0] = Global_112922.f_20564.f_22[iVar0];
Global_59878.f_93[iVar0 /*3*/][0] = Global_112922.f_20564.f_33[iVar0];
Global_59878.f_124[iVar0 /*3*/][0] = Global_112922.f_20564.f_44[iVar0];
Global_59878.f_155[iVar0 /*3*/][0] = Global_112922.f_20564.f_55[iVar0];
Global_59878.f_186[iVar0 /*3*/][0] = Global_112922.f_20564.f_66[iVar0];
Global_59878.f_217[iVar0 /*3*/][0] = Global_112922.f_20564.f_77[iVar0];
Global_59878.f_248[iVar0 /*3*/][0] = Global_112922.f_20564.f_88[iVar0];
if (!bParam0)
{
Global_59878[iVar0 /*3*/][1] = Global_112922.f_20564[iVar0];
Global_59878.f_31[iVar0 /*3*/][1] = Global_112922.f_20564.f_11[iVar0];
Global_59878.f_62[iVar0 /*3*/][1] = Global_112922.f_20564.f_22[iVar0];
Global_59878.f_93[iVar0 /*3*/][1] = Global_112922.f_20564.f_33[iVar0];
Global_59878.f_124[iVar0 /*3*/][1] = Global_112922.f_20564.f_44[iVar0];
Global_59878.f_155[iVar0 /*3*/][1] = Global_112922.f_20564.f_55[iVar0];
Global_59878.f_186[iVar0 /*3*/][1] = Global_112922.f_20564.f_66[iVar0];
Global_59878.f_217[iVar0 /*3*/][1] = Global_112922.f_20564.f_77[iVar0];
Global_59878.f_248[iVar0 /*3*/][1] = Global_112922.f_20564.f_88[iVar0];
}
iVar0++;
}
}
void func_226(int iParam0)
{
int iVar0;
iVar0 = Global_59870[iParam0];
switch (iParam0)
{
case 0:
STATS::STAT_SET_INT(joaat("sp0_total_cash"), iVar0, true);
break;
case 1:
STATS::STAT_SET_INT(joaat("sp1_total_cash"), iVar0, true);
break;
case 2:
STATS::STAT_SET_INT(joaat("sp2_total_cash"), iVar0, true);
break;
}
}
void func_227(bool bParam0)
{
bool bVar0;
char cVar1[64];
if (bParam0 == 8)
{
func_233(129, 0, -1);
return;
}
if (bParam0 == 9)
{
func_233(135, 0, -1);
return;
}
if (bParam0 == 10)
{
func_233(136, 0, -1);
return;
}
if (bParam0 == 11)
{
func_233(137, 0, -1);
return;
}
if (bParam0 == 12)
{
func_230(8271, 0, -1, 1, 0);
return;
}
if (bParam0 == 13)
{
func_230(8272, 0, -1, 1, 0);
return;
}
if (bParam0 == 14)
{
func_230(8273, 0, -1, 1, 0);
return;
}
if (bParam0 == 15)
{
func_230(8274, 0, -1, 1, 0);
return;
}
if (bParam0 == 16)
{
func_230(8275, 0, -1, 1, 0);
return;
}
if (bParam0 == 17)
{
func_230(8276, 0, -1, 1, 0);
return;
}
bVar0 = false;
if (!NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
if (BitTest(Global_112922.f_20564.f_471, bParam0))
{
bVar0 = true;
MISC::CLEAR_BIT(&(Global_112922.f_20564.f_471), bParam0);
}
}
else if (BitTest(Global_112922.f_20564.f_471, bParam0) || BitTest(Global_2359296[func_229() /*5559*/].f_675.f_10, bParam0))
{
bVar0 = true;
MISC::CLEAR_BIT(&(Global_112922.f_20564.f_471), bParam0);
MISC::CLEAR_BIT(&(Global_2359296[func_229() /*5559*/].f_675.f_10), bParam0);
}
if (bVar0)
{
StringCopy(&cVar1, "CHAR_LIFEINVADER", 64);
HUD::BEGIN_TEXT_COMMAND_THEFEED_POST("COUP_RED");
HUD::ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(func_228(bParam0));
HUD::END_TEXT_COMMAND_THEFEED_POST_MESSAGETEXT(&cVar1, &cVar1, true, 0, "", 0);
}
}
char* func_228(bool bParam0)
{
switch (bParam0)
{
case 0:
return "COUP_HAIRC";
case 1:
return "COUP_TATTOO";
case 2:
return "COUP_WARSTOCK";
case 3:
return "COUP_MOSPORT";
case 4:
return "COUP_ELITAS";
case 5:
return "COUP_MEDSPENS";
case 6:
return "COUP_SPRUNK";
case 7:
return "COUP_RESPRAY";
case 8:
return "COUP_XMAS2017";
case 9:
return "COUP_CAR_XMAS2018";
case 10:
return "COUP_HELI_XMAS2018";
case 11:
return "COUP_CAR2_XMAS2018";
case 12:
return "COUP_CAS_ELITAS";
case 13:
return "COUP_CAS_DOCKTEASE";
case 14:
return "COUP_CAS_MOSPORT";
case 15:
return "COUP_CAS_SSASA";
case 16:
return "COUP_CAS_WARSTOCK";
case 17:
return "COUP_CAS_PANDM";
break;
default:
break;
}
return "";
}
int func_229()
{
int iVar0;
iVar0 = 0;
return iVar0;
}
void func_230(int iParam0, int iParam1, int iParam2, bool bParam3, bool bParam4)
{
int iVar0;
if (bParam4)
{
}
iVar0 = Global_2822371[iParam0 /*3*/][func_231(iParam2)];
if (iVar0 != 0)
{
STATS::STAT_SET_INT(iVar0, iParam1, bParam3);
}
}
int func_231(var uParam0)
{
int iVar0;
int iVar1;
iVar0 = uParam0;
if (iVar0 == -1)
{
iVar1 = func_232();
if (iVar1 > -1)
{
Global_2822083 = 0;
iVar0 = iVar1;
}
else
{
iVar0 = 0;
Global_2822083 = 1;
}
}
return iVar0;
}
int func_232()
{
return Global_1574915;
}
void func_233(int iParam0, bool bParam1, int iParam2)
{
if (iParam2 == -1)
{
iParam2 = func_232();
}
STATS::_SET_PACKED_STAT_BOOL(iParam0, bParam1, iParam2);
}
void func_234(int iParam0)
{
func_363(93, iParam0);
func_363(29, iParam0);
func_363(30, iParam0);
}
int func_235(int iParam0)
{
int iVar0;
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
if (iParam0 == 8)
{
return func_237(129, -1);
}
if (iParam0 == 9)
{
return func_237(135, -1);
}
if (iParam0 == 10)
{
return func_237(136, -1);
}
if (iParam0 == 11)
{
return func_237(137, -1);
}
if (iParam0 == 12)
{
iVar0 = NETWORK::GET_CLOUD_TIME_AS_INT();
iVar1 = func_236(8271, -1, 0);
if (iVar1 == 0 || iVar0 >= iVar1)
{
return 0;
}
return 1;
}
if (iParam0 == 13)
{
iVar2 = NETWORK::GET_CLOUD_TIME_AS_INT();
iVar3 = func_236(8272, -1, 0);
if (iVar3 == 0 || iVar2 >= iVar3)
{
return 0;
}
return 1;
}
if (iParam0 == 14)
{
iVar4 = NETWORK::GET_CLOUD_TIME_AS_INT();
iVar5 = func_236(8273, -1, 0);
if (iVar5 == 0 || iVar4 >= iVar5)
{
return 0;
}
return 1;
}
if (iParam0 == 15)
{
iVar6 = NETWORK::GET_CLOUD_TIME_AS_INT();
iVar7 = func_236(8274, -1, 0);
if (iVar7 == 0 || iVar6 >= iVar7)
{
return 0;
}
return 1;
}
if (iParam0 == 16)
{
iVar8 = NETWORK::GET_CLOUD_TIME_AS_INT();
iVar9 = func_236(8275, -1, 0);
if (iVar9 == 0 || iVar8 >= iVar9)
{
return 0;
}
return 1;
}
if (iParam0 == 17)
{
iVar10 = NETWORK::GET_CLOUD_TIME_AS_INT();
iVar11 = func_236(8276, -1, 0);
if (iVar11 == 0 || iVar10 >= iVar11)
{
return 0;
}
return 1;
}
if (!NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
return BitTest(Global_112922.f_20564.f_471, iParam0);
}
return BitTest(Global_2359296[func_229() /*5559*/].f_675.f_10, iParam0);
}
int func_236(int iParam0, int iParam1, int iParam2)
{
int iVar0;
var uVar1;
if (iParam0 != 12581)
{
if (iParam2 == 0)
{
}
iVar0 = Global_2822371[iParam0 /*3*/][func_231(iParam1)];
if (STATS::STAT_GET_INT(iVar0, &uVar1, -1))
{
return uVar1;
}
}
return 0;
}
bool func_237(int iParam0, int iParam1)
{
if (iParam1 == -1)
{
iParam1 = func_232();
}
return STATS::_GET_PACKED_STAT_BOOL(iParam0, iParam1);
}
int func_238(bool bParam0)
{
int iVar0;
int iVar1;
int iVar2;
iVar1 = 0;
if (PLAYER::HAS_ACHIEVEMENT_BEEN_PASSED(27))
{
return 0;
}
if (STATS::STAT_GET_INT(joaat("sp0_money_total_spent"), &iVar0, -1))
{
iVar1 = (iVar1 + iVar0);
}
if (STATS::STAT_GET_INT(joaat("sp1_money_total_spent"), &iVar0, -1))
{
iVar1 = (iVar1 + iVar0);
}
if (STATS::STAT_GET_INT(joaat("sp2_money_total_spent"), &iVar0, -1))
{
iVar1 = (iVar1 + iVar0);
}
if (bParam0)
{
}
iVar2 = 0;
STATS::STAT_GET_INT(joaat("num_cash_spent"), &iVar2, -1);
if (iVar1 > 0 && (iVar2 / 2000000) != (iVar1 / 2000000))
{
STATS::STAT_SET_INT(joaat("num_cash_spent"), iVar1, true);
func_253(27, iVar1);
}
if (iVar1 < 200000000)
{
return 0;
}
func_239(27, 1);
return 1;
}
int func_239(int iParam0, int iParam1)
{
if (iParam0 >= 78)
{
return 0;
}
return func_240(iParam0, iParam1);
}
int func_240(int iParam0, int iParam1)
{
if (func_252(14) && !func_251(iParam0))
{
return 0;
}
if (PLAYER::HAS_ACHIEVEMENT_BEEN_PASSED(iParam0) && iParam1 == 1)
{
return 0;
}
if (Global_31761 != 0 && !Global_77858)
{
return 0;
}
if (func_250(&Global_4535627))
{
if (func_248(&Global_4535627, iParam0))
{
return 0;
}
if (func_241(&Global_4535627, iParam0))
{
return 1;
}
}
else
{
if (!PLAYER::GIVE_ACHIEVEMENT_TO_PLAYER(iParam0))
{
return 0;
}
if (PLAYER::HAS_ACHIEVEMENT_BEEN_PASSED(iParam0))
{
return 1;
}
return 0;
}
return 0;
}
int func_241(var uParam0, int iParam1)
{
int iVar0;
var uVar1[78];
if (PLAYER::HAS_ACHIEVEMENT_BEEN_PASSED(iParam1))
{
return 0;
}
if (func_252(14) && !func_251(iParam1))
{
return 0;
}
if (func_248(uParam0, iParam1))
{
return 0;
}
if (func_247(uParam0) < 0f)
{
func_246(uParam0, 0);
}
func_244(&uVar1);
iVar0 = 0;
iVar0 = 0;
while (iVar0 < (*uParam0 - 1))
{
uVar1[iVar0 + 1] = (*uParam0)[iVar0];
iVar0++;
}
func_242(&uVar1, iParam1);
iVar0 = 0;
iVar0 = 0;
while (iVar0 < *uParam0)
{
(*uParam0)[iVar0] = uVar1[iVar0];
iVar0++;
}
return 1;
}
int func_242(var uParam0, int iParam1)
{
int iVar0;
if (PLAYER::HAS_ACHIEVEMENT_BEEN_PASSED(iParam1))
{
return 0;
}
if (func_252(14) && !func_251(iParam1))
{
return 0;
}
if (func_248(uParam0, iParam1))
{
return 0;
}
if (func_247(uParam0) < 0f)
{
func_246(uParam0, 0);
}
iVar0 = 0;
while (iVar0 < *uParam0)
{
if (func_243(uParam0, iVar0))
{
(*uParam0)[iVar0] = iParam1;
return 1;
}
iVar0++;
}
return 0;
}
bool func_243(var uParam0, int iParam1)
{
return (*uParam0)[iParam1] == 78;
}
void func_244(var uParam0)
{
int iVar0;
iVar0 = 0;
while (iVar0 < *uParam0)
{
func_245(uParam0, iVar0);
iVar0++;
}
func_246(uParam0, (Global_4535626 - 0.5f));
}
void func_245(var uParam0, int iParam1)
{
(*uParam0)[iParam1] = 78;
}
void func_246(var uParam0, float fParam1)
{
if (fParam1 == 0f)
{
uParam0->f_80 = 0f;
}
else
{
uParam0->f_80 = fParam1;
}
}
float func_247(var uParam0)
{
return uParam0->f_80;
}
bool func_248(var uParam0, int iParam1)
{
return func_249(uParam0, iParam1) != -1;
}
int func_249(var uParam0, int iParam1)
{
int iVar0;
iVar0 = 0;
while (iVar0 < *uParam0)
{
if ((*uParam0)[iVar0] == iParam1)
{
return iVar0;
}
iVar0++;
}
return -1;
}
bool func_250(var uParam0)
{
return uParam0->f_79 == 1;
}
int func_251(int iParam0)
{
switch (iParam0)
{
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
case 69:
return 1;
default:
}
return 0;
}
bool func_252(int iParam0)
{
return Global_42602 == iParam0;
}
int func_253(int iParam0, int iParam1)
{
int iVar0;
if (iParam0 < 0)
{
return 0;
}
if (iParam0 > 78)
{
return 0;
}
if (iParam1 <= 0 || iParam1 > 100)
{
return 0;
}
iVar0 = PLAYER::_GET_ACHIEVEMENT_PROGRESS(iParam0);
if (iParam1 > iVar0)
{
return PLAYER::_SET_ACHIEVEMENT_PROGRESS(iParam0, iParam1);
}
return 0;
}
void func_254(int iParam0, int iParam1)
{
int iVar0;
STATS::STAT_GET_INT(iParam0, &iVar0, -1);
iVar0 = (iVar0 + iParam1);
STATS::STAT_SET_INT(iParam0, iVar0, true);
}
void func_255()
{
int iVar0;
if (NETWORK::NETWORK_IS_SIGNED_IN())
{
STATS::STAT_GET_INT(joaat("sp0_total_cash"), &iVar0, -1);
if (!Global_59870[0] == iVar0)
{
Global_59870[0] = iVar0;
}
STATS::STAT_GET_INT(joaat("sp1_total_cash"), &iVar0, -1);
if (!Global_59870[1] == iVar0)
{
Global_59870[1] = iVar0;
}
STATS::STAT_GET_INT(joaat("sp2_total_cash"), &iVar0, -1);
if (!Global_59870[2] == iVar0)
{
Global_59870[2] = iVar0;
}
}
}
int func_256(int iParam0)
{
return Global_1918[iParam0 /*29*/].f_17;
}
void func_257(int iParam0, int iParam1, int iParam2)
{
bool bVar0;
if (iParam0 < 0)
{
}
if (iParam0 == 321 || iParam0 > 321)
{
}
else
{
func_233((891 + iParam0), 1, -1);
}
bVar0 = true;
if (Global_112922.f_10194[iParam0 /*12*/].f_5 == 1)
{
if (Global_112922.f_10194[iParam0 /*12*/].f_6 == 11 || Global_112922.f_10194[iParam0 /*12*/].f_6 == 12)
{
bVar0 = false;
}
}
else
{
Global_112922.f_10194[iParam0 /*12*/].f_5 = 1;
Global_112922.f_10194[iParam0 /*12*/].f_10 = iParam1;
Global_112922.f_10194[iParam0 /*12*/].f_11 = iParam2;
if (iParam0 == 287)
{
STATS::PRESENCE_EVENT_UPDATESTAT_INT(joaat("num_hidden_packages_0"), 50, 0);
}
if (iParam0 == 286)
{
STATS::PRESENCE_EVENT_UPDATESTAT_INT(joaat("num_hidden_packages_1"), 50, 0);
}
if (iParam0 == 299)
{
STATS::PRESENCE_EVENT_UPDATESTAT_INT(joaat("num_hidden_packages_3"), 50, 0);
}
}
if (bVar0)
{
func_258();
}
}
void func_258()
{
int iVar0;
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
int iVar9;
iVar0 = 0;
Global_112658 = 0;
Global_112659 = 0;
Global_112660 = 0;
Global_112661 = 0;
Global_112662 = 0;
Global_112663 = 0;
Global_112664 = 0;
fVar1 = 0f;
fVar2 = 0f;
fVar3 = 0f;
fVar4 = 0f;
fVar5 = 0f;
fVar6 = 0f;
fVar7 = 0f;
fVar8 = Global_112922.f_10194.f_3853;
Global_112922.f_10194.f_3853 = 0f;
while (iVar0 < 321)
{
if (Global_112922.f_10194[iVar0 /*12*/].f_5 == 1)
{
switch (Global_112922.f_10194[iVar0 /*12*/].f_6)
{
case 1:
Global_112658++;
fVar1 = (fVar1 + Global_112922.f_10194[iVar0 /*12*/].f_4);
break;
case 3:
Global_112659++;
fVar2 = (fVar2 + Global_112922.f_10194[iVar0 /*12*/].f_4);
break;
case 5:
Global_112660++;
fVar3 = (fVar3 + Global_112922.f_10194[iVar0 /*12*/].f_4);
break;
case 7:
Global_112661++;
fVar4 = (fVar4 + Global_112922.f_10194[iVar0 /*12*/].f_4);
break;
case 9:
Global_112662++;
fVar5 = (fVar5 + (Global_112922.f_10194[iVar0 /*12*/].f_4 * 4f));
break;
case 11:
Global_112663++;
fVar6 = (fVar6 + Global_112922.f_10194[iVar0 /*12*/].f_4);
break;
case 13:
Global_112664++;
fVar7 = (fVar7 + Global_112922.f_10194[iVar0 /*12*/].f_4);
break;
default:
break;
}
}
iVar0++;
}
if (Global_112641 > 0)
{
if (Global_112658 == Global_112641)
{
fVar1 = 55f;
}
}
if (Global_112642 > 0)
{
if (Global_112659 == Global_112642)
{
fVar2 = 10f;
}
}
if (Global_112643 > 0)
{
if (Global_112660 == Global_112643)
{
fVar3 = 0f;
}
}
if (Global_112644 > 0)
{
if (Global_112661 == Global_112644)
{
fVar4 = 10f;
}
}
if (Global_112645 > 0)
{
if (((Global_112662 == Global_112645 || (Global_112645 * 10 / Global_112662) < 41) || Global_112662 > Global_112648) || Global_112662 == Global_112648)
{
if (!BitTest(Global_112922.f_10194.f_3856, 14))
{
if (Global_112662 == Global_112645)
{
STATS::PRESENCE_EVENT_UPDATESTAT_INT(joaat("num_rndevents_completed"), Global_112645, 0);
MISC::SET_BIT(&(Global_112922.f_10194.f_3856), 14);
}
}
fVar5 = 5f;
}
}
if (Global_112646 > 0)
{
if (Global_112663 == Global_112646)
{
fVar6 = 15f;
}
}
if (Global_112647 > 0)
{
if (Global_112664 == Global_112647)
{
fVar7 = 5f;
}
}
Global_112922.f_10194.f_3853 = ((((((fVar1 + fVar2) + fVar3) + fVar4) + fVar5) + fVar6) + fVar7);
if (Global_112662 > Global_112648 || Global_112662 == Global_112648)
{
iVar9 = Global_112648;
}
else
{
iVar9 = Global_112662;
}
STATS::STAT_SET_INT(joaat("num_missions_completed"), Global_112658, true);
STATS::STAT_SET_INT(joaat("num_missions_available"), Global_112641, true);
STATS::STAT_SET_INT(joaat("num_minigames_completed"), Global_112659, true);
STATS::STAT_SET_INT(joaat("num_minigames_available"), Global_112642, true);
STATS::STAT_SET_INT(joaat("num_oddjobs_completed"), Global_112660, true);
STATS::STAT_SET_INT(joaat("num_oddjobs_available"), Global_112643, true);
STATS::STAT_SET_INT(joaat("num_rndpeople_completed"), Global_112661, true);
STATS::STAT_SET_INT(joaat("num_rndpeople_available"), Global_112644, true);
STATS::STAT_SET_INT(joaat("num_rndevents_completed"), iVar9, true);
STATS::STAT_SET_INT(joaat("num_rndevents_available"), Global_112648, true);
STATS::STAT_SET_INT(joaat("num_misc_completed"), (Global_112664 + Global_112663), true);
STATS::STAT_SET_INT(joaat("num_misc_available"), (Global_112647 + Global_112646), true);
Global_112665 = (Global_112658 * 100 / Global_112641);
Global_112667 = ((Global_112660 + Global_112659) * 100 / (Global_112643 + Global_112642));
Global_112666 = ((Global_112661 + iVar9) * 100 / (Global_112644 + Global_112648));
Global_112668 = ((Global_112663 + Global_112664) * 100 / (Global_112646 + Global_112647));
STATS::STAT_SET_FLOAT(joaat("total_progress_made"), Global_112922.f_10194.f_3853, true);
STATS::STAT_SET_INT(joaat("percent_story_missions"), Global_112665, true);
STATS::STAT_SET_INT(joaat("percent_ambient_missions"), Global_112666, true);
STATS::STAT_SET_INT(joaat("percent_oddjobs"), Global_112667, true);
if (fVar8 > 0f && SYSTEM::FLOOR(fVar8) < SYSTEM::FLOOR(Global_112922.f_10194.f_3853))
{
func_253(13, SYSTEM::FLOOR(Global_112922.f_10194.f_3853));
}
if (!DATAFILE::DATAFILE_IS_SAVE_PENDING())
{
if (!Global_77858)
{
if (func_259() == 2 == 0 && !NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
if (NETWORK::NETWORK_IS_CLOUD_AVAILABLE())
{
Global_112656 = 0;
}
if (!Global_62696)
{
func_219();
}
}
}
}
}
int func_259()
{
return Global_31511;
}
void func_260(int iParam0, int iParam1)
{
if (iParam0 == 146 || iParam0 == -1)
{
return;
}
if (Global_112922.f_9085.f_99.f_58[iParam0] == iParam1)
{
return;
}
Global_112922.f_9085.f_99.f_58[iParam0] = iParam1;
}
int func_261(int iParam0)
{
if (iParam0 == 146 || iParam0 == -1)
{
return 0;
}
return Global_112922.f_9085.f_99.f_58[iParam0];
}
void func_262(int iParam0, bool bParam1)
{
int iVar0;
iVar0 = iParam0;
if ((iVar0 < 0 || iVar0 >= 263) || iParam0 == 263)
{
return;
}
if (bParam1 == BitTest(Global_31890[iVar0 /*23*/].f_11, 20))
{
return;
}
if (bParam1)
{
MISC::SET_BIT(&(Global_31890[iVar0 /*23*/].f_11), 20);
}
else
{
MISC::CLEAR_BIT(&(Global_31890[iVar0 /*23*/].f_11), 20);
}
if (Global_31887 == 1)
{
Global_31888 = 1;
}
Global_31887 = 1;
MISC::SET_BIT(&(Global_31890[iVar0 /*23*/].f_11), 20);
}
bool func_263(int* iParam0, int iParam1)
{
return BitTest(iParam0->f_607, iParam1);
}
int func_264()
{
return GRAPHICS::REQUEST_SCALEFORM_MOVIE("MP_BIG_MESSAGE_FREEMODE");
}
void func_265(struct<3> Param0, int iParam3, int iParam4, int iParam5, var uParam6, float fParam7)
{
int iVar0;
int iVar1;
bool bVar2;
int iVar3;
int iVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
bool bVar12;
struct<3> Var13;
struct<3> Var16;
float fVar19;
int iVar20;
struct<3> Var21;
struct<3> Var24;
iVar0 = PLAYER::PLAYER_PED_ID();
iVar1 = 0;
bVar2 = PED::IS_PED_INJURED(iVar0);
if (bVar2)
{
*iParam5 = 2;
return;
}
iVar3 = PED::GET_PED_PARACHUTE_STATE(iVar0);
iVar4 = PED::GET_PED_PARACHUTE_LANDING_TYPE(iVar0);
bVar5 = ENTITY::IS_ENTITY_IN_AIR(iVar0);
bVar6 = PED::IS_PED_RAGDOLL(iVar0);
bVar7 = ENTITY::DOES_ENTITY_EXIST(iParam3);
bVar8 = (bVar7 && PED::IS_PED_ON_SPECIFIC_VEHICLE(iVar0, iParam3));
bVar9 = ((bVar7 && !PED::IS_PED_INJURED(iParam4)) && ENTITY::IS_ENTITY_TOUCHING_ENTITY(iVar0, iParam4));
bVar10 = (bVar7 && VEHICLE::GET_VEHICLE_TRAILER_VEHICLE(iParam3, &iVar1));
bVar11 = ((bVar10 && !ENTITY::IS_ENTITY_DEAD(iVar1, false)) && PED::IS_PED_ON_SPECIFIC_VEHICLE(iVar0, iVar1));
bVar12 = (!bVar7 && !func_431(Param0));
if (bVar12)
{
Var13 = { ENTITY::GET_ENTITY_COORDS(iVar0, true) };
Var16 = { Var13 - Param0 };
fVar19 = SYSTEM::SQRT(((Var16.f_0 * Var16.f_0) + (Var16.f_1 * Var16.f_1)));
*fParam7 = fVar19;
if ((Var16.f_2 < 5f && Var16.f_2 > -2f) && fVar19 < 15f)
{
*uParam6 = func_268(SYSTEM::CEIL(((100f * (15f - fVar19)) / 15f)) + 4, 0, 100);
*iParam5 = 1;
}
else
{
*iParam5 = 3;
}
}
if (bVar7)
{
if (func_266(iParam3, iParam4))
{
*fParam7 = 0f;
*uParam6 = 100;
*iParam5 = 1;
}
else
{
*uParam6 = 0;
*iParam5 = 3;
}
}
if (bVar10)
{
VEHICLE::GET_VEHICLE_TRAILER_VEHICLE(iParam3, &iVar20);
Var21 = { ENTITY::GET_ENTITY_COORDS(iVar0, true) };
Var24 = { ENTITY::GET_ENTITY_COORDS(iVar20, true) };
}
}
int func_266(int iParam0, int iParam1)
{
int iVar0;
int iVar1;
struct<3> Var2;
struct<3> Var5;
int iVar8;
struct<3> Var9;
if ((!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()) && ENTITY::DOES_ENTITY_EXIST(iParam0)) && VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false))
{
Var5 = { ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true) };
if (func_367(ENTITY::GET_ENTITY_MODEL(iParam0)))
{
iVar8 = 0;
iVar8 = 0;
while (iVar8 < 6)
{
iVar1 = VEHICLE::GET_TRAIN_CARRIAGE(iParam0, iVar8);
if (ENTITY::DOES_ENTITY_EXIST(iVar1))
{
Var2 = { ENTITY::GET_ENTITY_COORDS(iParam0, true) };
if (PED::IS_PED_ON_SPECIFIC_VEHICLE(PLAYER::PLAYER_PED_ID(), iVar1))
{
return 1;
}
}
iVar8++;
}
}
if (ENTITY::DOES_ENTITY_EXIST(iParam0))
{
VEHICLE::GET_VEHICLE_TRAILER_VEHICLE(iParam0, &iVar0);
if ((PED::IS_PED_ON_SPECIFIC_VEHICLE(PLAYER::PLAYER_PED_ID(), iParam0) || ENTITY::IS_ENTITY_TOUCHING_ENTITY(PLAYER::PLAYER_PED_ID(), iParam0)) || ((ENTITY::DOES_ENTITY_EXIST(iParam1) && !ENTITY::IS_ENTITY_DEAD(iParam1, false)) && ENTITY::IS_ENTITY_TOUCHING_ENTITY(PLAYER::PLAYER_PED_ID(), iParam1)))
{
if (Var2.f_2 < Var5.f_2)
{
return 1;
}
}
}
if (ENTITY::DOES_ENTITY_EXIST(iVar0))
{
if (!ENTITY::IS_ENTITY_DEAD(iVar0, false))
{
if (PED::IS_PED_ON_SPECIFIC_VEHICLE(PLAYER::PLAYER_PED_ID(), iVar0))
{
return 1;
}
else if (ENTITY::IS_ENTITY_TOUCHING_ENTITY(PLAYER::PLAYER_PED_ID(), iVar0))
{
Var9 = { ENTITY::GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(iVar0, ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true)) };
Var9.f_0 = func_267((MISC::ABSF(Var9.f_0) - 1.305f), 0f);
if (Var9.f_1 >= 0f)
{
Var9.f_1 = func_267((Var9.f_1 - 5.98f), 0f);
}
else
{
Var9.f_1 = func_267((-Var9.f_1 - 6.21f), 0f);
}
if (Var9.f_1 == 0f && Var9.f_0 == 0f)
{
return 1;
}
}
}
}
}
return 0;
}
float func_267(float fParam0, float fParam1)
{
if (fParam0 > fParam1)
{
return fParam0;
}
return fParam1;
}
int func_268(int iParam0, int iParam1, int iParam2)
{
if (iParam0 > iParam2)
{
return iParam2;
}
else if (iParam0 < iParam1)
{
return iParam1;
}
return iParam0;
}
void func_269(struct<3> Param0, int* iParam3, var uParam4, var uParam5)
{
float fVar0;
int iVar1;
if (!func_462(&iParam3))
{
return;
}
fVar0 = func_461(&iParam3);
if (fVar0 > 1.4f)
{
return;
}
iVar1 = (170 - SYSTEM::CEIL(((170f * fVar0) / 1.4f)));
GRAPHICS::DRAW_MARKER(6, Param0, 0f, 0f, 1f, 0f, 0f, 0f, 4f, 4f, 4f, 240, 200, 80, iVar1, false, false, 2, false, 0, 0, false);
GRAPHICS::DRAW_MARKER(6, Param0, 0f, 0f, 1f, 0f, 0f, 0f, 9f, 9f, 9f, 240, 200, 80, iVar1, false, false, 2, false, 0, 0, false);
GRAPHICS::DRAW_MARKER(6, Param0, 0f, 0f, 1f, 0f, 0f, 0f, 14f, 14f, 14f, 240, 200, 80, iVar1, false, false, 2, false, 0, 0, false);
}
void func_270(int* iParam0, var uParam1, bool bParam2, int iParam3)
{
int iVar0;
iVar0 = func_368(uParam1);
if (func_465(func_466(bParam2)))
{
if (!func_263(iParam0, 0))
{
if (iParam3 > 1)
{
func_340("BJ_MG_MTOBJ", 7500, 1);
}
else if (iVar0 != 0)
{
if (func_367(iVar0))
{
func_340("BJ_MG_TRAIN", 7500, 1);
}
else
{
func_340("BJ_MG_BOAT", 7500, 1);
}
}
else
{
func_340("BJ_MG_STOBJ", 7500, 1);
}
func_221(iParam0, 0, 1);
}
}
if (func_337("BJ_FALLHLP") && Global_22691.f_135)
{
HUD::CLEAR_HELP(true);
func_221(iParam0, 1, 0);
}
if (!func_263(iParam0, 1) && !Global_22691.f_135)
{
HUD::ADD_NEXT_MESSAGE_TO_PREVIOUS_BRIEFS(false);
HUD::CLEAR_HELP(true);
func_338("BJ_FALLHLP", -1);
func_221(iParam0, 1, 1);
}
else if (!func_263(iParam0, 2))
{
if (PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == 1 || PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == 2)
{
HUD::CLEAR_HELP(true);
if (PAD::_IS_USING_KEYBOARD(0))
{
func_338("BJ_PARAHLP_KM", 10000);
}
else
{
func_338("BJ_PARAHLP", 10000);
}
func_221(iParam0, 2, 1);
}
}
else if (!func_263(iParam0, 3))
{
if (PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == -1 || PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == 3)
{
HUD::CLEAR_HELP(true);
func_221(iParam0, 3, 1);
}
}
}
void func_271(int iParam0)
{
struct<3> Var0;
struct<3> Var3;
struct<3> Var6;
struct<3> Var9;
struct<3> Var12;
var uVar15;
struct<3> Var18;
float fVar21;
float fVar22;
float fVar23;
float fVar24;
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
if (ENTITY::DOES_ENTITY_EXIST(ENTITY::GET_ENTITY_ATTACHED_TO(PLAYER::PLAYER_PED_ID())))
{
Var0 = { ENTITY::GET_ENTITY_SPEED_VECTOR(ENTITY::GET_ENTITY_ATTACHED_TO(PLAYER::PLAYER_PED_ID()), false) };
}
else
{
Var0 = { ENTITY::GET_ENTITY_SPEED_VECTOR(PLAYER::PLAYER_PED_ID(), true) };
}
fVar21 = Var0.f_1;
Var3 = { ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true) };
Var3.f_2 = 0f;
}
if (ENTITY::DOES_ENTITY_EXIST(*iParam0) && VEHICLE::IS_VEHICLE_DRIVEABLE(*iParam0, false))
{
Var6 = { ENTITY::GET_ENTITY_COORDS(*iParam0, true) };
Var6.f_2 = 0f;
Var18 = { ENTITY::GET_ENTITY_VELOCITY(*iParam0) };
}
if (VEHICLE::IS_VEHICLE_DRIVEABLE(*iParam0, false))
{
ENTITY::GET_ENTITY_MATRIX(*iParam0, &Var9, &uVar15, &uVar15, &uVar15);
Var9.f_2 = 0f;
}
Var12 = { Var3 - Var6 };
Var12.f_2 = 0f;
fVar23 = MISC::ABSF(func_275(Var12, Var9));
if (func_274(*iParam0))
{
fVar22 = func_49((fVar21 - (fVar23 / fVar21)), 2f, 3f);
}
else
{
fVar22 = func_49((fVar21 + (fVar23 / fVar21)), 3f, 10f);
}
fVar24 = func_49(func_272(Var18.f_1, fVar22, 0.5f), Var18.f_1, fVar21);
Var18.f_1 = func_272(Var18.f_1, fVar22, 0.5f);
if (((ENTITY::DOES_ENTITY_EXIST(*iParam0) && VEHICLE::IS_VEHICLE_DRIVEABLE(*iParam0, false)) && Var18.f_1 > 2f) && Var18.f_1 < VEHICLE::GET_VEHICLE_ESTIMATED_MAX_SPEED(*iParam0))
{
TASK::SET_DRIVE_TASK_MAX_CRUISE_SPEED(VEHICLE::GET_PED_IN_VEHICLE_SEAT(*iParam0, -1, false), fVar24);
}
}
float func_272(float fParam0, float fParam1, float fParam2)
{
float fVar0;
fVar0 = ((1f - SYSTEM::COS(func_273((fParam2 * 3.141593f)))) * 0.5f);
return ((fParam0 * (1f - fVar0)) + (fParam1 * fVar0));
}
float func_273(float fParam0)
{
return (fParam0 * 57.29578f);
}
int func_274(int iParam0)
{
struct<3> Var0;
struct<3> Var3;
var uVar6;
struct<3> Var9;
struct<3> Var12;
float fVar15;
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
Var0 = { ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true) };
}
if (VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false))
{
ENTITY::GET_ENTITY_MATRIX(iParam0, &Var12, &uVar6, &uVar6, &Var3);
}
Var9 = { Var0 - Var3 };
Var9.f_2 = 0f;
Var12.f_2 = 0f;
fVar15 = func_275(Var9, Var12);
if (fVar15 < 0f)
{
return 1;
}
return 0;
}
float func_275(struct<3> Param0, struct<3> Param3)
{
return (((Param0.f_0 * Param3.f_0) + (Param0.f_1 * Param3.f_1)) + (Param0.f_2 * Param3.f_2));
}
float func_276(int iParam0, int iParam1, bool bParam2)
{
struct<3> Var0;
struct<3> Var3;
if (!ENTITY::IS_ENTITY_DEAD(iParam0, false))
{
Var0 = { ENTITY::GET_ENTITY_COORDS(iParam0, true) };
}
else
{
Var0 = { ENTITY::GET_ENTITY_COORDS(iParam0, false) };
}
if (!ENTITY::IS_ENTITY_DEAD(iParam1, false))
{
Var3 = { ENTITY::GET_ENTITY_COORDS(iParam1, true) };
}
else
{
Var3 = { ENTITY::GET_ENTITY_COORDS(iParam1, false) };
}
return MISC::GET_DISTANCE_BETWEEN_COORDS(Var0, Var3, bParam2);
}
Vector3 func_277(int iParam0, struct<3> Param1)
{
var uVar0;
Param1.f_2 = (Param1.f_2 + 0.15f);
if (MISC::GET_GROUND_Z_FOR_3D_COORD(Param1, &uVar0, false, false))
{
Param1.f_2 = uVar0;
}
if (func_278(iParam0))
{
ENTITY::SET_ENTITY_COORDS(iParam0, Param1, true, false, false, true);
}
return Param1;
}
bool func_278(int iParam0)
{
if (!ENTITY::DOES_ENTITY_EXIST(iParam0))
{
return 0;
}
return !ENTITY::IS_ENTITY_DEAD(iParam0, false);
}
void func_279(int* iParam0, var uParam1)
{
var uVar0[6];
int iVar7;
struct<3> Var8;
float fVar11;
int iVar12;
int iVar13;
int iVar14;
bool bVar15;
if (!func_462(iParam0))
{
func_486(iParam0);
}
if (func_461(iParam0) < 1f)
{
return;
}
if (ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
return;
}
iVar12 = PED::GET_PED_NEARBY_PEDS(PLAYER::PLAYER_PED_ID(), &uVar0, -1);
iVar13 = 0;
while (iVar13 < 6)
{
if ((ENTITY::DOES_ENTITY_EXIST((*uParam1)[iVar13]) && !ENTITY::IS_ENTITY_DEAD((*uParam1)[iVar13], false)) && !PED::IS_PED_INJURED((*uParam1)[iVar13]))
{
if (func_281((*uParam1)[iVar13], &uVar0) == -1)
{
func_280(uParam1[iVar13]);
}
else
{
Var8 = { ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true) - ENTITY::GET_ENTITY_COORDS((*uParam1)[iVar13], true) };
fVar11 = ((Var8.f_0 * Var8.f_0) + (Var8.f_1 * Var8.f_1));
if (Var8.f_2 * Var8.f_2) < (3f * fVar11)
{
func_280(uParam1[iVar13]);
}
}
}
iVar13++;
}
if (iVar12 > 0)
{
iVar13 = 0;
while (iVar13 < iVar12)
{
if ((((ENTITY::DOES_ENTITY_EXIST(uVar0[iVar13]) && !ENTITY::IS_ENTITY_DEAD(uVar0[iVar13], false)) && !PED::IS_PED_INJURED(uVar0[iVar13])) && PED::IS_PED_HUMAN(uVar0[iVar13])) && !PED::IS_PED_IN_ANY_VEHICLE(uVar0[iVar13], true))
{
if (func_281(uVar0[iVar13], uParam1) == -1)
{
Var8 = { ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true) - ENTITY::GET_ENTITY_COORDS(uVar0[iVar13], true) };
fVar11 = ((Var8.f_0 * Var8.f_0) + (Var8.f_1 * Var8.f_1));
if (Var8.f_2 * Var8.f_2) > (3f * fVar11)
{
bVar15 = false;
iVar14 = 0;
while (iVar14 < *uParam1)
{
if (!ENTITY::DOES_ENTITY_EXIST((*uParam1)[iVar14]) || PED::IS_PED_INJURED((*uParam1)[iVar14]))
{
(*uParam1)[iVar14] = uVar0[iVar13];
TASK::OPEN_SEQUENCE_TASK(&iVar7);
TASK::TASK_PLAY_ANIM(0, "oddjobs@basejump@", "ped_a_intro", 8f, -8f, -1, 0, 0f, false, false, false);
TASK::TASK_PLAY_ANIM(0, "oddjobs@basejump@", "ped_a_loop", 8f, -8f, -1, 1, 0f, false, false, false);
TASK::CLOSE_SEQUENCE_TASK(iVar7);
TASK::TASK_PERFORM_SEQUENCE(uVar0[iVar13], iVar7);
TASK::CLEAR_SEQUENCE_TASK(&iVar7);
iVar14 = *uParam1;
bVar15 = true;
}
iVar14++;
}
if (!bVar15)
{
return;
}
}
}
}
iVar13++;
}
}
}
void func_280(var uParam0)
{
TASK::CLEAR_PED_TASKS(*uParam0);
TASK::TASK_PLAY_ANIM(*uParam0, "oddjobs@basejump@", "ped_a_exit", 8f, -8f, -1, 0, 0f, false, false, false);
*uParam0 = 0;
}
int func_281(int iParam0, var uParam1)
{
int iVar0;
if (ENTITY::DOES_ENTITY_EXIST(iParam0))
{
iVar0 = 0;
iVar0 = 0;
while (iVar0 < *uParam1)
{
if (ENTITY::DOES_ENTITY_EXIST((*uParam1)[iVar0]))
{
if (iParam0 == (*uParam1)[iVar0])
{
return iVar0;
}
}
iVar0++;
}
}
return -1;
}
void func_282(var uParam0, var uParam1, int* iParam2, var uParam3, int* iParam4, int iParam5, int iParam6, int* iParam7, int* iParam8, int* iParam9, int iParam10, int iParam11, int iParam12, int iParam13, int iParam14, int iParam15, int iParam16, int iParam17, int iParam18, int iParam19, bool bParam20, int iParam21, int iParam22, int* iParam23, int* iParam24, var uParam25, var uParam26, var uParam27, var uParam28, var uParam29, bool bParam30, bool bParam31, bool bParam32, bool bParam33, bool bParam34, int iParam35, int iParam36)
{
int iVar0;
int iVar1;
int iVar2;
int iVar3;
int iVar4;
VEHICLE::REMOVE_VEHICLE_COMBAT_AVOIDANCE_AREA(*iParam36);
func_376();
func_375();
func_496();
func_44(&(iParam2->f_26), 0);
*iParam19 = 0;
*iParam21 = 0;
*uParam25 = { 0f, 0f, 0f };
*iParam22 = -1;
*uParam29 = 0;
*bParam30 = 0;
func_327(iParam2);
if (func_462(iParam24))
{
func_458(iParam24);
}
if (func_462(iParam23))
{
func_458(iParam23);
}
if (ENTITY::DOES_ENTITY_EXIST(*iParam7))
{
if (func_367(func_368(uParam0)))
{
VEHICLE::DELETE_MISSION_TRAIN(iParam7);
}
else
{
if (!ENTITY::IS_ENTITY_DEAD(*iParam7, false))
{
iVar1 = VEHICLE::GET_PED_IN_VEHICLE_SEAT(*iParam7, -1, false);
if (ENTITY::DOES_ENTITY_EXIST(iVar1))
{
PED::DELETE_PED(&iVar1);
}
}
VEHICLE::DELETE_VEHICLE(iParam7);
}
}
iVar2 = 0;
while (iVar2 < *iParam5)
{
if (ENTITY::DOES_ENTITY_EXIST((*iParam5)[iVar2]) && !ENTITY::IS_ENTITY_DEAD((*iParam5)[iVar2], false))
{
TASK::CLEAR_PED_TASKS((*iParam5)[iVar2]);
(*iParam5)[iVar2] = 0;
}
iVar2++;
}
if (ENTITY::DOES_ENTITY_EXIST(*iParam8))
{
VEHICLE::DELETE_VEHICLE(iParam8);
}
if (ENTITY::DOES_ENTITY_EXIST(*iParam9))
{
if (!func_326(*iParam9) && ENTITY::DOES_ENTITY_EXIST(VEHICLE::GET_PED_IN_VEHICLE_SEAT(*iParam9, -1, false)))
{
iVar3 = VEHICLE::GET_PED_IN_VEHICLE_SEAT(*iParam9, -1, false);
PED::DELETE_PED(&iVar3);
}
VEHICLE::DELETE_VEHICLE(iParam9);
}
if (!ENTITY::IS_ENTITY_DEAD(*iParam4, false))
{
ENTITY::SET_PED_AS_NO_LONGER_NEEDED(iParam4);
}
if (PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), true))
{
iVar0 = PED::GET_VEHICLE_PED_IS_USING(PLAYER::PLAYER_PED_ID());
if (ENTITY::DOES_ENTITY_EXIST(iVar0))
{
PED::_0xF9ACF4A08098EA25(PLAYER::PLAYER_PED_ID(), true);
ENTITY::SET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), ENTITY::GET_ENTITY_COORDS(iVar0, true) + Vector(0f, 0f, 2f), true, false, false, true);
if (ENTITY::DOES_ENTITY_EXIST(*iParam6) && iVar0 == *iParam6)
{
VEHICLE::SET_PLAYERS_LAST_VEHICLE(*iParam6);
func_286(*iParam6, func_325(bParam20), func_324(bParam20), 24, 0);
ENTITY::SET_ENTITY_VELOCITY(iVar0, 0f, 0f, 0f);
ENTITY::SET_ENTITY_COORDS(iVar0, func_325(bParam20), true, false, false, true);
VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(iVar0, 5f);
ENTITY::SET_ENTITY_HEADING(iVar0, func_324(bParam20));
}
else
{
if (!ENTITY::IS_ENTITY_A_MISSION_ENTITY(iVar0))
{
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(iVar0, true, false);
}
VEHICLE::DELETE_VEHICLE(&iVar0);
}
}
}
*iParam15 = 0;
*iParam17 = 0;
*iParam18 = 1;
*uParam26 = 0f;
*uParam27 = 0f;
*uParam28 = 0f;
*bParam31 = 0;
*bParam32 = 0;
*bParam33 = 0;
*bParam34 = 0;
*iParam35 = 0;
if (*iParam16 > -1)
{
GRAPHICS::DELETE_CHECKPOINT(*iParam11);
GRAPHICS::DELETE_CHECKPOINT(*iParam12);
*iParam16 = -1;
}
if (HUD::DOES_BLIP_EXIST(iParam13))
{
HUD::REMOVE_BLIP(&iParam13);
}
if (HUD::DOES_BLIP_EXIST(iParam14))
{
HUD::REMOVE_BLIP(&iParam14);
}
iVar4 = 0;
while (iVar4 < *iParam10)
{
if (ENTITY::DOES_ENTITY_EXIST((*iParam10)[iVar4]) && !ENTITY::IS_ENTITY_DEAD((*iParam10)[iVar4], false))
{
VEHICLE::SET_VEHICLE_LOD_MULTIPLIER((*iParam10)[iVar4], 1f);
ENTITY::SET_ENTITY_LOAD_COLLISION_FLAG((*iParam10)[iVar4], false, 1);
}
(*iParam10)[iVar4] = 0;
iVar4++;
}
func_285(iParam2);
*uParam3 = 0;
func_284();
func_283();
CAM::DO_SCREEN_FADE_OUT(800);
}
void func_283()
{
Global_31656 = 1;
}
void func_284()
{
int iVar0;
Local_68.f_66 = -1;
Local_68.f_67 = 10f;
iVar0 = 0;
while (iVar0 < 8)
{
Local_68.f_9[iVar0 /*7*/].f_3 = -1f;
Local_68.f_9[iVar0 /*7*/].f_4 = -1f;
Local_68.f_9[iVar0 /*7*/].f_5 = 0;
Local_68.f_9[iVar0 /*7*/].f_6 = 0;
iVar0++;
}
Local_68.f_5 = 0;
Local_68.f_5.f_1 = -1f;
Local_68.f_5.f_2 = 0;
Local_68.f_0 = 0;
Local_68.f_1 = 0;
}
void func_285(int* iParam0)
{
iParam0->f_607 = 0;
}
void func_286(int iParam0, struct<3> Param1, float fParam4, int iParam5, bool bParam6)
{
struct<60> Var0;
if (ENTITY::DOES_ENTITY_EXIST(iParam0) && VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false))
{
if (iParam5 != 24 && iParam5 != 25)
{
return;
}
if (iParam5 == 24)
{
if (ENTITY::DOES_ENTITY_EXIST(Global_76676.f_484[25]) && VEHICLE::IS_VEHICLE_DRIVEABLE(Global_76676.f_484[25], false))
{
if (Global_76676.f_484[25] == iParam0)
{
return;
}
}
}
if (!bParam6)
{
if ((VEHICLE::IS_BIG_VEHICLE(iParam0) || ENTITY::GET_ENTITY_MODEL(iParam0) == joaat("bus")) || ENTITY::GET_ENTITY_MODEL(iParam0) == joaat("tourbus"))
{
return;
}
}
func_323(iParam5);
Var0.f_9 = 49;
Var0.f_59 = 2;
func_318(iParam0, &Var0);
if (func_317(Param1, 0f, 0f, 0f, 0))
{
Param1 = { ENTITY::GET_ENTITY_COORDS(iParam0, true) };
fParam4 = ENTITY::GET_ENTITY_HEADING(iParam0);
}
if (iParam5 == 24)
{
if (MISC::GET_HASH_KEY(SCRIPT::GET_THIS_SCRIPT_NAME()) != joaat("vehicle_gen_controller"))
{
Global_77664 = MISC::GET_HASH_KEY(SCRIPT::GET_THIS_SCRIPT_NAME());
}
}
func_310(iParam5, &Var0, Param1, fParam4, func_316(iParam0));
func_287(iParam5, iParam0, 0);
}
}
void func_287(int iParam0, int iParam1, int iParam2)
{
int iVar0;
if (iParam0 == -1)
{
return;
}
if (!func_307(&(Global_76676.f_555[0 /*21*/]), iParam0))
{
return;
}
if (!BitTest(Global_76676.f_555[0 /*21*/].f_9, 12) && !BitTest(Global_76676.f_555[0 /*21*/].f_9, 10))
{
if (Global_76676.f_555[0 /*21*/].f_4 != ENTITY::GET_ENTITY_MODEL(iParam1))
{
return;
}
}
if (Global_77583 != -1 && Global_77583 != iParam0)
{
return;
}
if (ENTITY::DOES_ENTITY_EXIST(iParam1))
{
if (VEHICLE::IS_VEHICLE_DRIVEABLE(iParam1, false))
{
if (!ENTITY::IS_ENTITY_A_MISSION_ENTITY(iParam1))
{
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(iParam1, true, true);
}
if (iParam0 == 24)
{
Global_112922.f_32749.f_4801 = func_520();
}
if (iParam1 != Global_76676.f_139[iParam0])
{
if (iParam0 == 24)
{
iVar0 = func_306(iParam0);
if ((ENTITY::DOES_ENTITY_EXIST(iVar0) && VEHICLE::IS_VEHICLE_DRIVEABLE(iVar0, false)) && iParam1 != iVar0)
{
func_288(iVar0, 145);
}
}
Global_77582 = iParam1;
Global_77583 = iParam0;
Global_77584 = iParam2;
}
}
}
}
void func_288(int iParam0, int iParam1)
{
int iVar0;
int iVar1;
int iVar2;
if (!func_289(iParam0))
{
return;
}
if ((iParam1 != 0 && iParam1 != 1) && iParam1 != 2)
{
iVar0 = VEHICLE::GET_PED_IN_VEHICLE_SEAT(iParam0, -1, false);
if (!ENTITY::DOES_ENTITY_EXIST(iVar0))
{
iVar0 = VEHICLE::GET_LAST_PED_IN_VEHICLE_SEAT(iParam0, -1);
}
if (ENTITY::DOES_ENTITY_EXIST(iVar0) && !PED::IS_PED_INJURED(iVar0))
{
if (ENTITY::GET_ENTITY_MODEL(iVar0) == joaat("player_zero"))
{
iParam1 = 0;
}
else if (ENTITY::GET_ENTITY_MODEL(iVar0) == joaat("player_one"))
{
iParam1 = 1;
}
else if (ENTITY::GET_ENTITY_MODEL(iVar0) == joaat("player_two"))
{
iParam1 = 2;
}
}
if ((iParam1 != 0 && iParam1 != 1) && iParam1 != 2)
{
iParam1 = Global_112922.f_2363.f_539.f_4321;
}
}
iVar1 = 0;
while (iVar1 < 3)
{
iVar2 = 0;
while (iVar2 < 2)
{
if (ENTITY::GET_ENTITY_MODEL(iParam0) == Global_112922.f_32749.f_5038[iVar1 /*157*/][iVar2 /*78*/].f_66)
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(&(Global_112922.f_32749.f_5038[iVar1 /*157*/][iVar2 /*78*/].f_1)))
{
if (MISC::ARE_STRINGS_EQUAL(VEHICLE::GET_VEHICLE_NUMBER_PLATE_TEXT(iParam0), &(Global_112922.f_32749.f_5038[iVar1 /*157*/][iVar2 /*78*/].f_1)))
{
Global_112922.f_32749.f_5038[iVar1 /*157*/][iVar2 /*78*/].f_66 = 0;
Global_112922.f_32749.f_5592[iVar1] = iVar2;
}
}
}
iVar2++;
}
iVar1++;
}
iVar1 = 0;
while (iVar1 < 3)
{
if (ENTITY::GET_ENTITY_MODEL(iParam0) == Global_112922.f_32749.f_5600[iVar1 /*78*/].f_66)
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(&(Global_112922.f_32749.f_5600[iVar1 /*78*/].f_1)))
{
if (MISC::ARE_STRINGS_EQUAL(VEHICLE::GET_VEHICLE_NUMBER_PLATE_TEXT(iParam0), &(Global_112922.f_32749.f_5600[iVar1 /*78*/].f_1)))
{
Global_112922.f_32749.f_5600[iVar1 /*78*/].f_66 = 0;
}
}
}
iVar1++;
}
Global_112922.f_32749.f_5590 = iParam1;
Global_77581 = iParam0;
Global_112922.f_32749.f_5588 = 1;
func_318(iParam0, &(Global_112922.f_32749.f_5510));
}
int func_289(int iParam0)
{
if ((((((((((!ENTITY::DOES_ENTITY_EXIST(iParam0) || !VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false)) || func_304(iParam0, 0, 0)) || func_304(iParam0, 1, 0)) || func_304(iParam0, 2, 0)) || func_316(iParam0) != 145) || func_303(iParam0)) || func_302(iParam0)) || func_301(iParam0)) || func_300(iParam0)) || !func_290(ENTITY::GET_ENTITY_MODEL(iParam0)))
{
if (func_302(iParam0))
{
}
if (func_302(iParam0))
{
}
if (func_304(iParam0, 0, 0))
{
}
if (func_304(iParam0, 1, 0))
{
}
if (func_304(iParam0, 2, 0))
{
}
if (func_316(iParam0) != 145)
{
}
return 0;
}
return 1;
}
int func_290(int iParam0)
{
if (iParam0 == 0)
{
return 0;
}
if (!func_291(iParam0, 0))
{
return 0;
}
if (((VEHICLE::IS_THIS_MODEL_A_BOAT(iParam0) || VEHICLE::IS_THIS_MODEL_A_PLANE(iParam0)) || VEHICLE::IS_THIS_MODEL_A_HELI(iParam0)) || VEHICLE::IS_THIS_MODEL_A_TRAIN(iParam0))
{
return 0;
}
switch (iParam0)
{
case joaat("bus"):
case joaat("stretch"):
case joaat("barracks"):
case joaat("armytanker"):
case joaat("rhino"):
case joaat("armytrailer"):
case joaat("barracks2"):
case joaat("flatbed"):
case joaat("ripley"):
case joaat("towtruck"):
case joaat("towtruck2"):
case joaat("airbus"):
case joaat("coach"):
case joaat("rentalbus"):
case joaat("tourbus"):
case joaat("firetruk"):
case joaat("pbus"):
case joaat("trash"):
case joaat("benson"):
case joaat("boattrailer"):
case joaat("biff"):
case joaat("hauler"):
case joaat("docktrailer"):
case joaat("phantom"):
case joaat("pounder"):
case joaat("tractor2"):
case joaat("bulldozer"):
case joaat("handler"):
case joaat("tiptruck"):
case joaat("cutter"):
case joaat("dump"):
case joaat("mixer"):
case joaat("mixer2"):
case joaat("rubble"):
case joaat("scrap"):
case joaat("tiptruck2"):
case joaat("camper"):
case joaat("taco"):
case joaat("boxville"):
case joaat("boxville2"):
case joaat("boxville3"):
case joaat("journey"):
case joaat("mule"):
case joaat("mule2"):
case joaat("police"):
case joaat("police2"):
case joaat("police3"):
case joaat("police4"):
case joaat("policeb"):
case joaat("policeold1"):
case joaat("policeold2"):
case joaat("policet"):
case joaat("taxi"):
case joaat("submersible"):
case joaat("submersible2"):
case joaat("monster"):
return 0;
break;
}
return 1;
}
int func_291(int iParam0, bool bParam1)
{
int iVar0;
struct<2> Var1;
if (iParam0 == 0)
{
return 0;
}
if (!STREAMING::IS_MODEL_A_VEHICLE(iParam0))
{
return 0;
}
if (((((iParam0 == joaat("dominator2") && !NETWORK::NETWORK_IS_GAME_IN_PROGRESS()) || (iParam0 == joaat("buffalo3") && !NETWORK::NETWORK_IS_GAME_IN_PROGRESS())) || (iParam0 == joaat("gauntlet2") && !NETWORK::NETWORK_IS_GAME_IN_PROGRESS())) || iParam0 == joaat("blimp2")) || (iParam0 == joaat("stalion2") && !NETWORK::NETWORK_IS_GAME_IN_PROGRESS()))
{
if (!func_299())
{
return 0;
}
}
else
{
iVar0 = 0;
while (iVar0 < FILES::GET_NUM_DLC_VEHICLES())
{
if (FILES::GET_DLC_VEHICLE_DATA(iVar0, &Var1))
{
if (iParam0 == Var1.f_1)
{
if (FILES::IS_CONTENT_ITEM_LOCKED(Var1.f_0))
{
return 0;
}
}
}
iVar0++;
}
}
if (iParam0 == joaat("blimp"))
{
if ((((!func_298() && !func_297()) && !func_296()) && !func_295()) && !func_299())
{
return 0;
}
}
if ((iParam0 == joaat("hotknife") || iParam0 == joaat("carbonrs")) || iParam0 == joaat("khamelion"))
{
if ((func_142() || MISC::IS_PC_VERSION()) || func_92())
{
}
else if (!func_296())
{
return 0;
}
}
if (bParam1)
{
if (!func_294(iParam0))
{
return 0;
}
}
if (!func_292(iParam0))
{
return 0;
}
return 1;
}
int func_292(int iParam0)
{
int iVar0;
var uVar1;
char cVar2[64];
if (!func_293())
{
return 1;
}
NETSHOPPING::_NET_GAMESERVER_GET_TRANSACTION_MANAGER_DATA(&iVar0, &uVar1);
if (iVar0 == 4)
{
return 1;
}
switch (iParam0)
{
case joaat("dune4"):
StringCopy(&cVar2, "VE_DUNE4_t0_v3", 64);
break;
case joaat("voltic2"):
StringCopy(&cVar2, "VE_VOLTIC2_t0_v3", 64);
break;
case joaat("ruiner2"):
StringCopy(&cVar2, "VE_RUINER2_t0_v3", 64);
break;
case joaat("phantom2"):
StringCopy(&cVar2, "VE_PHANTOM2_t0_v3", 64);
break;
case joaat("technical2"):
StringCopy(&cVar2, "VE_TECHNICAL2_t0_v3", 64);
break;
case joaat("boxville5"):
StringCopy(&cVar2, "VE_BOXVILLE5_t0_v3", 64);
break;
case joaat("wastelander"):
StringCopy(&cVar2, "VE_WASTELANDER_t0_v3", 64);
break;
case joaat("blazer5"):
StringCopy(&cVar2, "VE_BLAZER5_t0_v3", 64);
break;
default:
return 1;
break;
}
if (!NETSHOPPING::_NET_GAMESERVER_CATALOG_ITEM_EXISTS(&cVar2))
{
return 0;
}
return 1;
}
int func_293()
{
if (MISC::IS_PC_VERSION())
{
return NETSHOPPING::_NET_GAMESERVER_USE_SERVER_TRANSACTIONS();
}
return 0;
}
int func_294(int iParam0)
{
int iVar0;
int iVar1;
if (Global_2783356)
{
return 1;
}
iVar0 = 1;
iVar1 = NETWORK::GET_CLOUD_TIME_AS_INT();
if (iParam0 == joaat("btype3"))
{
if ((!Global_262145.f_6856 && !Global_262145.f_13187) && iVar1 < Global_262145.f_13188)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("faction3"))
{
if (!Global_262145.f_14487 && iVar1 < Global_262145.f_14499)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("virgo3") || iParam0 == joaat("virgo2"))
{
if (!Global_262145.f_14483 && iVar1 < Global_262145.f_14495)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sabregt2"))
{
if (!Global_262145.f_14484 && iVar1 < Global_262145.f_14496)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tornado5"))
{
if (!Global_262145.f_14485 && iVar1 < Global_262145.f_14497)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("minivan2"))
{
if (!Global_262145.f_14486 && iVar1 < Global_262145.f_14498)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("slamvan3"))
{
if (!Global_262145.f_14488 && iVar1 < Global_262145.f_14500)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("prototipo"))
{
if (!Global_262145.f_14489 && iVar1 < Global_262145.f_14492)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("seven70"))
{
if (!Global_262145.f_14490 && iVar1 < Global_262145.f_14493)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pfister811"))
{
if (!Global_262145.f_14491 && iVar1 < Global_262145.f_14494)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("bf400"))
{
if (!Global_262145.f_17120 && iVar1 < Global_262145.f_17085)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("brioso"))
{
if (!Global_262145.f_17115 && iVar1 < Global_262145.f_17080)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cliffhanger"))
{
if (!Global_262145.f_17119 && iVar1 < Global_262145.f_17084)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("contender"))
{
if (!Global_262145.f_17118 && iVar1 < Global_262145.f_17083)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("le7b"))
{
if (!Global_262145.f_17112 && iVar1 < Global_262145.f_17077)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("omnis"))
{
if (!Global_262145.f_17113 && iVar1 < Global_262145.f_17078)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("trophytruck"))
{
if (!Global_262145.f_17116 && iVar1 < Global_262145.f_17081)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("trophytruck2"))
{
if (!Global_262145.f_17117 && iVar1 < Global_262145.f_17082)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tropos"))
{
if (!Global_262145.f_17114 && iVar1 < Global_262145.f_17079)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gargoyle"))
{
if (!Global_262145.f_17122 && iVar1 < Global_262145.f_17087)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rallytruck"))
{
if (!Global_262145.f_17123 && iVar1 < Global_262145.f_17088)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tampa2"))
{
if (!Global_262145.f_17111 && iVar1 < Global_262145.f_17076)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tyrus"))
{
if (!Global_262145.f_17110 && iVar1 < Global_262145.f_17075)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sheava"))
{
if (!Global_262145.f_17109 && iVar1 < Global_262145.f_17074)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("lynx"))
{
if (!Global_262145.f_17121 && iVar1 < Global_262145.f_17086)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stalion2"))
{
if (!Global_262145.f_17124 && iVar1 < Global_262145.f_17089)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gauntlet2"))
{
if (!Global_262145.f_17125 && iVar1 < Global_262145.f_17090)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dominator2"))
{
if (!Global_262145.f_17126 && iVar1 < Global_262145.f_17091)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("buffalo3"))
{
if (!Global_262145.f_17127 && iVar1 < Global_262145.f_17092)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("defiler"))
{
if (!Global_262145.f_17274 && iVar1 < Global_262145.f_17296)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nightblade"))
{
if (!Global_262145.f_17275 && iVar1 < Global_262145.f_17297)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zombiea"))
{
if (!Global_262145.f_17276 && iVar1 < Global_262145.f_17298)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("esskey"))
{
if (!Global_262145.f_17277 && iVar1 < Global_262145.f_17299)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("avarus"))
{
if (!Global_262145.f_17278 && iVar1 < Global_262145.f_17300)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zombieb"))
{
if (!Global_262145.f_17279 && iVar1 < Global_262145.f_17301)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hakuchou2"))
{
if (!Global_262145.f_17281 && iVar1 < Global_262145.f_17302)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vortex"))
{
if (!Global_262145.f_17282 && iVar1 < Global_262145.f_17303)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("shotaro"))
{
if (!Global_262145.f_17283 && iVar1 < Global_262145.f_17304)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("chimera"))
{
if (!Global_262145.f_17284 && iVar1 < Global_262145.f_17305)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("raptor"))
{
if (!Global_262145.f_17285 && iVar1 < Global_262145.f_17306)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("daemon2"))
{
if (!Global_262145.f_17286 && iVar1 < Global_262145.f_17307)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("blazer4"))
{
if (!Global_262145.f_17287 && iVar1 < Global_262145.f_17308)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tornado6"))
{
if (!Global_262145.f_17293 && iVar1 < Global_262145.f_17315)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("youga2"))
{
if (!Global_262145.f_17290 && iVar1 < Global_262145.f_17311)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("wolfsbane"))
{
if (!Global_262145.f_17291 && iVar1 < Global_262145.f_17312)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("faggio3"))
{
if (!Global_262145.f_17292 && iVar1 < Global_262145.f_17313)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("faggio"))
{
if (!Global_262145.f_17280 && iVar1 < Global_262145.f_17314)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("bagger"))
{
if (!Global_262145.f_17294 && iVar1 < Global_262145.f_17316)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sanctus"))
{
if (!Global_262145.f_17288 && iVar1 < Global_262145.f_17309)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("manchez"))
{
if (!Global_262145.f_17289 && iVar1 < Global_262145.f_17310)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ratbike"))
{
if (!Global_262145.f_17295 && iVar1 < Global_262145.f_17317)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("voltic2"))
{
if (!Global_262145.f_18926 && iVar1 < Global_262145.f_19023)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ruiner2"))
{
if (!Global_262145.f_18927 && iVar1 < Global_262145.f_19024)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dune4"))
{
if (!Global_262145.f_18928 && iVar1 < Global_262145.f_19025)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dune5"))
{
if (!Global_262145.f_18929 && iVar1 < Global_262145.f_19026)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("phantom2"))
{
if (!Global_262145.f_18930 && iVar1 < Global_262145.f_19027)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("technical2"))
{
if (!Global_262145.f_18931 && iVar1 < Global_262145.f_19028)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("boxville5"))
{
if (!Global_262145.f_18932 && iVar1 < Global_262145.f_19029)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("wastelander"))
{
if (!Global_262145.f_18933 && iVar1 < Global_262145.f_19030)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("blazer5"))
{
if (!Global_262145.f_18934 && iVar1 < Global_262145.f_19031)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet2"))
{
if (!Global_262145.f_18935 && iVar1 < Global_262145.f_19032)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet3"))
{
if (!Global_262145.f_18936 && iVar1 < Global_262145.f_19033)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("diablous"))
{
if (!Global_262145.f_18937 && iVar1 < Global_262145.f_19034)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("diablous2"))
{
if (!Global_262145.f_18938 && iVar1 < Global_262145.f_19035)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("elegy"))
{
if (!Global_262145.f_18939 && iVar1 < Global_262145.f_19036)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("elegy2"))
{
if (!Global_262145.f_18940 && iVar1 < Global_262145.f_19037)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("fcr"))
{
if (!Global_262145.f_18941 && iVar1 < Global_262145.f_19038)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("fcr2"))
{
if (!Global_262145.f_18942 && iVar1 < Global_262145.f_19039)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("italigtb"))
{
if (!Global_262145.f_18943 && iVar1 < Global_262145.f_19040)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("italigtb2"))
{
if (!Global_262145.f_18944 && iVar1 < Global_262145.f_19041)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nero"))
{
if (!Global_262145.f_18945 && iVar1 < Global_262145.f_19042)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nero2"))
{
if (!Global_262145.f_18946 && iVar1 < Global_262145.f_19043)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("penetrator"))
{
if (!Global_262145.f_18947 && iVar1 < Global_262145.f_19044)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("specter"))
{
if (!Global_262145.f_18948 && iVar1 < Global_262145.f_19045)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("specter2"))
{
if (!Global_262145.f_18949 && iVar1 < Global_262145.f_19046)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tempesta"))
{
if (!Global_262145.f_18950 && iVar1 < Global_262145.f_19047)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("gp1"))
{
if (!Global_262145.f_20007 && iVar1 < Global_262145.f_20003)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("infernus2"))
{
if (!Global_262145.f_20008 && iVar1 < Global_262145.f_20004)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ruston"))
{
if (!Global_262145.f_20009 && iVar1 < Global_262145.f_20005)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("turismo2"))
{
if (!Global_262145.f_20010 && iVar1 < Global_262145.f_20006)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("xa21"))
{
if (!Global_262145.f_20888 && iVar1 < Global_262145.f_20896)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cheetah2"))
{
if (!Global_262145.f_20889 && iVar1 < Global_262145.f_20897)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("torero"))
{
if (!Global_262145.f_20890 && iVar1 < Global_262145.f_20898)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vagner"))
{
if (!Global_262145.f_20891 && iVar1 < Global_262145.f_20899)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ardent"))
{
if (!Global_262145.f_20892 && iVar1 < Global_262145.f_20900)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nightshark"))
{
if (!Global_262145.f_20893 && iVar1 < Global_262145.f_20901)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("microlight"))
{
if (!Global_262145.f_21669 && iVar1 < Global_262145.f_21689)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("mogul"))
{
if (!Global_262145.f_21681 && iVar1 < Global_262145.f_21701)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rogue"))
{
if (!Global_262145.f_21672 && iVar1 < Global_262145.f_21692)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("starling"))
{
if (!Global_262145.f_21682 && iVar1 < Global_262145.f_21702)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("seabreeze"))
{
if (!Global_262145.f_21670 && iVar1 < Global_262145.f_21690)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tula"))
{
if (!Global_262145.f_21686 && iVar1 < Global_262145.f_21706)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pyro"))
{
if (!Global_262145.f_21684 && iVar1 < Global_262145.f_21704)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("molotok"))
{
if (!Global_262145.f_21685 && iVar1 < Global_262145.f_21705)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nokota"))
{
if (!Global_262145.f_21680 && iVar1 < Global_262145.f_21700)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("bombushka"))
{
if (!Global_262145.f_21687 && iVar1 < Global_262145.f_21707)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hunter"))
{
if (!Global_262145.f_21683 && iVar1 < Global_262145.f_21703)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("havok"))
{
if (!Global_262145.f_21679 && iVar1 < Global_262145.f_21699)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("howard"))
{
if (!Global_262145.f_21671 && iVar1 < Global_262145.f_21691)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("alphaz1"))
{
if (!Global_262145.f_21673 && iVar1 < Global_262145.f_21693)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cyclone"))
{
if (!Global_262145.f_21674 && iVar1 < Global_262145.f_21694)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("visione"))
{
if (!Global_262145.f_21675 && iVar1 < Global_262145.f_21695)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vigilante"))
{
if (!Global_262145.f_21676 && iVar1 < Global_262145.f_21696)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("retinue"))
{
if (!Global_262145.f_21677 && iVar1 < Global_262145.f_21697)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rapidgt3"))
{
if (!Global_262145.f_21678 && iVar1 < Global_262145.f_21698)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("deluxo"))
{
if (!Global_262145.f_22630 && iVar1 < Global_262145.f_22658)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stromberg"))
{
if (!Global_262145.f_22631 && iVar1 < Global_262145.f_22659)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("riot2"))
{
if (!Global_262145.f_22632 && iVar1 < Global_262145.f_22660)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("chernobog"))
{
if (!Global_262145.f_22633 && iVar1 < Global_262145.f_22661)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("khanjali"))
{
if (!Global_262145.f_22634 && iVar1 < Global_262145.f_22662)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("akula"))
{
if (!Global_262145.f_22635 && iVar1 < Global_262145.f_22663)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("thruster"))
{
if (!Global_262145.f_22636 && iVar1 < Global_262145.f_22664)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("barrage"))
{
if (!Global_262145.f_22637 && iVar1 < Global_262145.f_22665)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("volatol"))
{
if (!Global_262145.f_22638 && iVar1 < Global_262145.f_22666)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet4"))
{
if (!Global_262145.f_22639 && iVar1 < Global_262145.f_22667)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("neon"))
{
if (!Global_262145.f_22640 && iVar1 < Global_262145.f_22668)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("streiter"))
{
if (!Global_262145.f_22641 && iVar1 < Global_262145.f_22669)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sentinel3"))
{
if (!Global_262145.f_22642 && iVar1 < Global_262145.f_22670)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("yosemite"))
{
if (!Global_262145.f_22643 && iVar1 < Global_262145.f_22671)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sc1"))
{
if (!Global_262145.f_22644 && iVar1 < Global_262145.f_22672)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("autarch"))
{
if (!Global_262145.f_22645 && iVar1 < Global_262145.f_22673)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gt500"))
{
if (!Global_262145.f_22646 && iVar1 < Global_262145.f_22674)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hustler"))
{
if (!Global_262145.f_22647 && iVar1 < Global_262145.f_22675)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("revolter"))
{
if (!Global_262145.f_22648 && iVar1 < Global_262145.f_22676)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pariah"))
{
if (!Global_262145.f_22649 && iVar1 < Global_262145.f_22677)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("raiden"))
{
if (!Global_262145.f_22650 && iVar1 < Global_262145.f_22678)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("savestra"))
{
if (!Global_262145.f_22651 && iVar1 < Global_262145.f_22679)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("riata"))
{
if (!Global_262145.f_22652 && iVar1 < Global_262145.f_22680)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hermes"))
{
if (!Global_262145.f_22653 && iVar1 < Global_262145.f_22681)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet5"))
{
if (!Global_262145.f_22654 && iVar1 < Global_262145.f_22682)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("z190"))
{
if (!Global_262145.f_22655 && iVar1 < Global_262145.f_22683)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("viseris"))
{
if (!Global_262145.f_22656 && iVar1 < Global_262145.f_22684)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("kamacho"))
{
if (!Global_262145.f_22657 && iVar1 < Global_262145.f_22685)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("gb200"))
{
if (!Global_262145.f_23850 && iVar1 < Global_262145.f_23866)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("fagaloa"))
{
if (!Global_262145.f_23851 && iVar1 < Global_262145.f_23867)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ellie"))
{
if (!Global_262145.f_23855 && iVar1 < Global_262145.f_23871)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("issi3"))
{
if (!Global_262145.f_23858 && iVar1 < Global_262145.f_23874)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("michelli"))
{
if (!Global_262145.f_23863 && iVar1 < Global_262145.f_23879)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("flashgt"))
{
if (!Global_262145.f_23857 && iVar1 < Global_262145.f_23873)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hotring"))
{
if (!Global_262145.f_23849 && iVar1 < Global_262145.f_23865)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tezeract"))
{
if (!Global_262145.f_23856 && iVar1 < Global_262145.f_23872)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tyrant"))
{
if (!Global_262145.f_23862 && iVar1 < Global_262145.f_23878)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dominator3"))
{
if (!Global_262145.f_23861 && iVar1 < Global_262145.f_23877)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("taipan"))
{
if (!Global_262145.f_23852 && iVar1 < Global_262145.f_23868)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("entity2"))
{
if (!Global_262145.f_23854 && iVar1 < Global_262145.f_23870)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("jester3"))
{
if (!Global_262145.f_23864 && iVar1 < Global_262145.f_23880)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cheburek"))
{
if (!Global_262145.f_23860 && iVar1 < Global_262145.f_23876)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("caracara"))
{
if (!Global_262145.f_23853 && iVar1 < Global_262145.f_23869)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("seasparrow"))
{
if (!Global_262145.f_23859 && iVar1 < Global_262145.f_23875)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("terbyte"))
{
if (!Global_262145.f_23940 && iVar1 < Global_262145.f_23927)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pbus2"))
{
if (!Global_262145.f_23941 && iVar1 < Global_262145.f_23928)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("mule4"))
{
if (!Global_262145.f_23946 && iVar1 < Global_262145.f_23933)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pounder2"))
{
if (!Global_262145.f_23945 && iVar1 < Global_262145.f_23932)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("swinger"))
{
if (!Global_262145.f_23943 && iVar1 < Global_262145.f_23930)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("menacer"))
{
if (!Global_262145.f_23949 && iVar1 < Global_262145.f_23936)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("scramjet"))
{
if (!Global_262145.f_23951 && iVar1 < Global_262145.f_23938)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("strikeforce"))
{
if (!Global_262145.f_23952 && iVar1 < Global_262145.f_23939)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("oppressor2"))
{
if (!Global_262145.f_23950 && iVar1 < Global_262145.f_23937)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("patriot2"))
{
if (!Global_262145.f_23942 && iVar1 < Global_262145.f_23929)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stafford"))
{
if (!Global_262145.f_23944 && iVar1 < Global_262145.f_23931)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("freecrawler"))
{
if (!Global_262145.f_23948 && iVar1 < Global_262145.f_23935)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("blimp3"))
{
if (!Global_262145.f_23947 && iVar1 < Global_262145.f_23934)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("monster3"))
{
}
else if (iParam0 == joaat("cerberus"))
{
}
else if (iParam0 == joaat("cerberus2"))
{
}
else if (iParam0 == joaat("cerberus3"))
{
}
else if (iParam0 == joaat("brutus"))
{
}
else if (iParam0 == joaat("brutus2"))
{
}
else if (iParam0 == joaat("brutus3"))
{
}
else if (iParam0 == joaat("scarab"))
{
}
else if (iParam0 == joaat("scarab2"))
{
}
else if (iParam0 == joaat("scarab3"))
{
}
else if (iParam0 == joaat("imperator"))
{
}
else if (iParam0 == joaat("imperator2"))
{
}
else if (iParam0 == joaat("imperator3"))
{
}
else if (iParam0 == joaat("zr380"))
{
}
else if (iParam0 == joaat("zr3802"))
{
}
else if (iParam0 == joaat("zr3803"))
{
}
else if (iParam0 == joaat("impaler"))
{
}
else if (iParam0 == joaat("deveste"))
{
if (!Global_262145.f_26432 && iVar1 < Global_262145.f_26434)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("toros"))
{
if (!Global_262145.f_25445 && iVar1 < Global_262145.f_25438)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("clique"))
{
if (!Global_262145.f_25446 && iVar1 < Global_262145.f_25439)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("italigto"))
{
if (!Global_262145.f_25447 && iVar1 < Global_262145.f_25440)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("deviant"))
{
if (!Global_262145.f_25448 && iVar1 < Global_262145.f_25441)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vamos"))
{
if (!Global_262145.f_26433 && iVar1 < Global_262145.f_26435)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tulip"))
{
if (!Global_262145.f_25449 && iVar1 < Global_262145.f_25442)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("schlagen"))
{
if (!Global_262145.f_25450 && iVar1 < Global_262145.f_25443)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rcbandito"))
{
if (!Global_262145.f_25451 && iVar1 < Global_262145.f_25444)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("thrax"))
{
if (!Global_262145.f_25456 && iVar1 < Global_262145.f_25477)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("drafter"))
{
if (!Global_262145.f_25457 && iVar1 < Global_262145.f_25478)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("locust"))
{
if (!Global_262145.f_25458 && iVar1 < Global_262145.f_25479)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("novak"))
{
if (!Global_262145.f_25459 && iVar1 < Global_262145.f_25480)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zorrusso"))
{
if (!Global_262145.f_25460 && iVar1 < Global_262145.f_25481)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gauntlet3"))
{
if (!Global_262145.f_25461 && iVar1 < Global_262145.f_25482)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("issi7"))
{
if (!Global_262145.f_25462 && iVar1 < Global_262145.f_25483)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zion3"))
{
if (!Global_262145.f_25463 && iVar1 < Global_262145.f_25484)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nebula"))
{
if (!Global_262145.f_25464 && iVar1 < Global_262145.f_25485)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hellion"))
{
if (!Global_262145.f_25465 && iVar1 < Global_262145.f_25486)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dynasty"))
{
if (!Global_262145.f_25466 && iVar1 < Global_262145.f_25487)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rrocket"))
{
if (!Global_262145.f_25467 && iVar1 < Global_262145.f_25488)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("peyote2"))
{
if (!Global_262145.f_25468 && iVar1 < Global_262145.f_25489)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gauntlet4"))
{
if (!Global_262145.f_25469 && iVar1 < Global_262145.f_25490)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("caracara2"))
{
if (!Global_262145.f_25470 && iVar1 < Global_262145.f_25491)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("jugular"))
{
if (!Global_262145.f_25471 && iVar1 < Global_262145.f_25492)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("s80"))
{
if (!Global_262145.f_25472 && iVar1 < Global_262145.f_25493)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("krieger"))
{
if (!Global_262145.f_25473 && iVar1 < Global_262145.f_25494)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("emerus"))
{
if (!Global_262145.f_25474 && iVar1 < Global_262145.f_25495)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("neo"))
{
if (!Global_262145.f_25475 && iVar1 < Global_262145.f_25496)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("paragon"))
{
if (!Global_262145.f_25476 && iVar1 < Global_262145.f_25497)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("asbo"))
{
if (!Global_262145.f_28277 && iVar1 < Global_262145.f_28298)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("kanjo"))
{
if (!Global_262145.f_28278 && iVar1 < Global_262145.f_28299)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("everon"))
{
if (!Global_262145.f_28279 && iVar1 < Global_262145.f_28300)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("retinue2"))
{
if (!Global_262145.f_28280 && iVar1 < Global_262145.f_28301)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("yosemite2"))
{
if (!Global_262145.f_28281 && iVar1 < Global_262145.f_28302)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sugoi"))
{
if (!Global_262145.f_28282 && iVar1 < Global_262145.f_28303)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sultan2"))
{
if (!Global_262145.f_28283 && iVar1 < Global_262145.f_28304)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("outlaw"))
{
if (!Global_262145.f_28284 && iVar1 < Global_262145.f_28305)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vagrant"))
{
if (!Global_262145.f_28285 && iVar1 < Global_262145.f_28306)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("komoda"))
{
if (!Global_262145.f_28286 && iVar1 < Global_262145.f_28307)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stryder"))
{
if (!Global_262145.f_28287 && iVar1 < Global_262145.f_28308)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("furia"))
{
if (!Global_262145.f_28288 && iVar1 < Global_262145.f_28309)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zhaba"))
{
if (!Global_262145.f_28289 && iVar1 < Global_262145.f_28310)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("jb7002"))
{
if (!Global_262145.f_28290 && iVar1 < Global_262145.f_28311)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("firetruk"))
{
if (!Global_262145.f_28291 && iVar1 < Global_262145.f_28312)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("burrito2"))
{
if (!Global_262145.f_28292 && iVar1 < Global_262145.f_28313)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("boxville"))
{
if (!Global_262145.f_28293 && iVar1 < Global_262145.f_28314)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stockade"))
{
if (!Global_262145.f_28294 && iVar1 < Global_262145.f_28315)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("minitank"))
{
if (!Global_262145.f_28295 && iVar1 < Global_262145.f_28316)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("lguard"))
{
if (!Global_262145.f_28296 && iVar1 < Global_262145.f_28317)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("blazer2"))
{
if (!Global_262145.f_28297 && iVar1 < Global_262145.f_28318)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("formula"))
{
if ((!Global_262145.f_28320 && iVar1 < Global_262145.f_28321) && !Global_262145.f_28275)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("formula2"))
{
if ((!Global_262145.f_28323 && iVar1 < Global_262145.f_28324) && !Global_262145.f_28276)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("imorgon"))
{
if (!Global_262145.f_28328 && iVar1 < Global_262145.f_28331)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rebla"))
{
if (!Global_262145.f_28329 && iVar1 < Global_262145.f_28332)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vstr"))
{
if (!Global_262145.f_28330 && iVar1 < Global_262145.f_28333)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gauntlet5"))
{
if (!Global_262145.f_29346 && iVar1 < Global_262145.f_29011)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("club"))
{
if (!Global_262145.f_28997 && iVar1 < Global_262145.f_29018)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dukes3"))
{
if (!Global_262145.f_28998 && iVar1 < Global_262145.f_29004)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("yosemite3"))
{
if (!Global_262145.f_29344 && iVar1 < Global_262145.f_29012)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("peyote3"))
{
if (!Global_262145.f_29345 && iVar1 < Global_262145.f_29013)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("glendale2"))
{
if (!Global_262145.f_28991 && iVar1 < Global_262145.f_29010)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("penumbra2"))
{
if (!Global_262145.f_28992 && iVar1 < Global_262145.f_29019)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("landstalker2"))
{
if (!Global_262145.f_28993 && iVar1 < Global_262145.f_29009)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("seminole2"))
{
if (!Global_262145.f_28994 && iVar1 < Global_262145.f_29007)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tigon"))
{
if (!Global_262145.f_29340 && iVar1 < Global_262145.f_29014)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("openwheel1"))
{
if (!Global_262145.f_29341 && iVar1 < Global_262145.f_29015)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("openwheel2"))
{
if (!Global_262145.f_29342 && iVar1 < Global_262145.f_29016)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("coquette4"))
{
if (!Global_262145.f_29343 && iVar1 < Global_262145.f_29017)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("manana2"))
{
if (!Global_262145.f_28995 && iVar1 < Global_262145.f_29006)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("youga3"))
{
if (!Global_262145.f_28996 && iVar1 < Global_262145.f_29008)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("toreador"))
{
if (!Global_262145.f_29791 && iVar1 < Global_262145.f_29774)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("annihilator2"))
{
if (!Global_262145.f_29792 && iVar1 < Global_262145.f_29775)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("alkonost"))
{
if (!Global_262145.f_29793 && iVar1 < Global_262145.f_29776)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("patrolboat"))
{
if (!Global_262145.f_29794 && iVar1 < Global_262145.f_29777)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("longfin"))
{
if (!Global_262145.f_29795 && iVar1 < Global_262145.f_29778)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("winky"))
{
if (!Global_262145.f_29796 && iVar1 < Global_262145.f_29779)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("veto"))
{
if (!Global_262145.f_29797 && iVar1 < Global_262145.f_29780)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("veto2"))
{
if (!Global_262145.f_29798 && iVar1 < Global_262145.f_29781)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("italirsx"))
{
if (!Global_262145.f_29799 && iVar1 < Global_262145.f_29782)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("weevil"))
{
if (Global_262145.f_29808)
{
}
else if (!Global_262145.f_29800 && iVar1 < Global_262145.f_29783)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("manchez2"))
{
if (!Global_262145.f_29801 && iVar1 < Global_262145.f_29784)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("slamtruck"))
{
if (!Global_262145.f_29802 && iVar1 < Global_262145.f_29785)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vetir"))
{
if (!Global_262145.f_29803 && iVar1 < Global_262145.f_29786)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("squaddie"))
{
if (!Global_262145.f_29804 && iVar1 < Global_262145.f_29787)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("brioso2"))
{
if (Global_262145.f_29809)
{
}
else if (!Global_262145.f_29805 && iVar1 < Global_262145.f_29788)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dinghy5"))
{
if (!Global_262145.f_29806 && iVar1 < Global_262145.f_29789)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("verus"))
{
if (!Global_262145.f_29807 && iVar1 < Global_262145.f_29790)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tailgater2"))
{
if (!Global_262145.f_30659 && iVar1 < Global_262145.f_30642)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("euros"))
{
if (!Global_262145.f_30660 && iVar1 < Global_262145.f_30643)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sultan3"))
{
if (!Global_262145.f_30661 && iVar1 < Global_262145.f_30644)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rt3000"))
{
if (!Global_262145.f_30662 && iVar1 < Global_262145.f_30645)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vectre"))
{
if (!Global_262145.f_30663 && iVar1 < Global_262145.f_30646)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zr350"))
{
if (!Global_262145.f_30664 && iVar1 < Global_262145.f_30647)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("warrener2"))
{
if (!Global_262145.f_30665 && iVar1 < Global_262145.f_30648)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("calico"))
{
if (!Global_262145.f_30666 && iVar1 < Global_262145.f_30649)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("remus"))
{
if (!Global_262145.f_30667 && iVar1 < Global_262145.f_30650)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cypher"))
{
if (!Global_262145.f_30668 && iVar1 < Global_262145.f_30651)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dominator7"))
{
if (!Global_262145.f_30669 && iVar1 < Global_262145.f_30652)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("jester4"))
{
if (!Global_262145.f_30670 && iVar1 < Global_262145.f_30653)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("futo2"))
{
if (!Global_262145.f_30671 && iVar1 < Global_262145.f_30654)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dominator8"))
{
if (!Global_262145.f_30672 && iVar1 < Global_262145.f_30655)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("previon"))
{
if (!Global_262145.f_30673 && iVar1 < Global_262145.f_30656)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("growler"))
{
if (!Global_262145.f_30674 && iVar1 < Global_262145.f_30657)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet6"))
{
if (!Global_262145.f_30675 && iVar1 < Global_262145.f_30658)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("champion"))
{
if (!Global_262145.f_31483 && iVar1 < Global_262145.f_31468)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("buffalo4"))
{
if (!Global_262145.f_31484 && iVar1 < Global_262145.f_31469)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("deity"))
{
if (!Global_262145.f_31485 && iVar1 < Global_262145.f_31470)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("jubilee"))
{
if (!Global_262145.f_31486 && iVar1 < Global_262145.f_31471)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ignus"))
{
if (!Global_262145.f_31487 && iVar1 < Global_262145.f_31472)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cinquemila"))
{
if (!Global_262145.f_31488 && iVar1 < Global_262145.f_31473)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("astron"))
{
if (!Global_262145.f_31489 && iVar1 < Global_262145.f_31474)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet7"))
{
if (!Global_262145.f_31490 && iVar1 < Global_262145.f_31475)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zeno"))
{
if (!Global_262145.f_31491 && iVar1 < Global_262145.f_31476)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("reever"))
{
if (!Global_262145.f_31492 && iVar1 < Global_262145.f_31477)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("iwagen"))
{
if (!Global_262145.f_31493 && iVar1 < Global_262145.f_31478)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("granger2"))
{
if (!Global_262145.f_31494 && iVar1 < Global_262145.f_31479)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("patriot3"))
{
if (!Global_262145.f_31495 && iVar1 < Global_262145.f_31480)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("shinobi"))
{
if (!Global_262145.f_31496 && iVar1 < Global_262145.f_31481)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("baller7"))
{
if (Global_262145.f_31561)
{
}
else if (!Global_262145.f_31497 && iVar1 < Global_262145.f_31482)
{
iVar0 = 0;
}
}
return iVar0;
}
int func_295()
{
return 0;
}
int func_296()
{
return 1;
}
int func_297()
{
return 1;
}
int func_298()
{
if (DLC::IS_DLC_PRESENT(-1226939934))
{
return 1;
}
return 0;
}
int func_299()
{
int iVar0;
if (Global_151761 == 2)
{
return 1;
}
else if (Global_151761 == 3)
{
return 0;
}
if (NETWORK::NETWORK_IS_SIGNED_IN())
{
if (NETWORK::NETWORK_HAS_VALID_ROS_CREDENTIALS())
{
if (NETWORK::_NETWORK_GET_ROS_PRIVILEGE_24())
{
STATS::STAT_GET_INT(joaat("sp_unlock_exclus_content"), &iVar0, -1);
MISC::SET_BIT(&iVar0, 2);
MISC::SET_BIT(&iVar0, 4);
MISC::SET_BIT(&iVar0, 6);
MISC::SET_BIT(&Global_25, 2);
MISC::SET_BIT(&Global_25, 4);
MISC::SET_BIT(&Global_25, 6);
STATS::STAT_SET_INT(joaat("sp_unlock_exclus_content"), iVar0, true);
if (MISC::ARE_PROFILE_SETTINGS_VALID())
{
iVar0 = MISC::GET_PROFILE_SETTING(866);
MISC::SET_BIT(&iVar0, false);
STATS::_SET_HAS_CONTENT_UNLOCKS_FLAGS(iVar0);
}
return 1;
}
}
}
if (MISC::ARE_PROFILE_SETTINGS_VALID())
{
if (BitTest(MISC::GET_PROFILE_SETTING(866), 0))
{
return 1;
}
}
return 0;
}
int func_300(int iParam0)
{
int iVar0;
char* sVar1;
iVar0 = ENTITY::GET_ENTITY_MODEL(iParam0);
sVar1 = VEHICLE::GET_VEHICLE_NUMBER_PLATE_TEXT(iParam0);
if (iVar0 == joaat("speedo") && MISC::ARE_STRINGS_EQUAL(sVar1, "LAMAR G "))
{
return 1;
}
if (!func_291(iVar0, 0))
{
return 1;
}
return 0;
}
int func_301(int iParam0)
{
int iVar0;
iVar0 = 0;
while (iVar0 < 3)
{
if (ENTITY::DOES_ENTITY_EXIST(Global_97341[iVar0]))
{
if (Global_97341[iVar0] == iParam0)
{
return 1;
}
}
iVar0++;
}
return 0;
}
int func_302(int iParam0)
{
int iVar0;
if (ENTITY::DOES_ENTITY_EXIST(iParam0) && VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false))
{
iVar0 = 0;
while (iVar0 < 9)
{
if (ENTITY::DOES_ENTITY_EXIST(Global_97311[iVar0]) && VEHICLE::IS_VEHICLE_DRIVEABLE(Global_97311[iVar0], false))
{
if (Global_97311[iVar0] == iParam0 && ENTITY::GET_ENTITY_MODEL(Global_97311[iVar0]) == ENTITY::GET_ENTITY_MODEL(iParam0))
{
return 1;
}
}
iVar0++;
}
}
return 0;
}
int func_303(int iParam0)
{
int iVar0;
if (ENTITY::DOES_ENTITY_EXIST(Global_76676.f_484[24]))
{
if (iParam0 == Global_76676.f_484[24])
{
return 0;
}
}
iVar0 = 0;
while (iVar0 < 68)
{
if (ENTITY::DOES_ENTITY_EXIST(Global_76676.f_484[iVar0]))
{
if ((((((((((((iVar0 != 24 && iVar0 != 21) && iVar0 != 22) && iVar0 != 23) && iVar0 != 27) && iVar0 != 30) && iVar0 != 33) && iVar0 != 28) && iVar0 != 31) && iVar0 != 34) && iVar0 != 26) && iVar0 != 29) && iVar0 != 32)
{
if (iParam0 == Global_76676.f_484[iVar0])
{
return 1;
}
}
}
iVar0++;
}
return 0;
}
int func_304(int iParam0, int iParam1, bool bParam2)
{
int iVar0;
char* sVar1;
int iVar9;
if (!ENTITY::DOES_ENTITY_EXIST(iParam0) || !VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false))
{
return 0;
}
iVar0 = 0;
while (func_305(iParam1, iVar0, &sVar1, &iVar9))
{
if (!bParam2 || BitTest(Global_112922.f_7229[iVar9], 0))
{
if (VEHICLE::IS_VEHICLE_IN_GARAGE_AREA(&sVar1, iParam0))
{
return 1;
}
}
iVar0++;
}
return 0;
}
int func_305(int iParam0, int iParam1, char* sParam2, var uParam3)
{
StringCopy(sParam2, "", 32);
switch (iParam0)
{
case 0:
if (iParam1 == 0)
{
StringCopy(sParam2, "Michael - Beverly Hills", 32);
*uParam3 = 0;
return 1;
}
else if (iParam1 == 1)
{
StringCopy(sParam2, "Trevor - Countryside", 32);
*uParam3 = 1;
return 1;
}
break;
case 1:
if (iParam1 == 0)
{
StringCopy(sParam2, "Franklin - Aunt", 32);
*uParam3 = 5;
return 1;
}
else if (iParam1 == 1)
{
StringCopy(sParam2, "Franklin - Hills", 32);
*uParam3 = 6;
return 1;
}
break;
case 2:
if (iParam1 == 0)
{
StringCopy(sParam2, "Trevor - Countryside", 32);
*uParam3 = 2;
return 1;
}
else if (iParam1 == 1)
{
StringCopy(sParam2, "Trevor - City", 32);
*uParam3 = 3;
return 1;
}
else if (iParam1 == 2)
{
StringCopy(sParam2, "Trevor - Stripclub", 32);
*uParam3 = 4;
return 1;
}
break;
}
return 0;
}
int func_306(int iParam0)
{
if (iParam0 == -1)
{
return 0;
}
return Global_76676.f_139[iParam0];
}
int func_307(var uParam0, int iParam1)
{
int iVar0;
int iVar1;
*uParam0 = { 0f, 0f, 0f };
uParam0->f_3 = 0f;
uParam0->f_4 = 0;
StringCopy(&(uParam0->f_5), "", 16);
uParam0->f_9 = 0;
uParam0->f_10 = 0;
uParam0->f_11 = 0;
uParam0->f_12 = 145;
uParam0->f_13 = -1;
uParam0->f_14 = 0;
uParam0->f_15 = { 0f, 0f, 0f };
uParam0->f_18 = { 0f, 0f, 0f };
switch (iParam1)
{
case 0:
*uParam0 = { -831.8538f, 172.1154f, 69.9058f };
uParam0->f_3 = 157.5705f;
uParam0->f_4 = func_308(0, 1);
uParam0->f_12 = 0;
MISC::SET_BIT(&(uParam0->f_9), 20);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 1:
*uParam0 = { 1970.943f, 3801.684f, 31.1396f };
uParam0->f_3 = 301.3964f;
uParam0->f_4 = func_308(0, 1);
uParam0->f_12 = 0;
MISC::SET_BIT(&(uParam0->f_9), 20);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 2:
*uParam0 = { -22.6297f, -1439.137f, 29.6549f };
uParam0->f_3 = 180.0808f;
uParam0->f_4 = func_308(1, 1);
uParam0->f_12 = 1;
MISC::SET_BIT(&(uParam0->f_9), 20);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 3:
*uParam0 = { -22.5229f, -1434.699f, 29.6552f };
uParam0->f_3 = 141.6114f;
uParam0->f_4 = func_308(1, 2);
uParam0->f_12 = 1;
MISC::SET_BIT(&(uParam0->f_9), 19);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 4:
*uParam0 = { 10.9281f, 545.669f, 174.7951f };
uParam0->f_3 = 61.392f;
uParam0->f_4 = func_308(1, 1);
uParam0->f_12 = 1;
MISC::SET_BIT(&(uParam0->f_9), 20);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 5:
*uParam0 = { 6.1093f, 544.9742f, 174.2835f };
uParam0->f_3 = 92.1548f;
uParam0->f_4 = func_308(1, 2);
uParam0->f_12 = 1;
MISC::SET_BIT(&(uParam0->f_9), 19);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 6:
*uParam0 = { 1981.416f, 3808.131f, 31.1384f };
uParam0->f_3 = 117.2557f;
uParam0->f_4 = func_308(2, 1);
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 20);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 7:
*uParam0 = { -1158.488f, -1529.367f, 3.8995f };
uParam0->f_3 = 35.7505f;
uParam0->f_4 = func_308(2, 1);
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 20);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 8:
*uParam0 = { 148.2868f, -1270.569f, 28.2252f };
uParam0->f_3 = 208.4685f;
uParam0->f_4 = func_308(2, 1);
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 20);
MISC::SET_BIT(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 9:
*uParam0 = { 1459.509f, -1380.45f, 78.3259f };
uParam0->f_3 = 99.6211f;
uParam0->f_4 = joaat("scorcher");
MISC::SET_BIT(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 10:
*uParam0 = { -1518.947f, -1387.865f, -0.5134f };
uParam0->f_3 = 98.3867f;
uParam0->f_4 = joaat("seashark");
iVar0 = 1;
MISC::SET_BIT(&(uParam0->f_9), 6);
break;
case 11:
*uParam0 = { 353.0926f, 3577.593f, 32.351f };
uParam0->f_3 = 16.6205f;
uParam0->f_4 = joaat("duster");
iVar0 = 1;
MISC::SET_BIT(&(uParam0->f_9), 6);
break;
case 12:
uParam0->f_14 = 0;
*uParam0 = { -1652.004f, -3142.348f, 12.9921f };
uParam0->f_3 = 329.1082f;
uParam0->f_12 = 0;
uParam0->f_13 = 359;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 13:
uParam0->f_14 = 1;
*uParam0 = { -1271.649f, -3380.685f, 12.9451f };
uParam0->f_3 = 329.5137f;
uParam0->f_12 = 1;
uParam0->f_13 = 359;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 14:
uParam0->f_14 = 2;
*uParam0 = { 1735.586f, 3294.531f, 40.1651f };
uParam0->f_3 = 194.9525f;
uParam0->f_12 = 2;
uParam0->f_13 = 359;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 15:
uParam0->f_14 = 3;
*uParam0 = { -846.27f, -1363.19f, 0.22f };
uParam0->f_3 = 108.78f;
uParam0->f_12 = 0;
uParam0->f_13 = 356;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 22);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 16:
uParam0->f_14 = 4;
*uParam0 = { -849.47f, -1354.99f, 0.24f };
uParam0->f_3 = 109.84f;
uParam0->f_12 = 1;
uParam0->f_13 = 356;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 22);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 17:
uParam0->f_14 = 5;
*uParam0 = { -852.47f, -1346.2f, 0.21f };
uParam0->f_3 = 108.76f;
uParam0->f_12 = 2;
uParam0->f_13 = 356;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 22);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 18:
uParam0->f_14 = 6;
*uParam0 = { -745.857f, -1433.904f, 4.0005f };
uParam0->f_12 = 0;
uParam0->f_13 = 360;
uParam0->f_15 = { -756.2952f, -1441.609f, 2.9184f };
uParam0->f_18 = { -738.0606f, -1423.068f, 8.2835f };
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 19:
uParam0->f_14 = 7;
*uParam0 = { -761.8486f, -1453.829f, 4.0005f };
uParam0->f_12 = 1;
uParam0->f_13 = 360;
uParam0->f_15 = { -772.8158f, -1459.957f, 3.2894f };
uParam0->f_18 = { -754.3353f, -1440.836f, 8.3334f };
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 20:
uParam0->f_14 = 8;
*uParam0 = { 1769.3f, 3244f, 41.1f };
uParam0->f_12 = 2;
uParam0->f_13 = 360;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 21:
uParam0->f_14 = 9;
*uParam0 = { 192.7897f, -1020.539f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = 0;
uParam0->f_13 = 357;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 24);
MISC::SET_BIT(&(uParam0->f_9), 28);
MISC::SET_BIT(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 22:
uParam0->f_14 = 10;
*uParam0 = { 192.7897f, -1020.539f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = 1;
uParam0->f_13 = 357;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 24);
MISC::SET_BIT(&(uParam0->f_9), 28);
MISC::SET_BIT(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 23:
uParam0->f_14 = 11;
*uParam0 = { 192.7897f, -1020.539f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = 2;
uParam0->f_13 = 357;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 14);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 24);
MISC::SET_BIT(&(uParam0->f_9), 28);
MISC::SET_BIT(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 26:
case 27:
case 28:
iVar1 = (iParam1 - 26);
uParam0->f_14 = (12 + iVar1);
*uParam0 = { 196.2794f, -1020.479f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = (0 + iVar1);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 27);
MISC::SET_BIT(&(uParam0->f_9), 24);
MISC::SET_BIT(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 29:
case 30:
case 31:
iVar1 = (iParam1 - 29);
uParam0->f_14 = (15 + iVar1);
*uParam0 = { 199.8872f, -1020.048f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = (0 + iVar1);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 27);
MISC::SET_BIT(&(uParam0->f_9), 24);
MISC::SET_BIT(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 32:
case 33:
case 34:
iVar1 = (iParam1 - 32);
uParam0->f_14 = (18 + iVar1);
*uParam0 = { 203.6006f, -1019.776f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = (0 + iVar1);
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 12);
MISC::SET_BIT(&(uParam0->f_9), 7);
MISC::SET_BIT(&(uParam0->f_9), 27);
MISC::SET_BIT(&(uParam0->f_9), 24);
MISC::SET_BIT(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 24:
uParam0->f_14 = 21;
*uParam0 = { 0f, 0f, 0f };
uParam0->f_3 = 0f;
uParam0->f_4 = 0;
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 11);
MISC::SET_BIT(&(uParam0->f_9), 13);
MISC::SET_BIT(&(uParam0->f_9), 12);
iVar0 = 1;
break;
case 25:
uParam0->f_14 = 22;
*uParam0 = { 723.2515f, -632.0496f, 27.1484f };
uParam0->f_3 = 12.9316f;
uParam0->f_4 = joaat("tailgater");
MISC::SET_BIT(&(uParam0->f_9), 10);
MISC::SET_BIT(&(uParam0->f_9), 11);
MISC::SET_BIT(&(uParam0->f_9), 13);
MISC::SET_BIT(&(uParam0->f_9), 12);
iVar0 = 1;
break;
case 35:
*uParam0 = { -51.23f, 3111.9f, 24.95f };
uParam0->f_3 = 46.78f;
uParam0->f_4 = joaat("proptrailer");
MISC::SET_BIT(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 36:
*uParam0 = { -55.7984f, -1096.586f, 25.4223f };
uParam0->f_3 = 308.0596f;
uParam0->f_4 = joaat("bjxl");
uParam0->f_10 = 126;
uParam0->f_11 = 126;
MISC::SET_BIT(&(uParam0->f_9), 9);
MISC::SET_BIT(&(uParam0->f_9), 13);
iVar0 = 1;
break;
case 37:
*uParam0 = { -2892.93f, 3192.37f, 11.66f };
uParam0->f_3 = -132.35f;
uParam0->f_4 = joaat("velum");
uParam0->f_10 = 157;
uParam0->f_11 = 157;
MISC::SET_BIT(&(uParam0->f_9), 9);
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 13);
iVar0 = 1;
break;
case 38:
*uParam0 = { 1744.308f, 3270.673f, 40.2076f };
uParam0->f_3 = 125f;
uParam0->f_4 = joaat("cargobob3");
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 39:
*uParam0 = { 1751.44f, 3322.643f, 42.1855f };
uParam0->f_3 = 268.134f;
uParam0->f_4 = joaat("submersible");
MISC::SET_BIT(&(uParam0->f_9), 23);
iVar0 = 1;
break;
case 41:
*uParam0 = { 1377.104f, -2076.2f, 52f };
uParam0->f_3 = 37.5f;
uParam0->f_4 = joaat("towtruck");
MISC::SET_BIT(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 40:
*uParam0 = { 1380.42f, -2072.77f, 51.7607f };
uParam0->f_3 = 37.5f;
uParam0->f_4 = joaat("trash");
MISC::SET_BIT(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 42:
*uParam0 = { 1359.389f, 3618.441f, 33.8907f };
uParam0->f_3 = 108.2337f;
uParam0->f_4 = joaat("barracks");
MISC::SET_BIT(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 43:
*uParam0 = { 693.1154f, -1018.155f, 21.6387f };
uParam0->f_3 = 177.6454f;
uParam0->f_4 = joaat("firetruk");
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 44:
*uParam0 = { -73.6963f, 495.124f, 143.5226f };
uParam0->f_3 = 155.5994f;
uParam0->f_4 = joaat("vacca");
iVar0 = 1;
break;
case 45:
*uParam0 = { -67.6314f, 891.8266f, 234.5348f };
uParam0->f_3 = 294.993f;
uParam0->f_4 = joaat("surano");
iVar0 = 1;
break;
case 46:
*uParam0 = { 533.9048f, -169.2469f, 53.7005f };
uParam0->f_3 = 1.2998f;
uParam0->f_4 = joaat("tornado2");
iVar0 = 1;
break;
case 47:
*uParam0 = { -726.8914f, -408.6952f, 34.0416f };
uParam0->f_3 = 267.7392f;
uParam0->f_4 = joaat("superd");
iVar0 = 1;
break;
case 48:
*uParam0 = { -1321.519f, 261.3993f, 61.5709f };
uParam0->f_3 = 350.7697f;
uParam0->f_4 = joaat("double");
iVar0 = 1;
break;
case 49:
*uParam0 = { -1267.999f, 451.6463f, 93.7071f };
uParam0->f_3 = 48.9311f;
uParam0->f_4 = joaat("double");
iVar0 = 1;
break;
case 50:
*uParam0 = { -1062.076f, -226.7637f, 37.157f };
uParam0->f_3 = 234.2767f;
uParam0->f_4 = joaat("double");
iVar0 = 1;
break;
case 51:
*uParam0 = { 68.16914f, -1558.958f, 29.46904f };
uParam0->f_3 = 49.90575f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 52:
*uParam0 = { 589.4399f, 2736.708f, 42.03316f };
uParam0->f_3 = -175.7105f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 53:
*uParam0 = { -488.774f, -344.5721f, 34.36356f };
uParam0->f_3 = 82.4042f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 54:
*uParam0 = { 288.8808f, -585.4728f, 43.15428f };
uParam0->f_3 = -20.80707f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 55:
*uParam0 = { 304.8294f, -1383.674f, 31.67744f };
uParam0->f_3 = -41.11603f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 56:
*uParam0 = { 1126.194f, -1481.486f, 34.7016f };
uParam0->f_3 = -91.43369f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
MISC::SET_BIT(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 57:
*uParam0 = { -1598.36f, 5252.84f, 0f };
uParam0->f_3 = 28.14f;
uParam0->f_4 = joaat("submersible");
uParam0->f_13 = 308;
MISC::SET_BIT(&(uParam0->f_9), 2);
MISC::SET_BIT(&(uParam0->f_9), 30);
MISC::SET_BIT(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 58:
*uParam0 = { -1602.62f, 5260.37f, 0.86f };
uParam0->f_3 = 25.32f;
uParam0->f_4 = joaat("dinghy");
uParam0->f_13 = 404;
MISC::SET_BIT(&(uParam0->f_9), 2);
MISC::SET_BIT(&(uParam0->f_9), 22);
MISC::SET_BIT(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 59:
*uParam0 = { 2116.571f, 4763.279f, 40.1596f };
uParam0->f_3 = 198.723f;
uParam0->f_4 = joaat("bfinjection");
iVar0 = 1;
break;
case 60:
*uParam0 = { 1133.21f, 120.2f, 80.9f };
uParam0->f_3 = 134.4f;
if (func_299())
{
uParam0->f_4 = joaat("blimp2");
}
else
{
uParam0->f_4 = joaat("blimp");
}
uParam0->f_13 = 401;
MISC::SET_BIT(&(uParam0->f_9), 13);
MISC::SET_BIT(&(uParam0->f_9), 2);
MISC::SET_BIT(&(uParam0->f_9), true);
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 21);
iVar0 = 1;
break;
case 61:
*uParam0 = { -806.31f, -2679.65f, 13.9f };
uParam0->f_3 = 150.54f;
if (func_299())
{
uParam0->f_4 = joaat("blimp2");
}
else
{
uParam0->f_4 = joaat("blimp");
}
uParam0->f_13 = 401;
MISC::SET_BIT(&(uParam0->f_9), 13);
MISC::SET_BIT(&(uParam0->f_9), 2);
MISC::SET_BIT(&(uParam0->f_9), true);
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 21);
iVar0 = 1;
break;
case 62:
*uParam0 = { 1985.85f, 3828.96f, 31.98f };
uParam0->f_3 = -16.58f;
uParam0->f_4 = joaat("blazer3");
MISC::SET_BIT(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 63:
*uParam0 = { 3870.75f, 4464.67f, 0f };
uParam0->f_3 = 0f;
uParam0->f_4 = joaat("submersible2");
uParam0->f_13 = 308;
MISC::SET_BIT(&(uParam0->f_9), false);
MISC::SET_BIT(&(uParam0->f_9), 21);
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 6);
MISC::SET_BIT(&(uParam0->f_9), 30);
iVar0 = 1;
break;
case 64:
*uParam0 = { 1257.729f, -2564.474f, 41.717f };
uParam0->f_3 = 284.5561f;
uParam0->f_4 = joaat("dukes2");
MISC::SET_BIT(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 65:
*uParam0 = { 643.2823f, 3014.152f, 42.2733f };
uParam0->f_3 = 128.0554f;
uParam0->f_4 = joaat("dukes2");
MISC::SET_BIT(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 66:
*uParam0 = { 38.9368f, 850.8677f, 196.3f };
uParam0->f_3 = 311.6813f;
uParam0->f_4 = joaat("dodo");
MISC::SET_BIT(&(uParam0->f_9), 30);
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 67:
*uParam0 = { 1333.875f, 4262.226f, 30.78f };
uParam0->f_3 = 262.5293f;
uParam0->f_4 = joaat("dodo");
MISC::SET_BIT(&(uParam0->f_9), 30);
MISC::SET_BIT(&(uParam0->f_9), 23);
MISC::SET_BIT(&(uParam0->f_9), 6);
iVar0 = 1;
break;
}
if (BitTest(uParam0->f_9, 10))
{
uParam0->f_4 = Global_112922.f_32749.f_69[uParam0->f_14 /*78*/].f_66;
if (iParam1 == 14)
{
if (((((uParam0->f_4 == joaat("miljet") || uParam0->f_4 == joaat("besra")) || uParam0->f_4 == joaat("luxor")) || uParam0->f_4 == joaat("shamal")) || uParam0->f_4 == joaat("titan")) || uParam0->f_4 == joaat("luxor2"))
{
*uParam0 = { 1678.8f, 3229.6f, 41.8f };
uParam0->f_3 = 106.0906f;
}
}
if (!func_317(Global_112922.f_32749.f_1864[uParam0->f_14 /*3*/], 0f, 0f, 0f, 0))
{
*uParam0 = { Global_112922.f_32749.f_1864[uParam0->f_14 /*3*/] };
}
if (Global_112922.f_32749.f_1934[uParam0->f_14] != -1f)
{
uParam0->f_3 = Global_112922.f_32749.f_1934[uParam0->f_14];
}
}
if (BitTest(uParam0->f_9, 19))
{
if (!func_317(Global_112922.f_2363.f_539.f_3588[1 /*10*/][uParam0->f_12 /*3*/], 0f, 0f, 0f, 0))
{
*uParam0 = { Global_112922.f_2363.f_539.f_3588[1 /*10*/][uParam0->f_12 /*3*/] };
uParam0->f_3 = Global_112922.f_2363.f_539.f_3609[1 /*4*/][uParam0->f_12];
}
}
else if (BitTest(uParam0->f_9, 20))
{
if (!func_317(Global_112922.f_2363.f_539.f_3588[0 /*10*/][uParam0->f_12 /*3*/], 0f, 0f, 0f, 0))
{
*uParam0 = { Global_112922.f_2363.f_539.f_3588[0 /*10*/][uParam0->f_12 /*3*/] };
uParam0->f_3 = Global_112922.f_2363.f_539.f_3609[0 /*4*/][uParam0->f_12];
}
}
return iVar0;
}
int func_308(int iParam0, int iParam1)
{
struct<82> Var0;
if (func_39(iParam0))
{
Var0.f_11 = 12;
Var0.f_31 = 49;
Var0.f_81 = 2;
func_309(iParam0, &Var0, iParam1);
return Var0.f_0;
}
else if (iParam0 != 145)
{
}
return 0;
}
void func_309(int iParam0, var uParam1, int iParam2)
{
int iVar0;
uParam1->f_88 = 1;
uParam1->f_84 = 255;
uParam1->f_85 = 255;
uParam1->f_86 = 255;
uParam1->f_97 = 1;
uParam1->f_3 = 1000;
uParam1->f_1 = 0;
switch (iParam0)
{
case 0:
iVar0 = joaat("tailgater");
if (Global_112922.f_9085.f_99.f_58[128] && !Global_112922.f_9085.f_99.f_58[131])
{
iVar0 = joaat("premier");
}
switch (iVar0)
{
case joaat("tailgater"):
*uParam1 = iVar0;
uParam1->f_2 = 3f;
uParam1->f_4 = 0;
uParam1->f_9 = 1;
uParam1->f_11[0] = 1;
StringCopy(&(uParam1->f_27), "5MDS003", 16);
break;
case joaat("premier"):
*uParam1 = iVar0;
uParam1->f_2 = 14.9f;
uParam1->f_5 = 43;
uParam1->f_6 = 43;
uParam1->f_7 = 0;
uParam1->f_8 = 156;
uParam1->f_9 = 0;
StringCopy(&(uParam1->f_27), "880HS955", 16);
break;
}
break;
case 2:
iVar0 = joaat("bodhi2");
switch (iVar0)
{
case joaat("bodhi2"):
*uParam1 = iVar0;
uParam1->f_2 = 14f;
uParam1->f_5 = 32;
uParam1->f_6 = 0;
uParam1->f_7 = 0;
uParam1->f_8 = 156;
StringCopy(&(uParam1->f_27), "BETTY 32", 16);
if (Global_112922.f_9085.f_99.f_58[119])
{
uParam1->f_11[1] = 1;
}
break;
}
break;
case 1:
if (iParam2 == 1)
{
iVar0 = joaat("buffalo2");
}
else if (iParam2 == 2)
{
iVar0 = joaat("bagger");
}
else if (Global_112922.f_9085.f_99.f_58[118])
{
iVar0 = joaat("bagger");
}
else
{
iVar0 = joaat("buffalo2");
}
switch (iVar0)
{
case joaat("bagger"):
*uParam1 = iVar0;
uParam1->f_2 = 6f;
uParam1->f_5 = 53;
uParam1->f_6 = 0;
uParam1->f_7 = 59;
uParam1->f_8 = 156;
StringCopy(&(uParam1->f_27), "FC88", 16);
break;
case joaat("buffalo2"):
*uParam1 = iVar0;
uParam1->f_2 = 0f;
uParam1->f_5 = 111;
uParam1->f_6 = 111;
uParam1->f_7 = 0;
uParam1->f_8 = 156;
uParam1->f_10 = 1;
StringCopy(&(uParam1->f_27), "FC1988", 16);
uParam1->f_11[0] = 1;
uParam1->f_11[1] = 1;
uParam1->f_11[2] = 1;
uParam1->f_11[3] = 1;
uParam1->f_11[4] = 1;
uParam1->f_11[5] = 1;
uParam1->f_11[6] = 1;
uParam1->f_11[7] = 1;
uParam1->f_11[8] = 1;
break;
}
break;
default:
break;
}
}
void func_310(int iParam0, var uParam1, struct<3> Param2, float fParam5, int iParam6)
{
if (func_307(&(Global_76676.f_555[0 /*21*/]), iParam0))
{
if (BitTest(Global_76676.f_555[0 /*21*/].f_9, 10))
{
func_315(iParam0);
func_314(uParam1, &(Global_112922.f_32749.f_69[Global_76676.f_555[0 /*21*/].f_14 /*78*/]));
if (BitTest(Global_76676.f_555[0 /*21*/].f_9, 11))
{
Global_112922.f_32749.f_1864[Global_76676.f_555[0 /*21*/].f_14 /*3*/] = { Param2 };
Global_112922.f_32749.f_1934[Global_76676.f_555[0 /*21*/].f_14] = fParam5;
}
else
{
Global_112922.f_32749.f_1864[Global_76676.f_555[0 /*21*/].f_14 /*3*/] = { 0f, 0f, 0f };
Global_112922.f_32749.f_1934[Global_76676.f_555[0 /*21*/].f_14] = -1f;
}
Global_112922.f_32749.f_1958[Global_76676.f_555[0 /*21*/].f_14] = iParam6 + 1;
func_311(iParam0, 1);
}
}
}
void func_311(int iParam0, bool bParam1)
{
if (iParam0 == -1)
{
return;
}
if (bParam1)
{
if (!func_313(iParam0, 0))
{
func_312(iParam0, 1, 0);
func_312(iParam0, 2, 0);
func_312(iParam0, 3, 0);
func_312(iParam0, 4, 0);
func_312(iParam0, 0, 1);
Global_76676[iParam0] = 1;
}
}
else
{
func_312(iParam0, 0, 0);
}
}
void func_312(int iParam0, bool bParam1, bool bParam2)
{
if (iParam0 == -1)
{
return;
}
if (bParam2)
{
MISC::SET_BIT(&(Global_112922.f_32749[iParam0]), bParam1);
}
else
{
MISC::CLEAR_BIT(&(Global_112922.f_32749[iParam0]), bParam1);
}
}
int func_313(int iParam0, int iParam1)
{
if (iParam0 == -1)
{
return 0;
}
return BitTest(Global_112922.f_32749[iParam0], iParam1);
}
void func_314(var uParam0, var uParam1)
{
uParam1->f_66 = uParam0->f_66;
*uParam1 = *uParam0;
uParam1->f_1 = { uParam0->f_1 };
uParam1->f_5 = uParam0->f_5;
uParam1->f_6 = uParam0->f_6;
uParam1->f_7 = uParam0->f_7;
uParam1->f_8 = uParam0->f_8;
uParam1->f_9 = { uParam0->f_9 };
uParam1->f_59 = { uParam0->f_59 };
uParam1->f_62 = uParam0->f_62;
uParam1->f_63 = uParam0->f_63;
uParam1->f_64 = uParam0->f_64;
uParam1->f_65 = uParam0->f_65;
uParam1->f_77 = uParam0->f_77;
uParam1->f_67 = uParam0->f_67;
uParam1->f_69 = uParam0->f_69;
uParam1->f_68 = uParam0->f_68;
uParam1->f_71 = uParam0->f_71;
uParam1->f_72 = uParam0->f_72;
uParam1->f_73 = uParam0->f_73;
uParam1->f_74 = uParam0->f_74;
uParam1->f_75 = uParam0->f_75;
uParam1->f_76 = uParam0->f_76;
}
void func_315(int iParam0)
{
if (iParam0 == -1)
{
return;
}
if (func_307(&(Global_76676.f_555[0 /*21*/]), iParam0))
{
if (ENTITY::DOES_ENTITY_EXIST(Global_76676.f_139[iParam0]))
{
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(Global_76676.f_139[iParam0], true, true);
ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&(Global_76676.f_139[iParam0]));
Global_76676.f_139[iParam0] = 0;
}
if (BitTest(Global_76676.f_555[0 /*21*/].f_9, 13))
{
func_311(iParam0, 0);
}
}
}
int func_316(int iParam0)
{
int iVar0;
if (!ENTITY::DOES_ENTITY_EXIST(iParam0))
{
return 145;
}
if (!VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false))
{
return 145;
}
iVar0 = 0;
while (iVar0 < 9)
{
if (ENTITY::DOES_ENTITY_EXIST(Global_97311[iVar0]))
{
if (Global_97311[iVar0] == iParam0)
{
return Global_97321[iVar0];
}
}
iVar0++;
}
return 145;
}
bool func_317(struct<3> Param0, struct<3> Param3, bool bParam6)
{
if (bParam6)
{
return (Param0.f_0 == Param3.f_0 && Param0.f_1 == Param3.f_1);
}
return ((Param0.f_0 == Param3.f_0 && Param0.f_1 == Param3.f_1) && Param0.f_2 == Param3.f_2);
}
void func_318(int iParam0, var uParam1)
{
int iVar0;
if (VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false))
{
func_322(uParam1);
uParam1->f_66 = ENTITY::GET_ENTITY_MODEL(iParam0);
StringCopy(&(uParam1->f_1), VEHICLE::GET_VEHICLE_NUMBER_PLATE_TEXT(iParam0), 16);
*uParam1 = VEHICLE::GET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(iParam0);
VEHICLE::GET_VEHICLE_COLOURS(iParam0, &(uParam1->f_5), &(uParam1->f_6));
VEHICLE::GET_VEHICLE_EXTRA_COLOURS(iParam0, &(uParam1->f_7), &(uParam1->f_8));
VEHICLE::GET_VEHICLE_TYRE_SMOKE_COLOR(iParam0, &(uParam1->f_62), &(uParam1->f_63), &(uParam1->f_64));
uParam1->f_65 = VEHICLE::GET_VEHICLE_WINDOW_TINT(iParam0);
uParam1->f_67 = VEHICLE::GET_VEHICLE_LIVERY(iParam0);
uParam1->f_69 = VEHICLE::GET_VEHICLE_WHEEL_TYPE(iParam0);
uParam1->f_70 = VEHICLE::GET_VEHICLE_DOOR_LOCK_STATUS(iParam0);
VEHICLE::GET_VEHICLE_CUSTOM_SECONDARY_COLOUR(iParam0, &(uParam1->f_71), &(uParam1->f_72), &(uParam1->f_73));
VEHICLE::_GET_VEHICLE_NEON_LIGHTS_COLOUR(iParam0, &(uParam1->f_74), &(uParam1->f_75), &(uParam1->f_76));
if (VEHICLE::_IS_VEHICLE_NEON_LIGHT_ENABLED(iParam0, 2))
{
MISC::SET_BIT(&(uParam1->f_77), 28);
}
if (VEHICLE::_IS_VEHICLE_NEON_LIGHT_ENABLED(iParam0, 3))
{
MISC::SET_BIT(&(uParam1->f_77), 29);
}
if (VEHICLE::_IS_VEHICLE_NEON_LIGHT_ENABLED(iParam0, 0))
{
MISC::SET_BIT(&(uParam1->f_77), 30);
}
if (VEHICLE::_IS_VEHICLE_NEON_LIGHT_ENABLED(iParam0, 1))
{
MISC::SET_BIT(&(uParam1->f_77), 31);
}
if (uParam1->f_65 == -1 && !func_321(uParam1->f_66))
{
uParam1->f_65 = 0;
}
if (VEHICLE::IS_VEHICLE_A_CONVERTIBLE(iParam0, false))
{
uParam1->f_68 = VEHICLE::GET_CONVERTIBLE_ROOF_STATE(iParam0);
}
if (VEHICLE::IS_THIS_MODEL_A_PLANE(uParam1->f_66))
{
if (VEHICLE::IS_PLANE_LANDING_GEAR_INTACT(iParam0))
{
switch (VEHICLE::GET_LANDING_GEAR_STATE(iParam0))
{
case 3:
case 0:
MISC::CLEAR_BIT(&(uParam1->f_77), 23);
MISC::SET_BIT(&(uParam1->f_77), 22);
break;
case 4:
case 1:
MISC::CLEAR_BIT(&(uParam1->f_77), 23);
MISC::CLEAR_BIT(&(uParam1->f_77), 22);
break;
case 5:
MISC::SET_BIT(&(uParam1->f_77), 23);
break;
}
}
else
{
MISC::SET_BIT(&(uParam1->f_77), 23);
}
}
if (!VEHICLE::GET_VEHICLE_TYRES_CAN_BURST(iParam0))
{
MISC::SET_BIT(&(uParam1->f_77), 9);
}
if (VEHICLE::IS_VEHICLE_STOLEN(iParam0))
{
MISC::SET_BIT(&(uParam1->f_77), 10);
}
if (VEHICLE::GET_IS_VEHICLE_PRIMARY_COLOUR_CUSTOM(iParam0))
{
MISC::SET_BIT(&(uParam1->f_77), 13);
VEHICLE::GET_VEHICLE_CUSTOM_PRIMARY_COLOUR(iParam0, &(uParam1->f_71), &(uParam1->f_72), &(uParam1->f_73));
}
if (VEHICLE::GET_IS_VEHICLE_SECONDARY_COLOUR_CUSTOM(iParam0))
{
MISC::SET_BIT(&(uParam1->f_77), 12);
}
func_320(&iParam0, &(uParam1->f_9), &(uParam1->f_59));
iVar0 = 0;
while (iVar0 <= 11)
{
if (VEHICLE::IS_VEHICLE_EXTRA_TURNED_ON(iParam0, iVar0 + 1))
{
MISC::SET_BIT(&(uParam1->f_77), func_319(iVar0 + 1));
}
iVar0++;
}
if (GRAPHICS::DOES_VEHICLE_HAVE_CREW_EMBLEM(iParam0, 0))
{
MISC::SET_BIT(&(uParam1->f_77), 11);
}
else
{
MISC::CLEAR_BIT(&(uParam1->f_77), 11);
}
if (DECORATOR::DECOR_EXIST_ON(iParam0, "IgnoredByQuickSave") && DECORATOR::DECOR_GET_BOOL(iParam0, "IgnoredByQuickSave"))
{
MISC::SET_BIT(&(uParam1->f_77), 27);
}
else
{
MISC::CLEAR_BIT(&(uParam1->f_77), 27);
}
}
}
int func_319(int iParam0)
{
switch (iParam0)
{
case 1:
return 0;
break;
case 2:
return 1;
break;
case 3:
return 2;
break;
case 4:
return 3;
break;
case 5:
return 4;
break;
case 6:
return 5;
break;
case 7:
return 6;
break;
case 8:
return 7;
break;
case 9:
return 8;
break;
case 10:
return 24;
break;
case 11:
return 25;
break;
case 12:
return 26;
break;
}
return 0;
}
int func_320(int iParam0, var uParam1, var uParam2)
{
int iVar0;
int iVar1;
if (!VEHICLE::IS_VEHICLE_DRIVEABLE(*iParam0, false))
{
return 0;
}
if (VEHICLE::GET_NUM_MOD_KITS(*iParam0) == 0)
{
return 0;
}
iVar0 = 0;
while (iVar0 < *uParam1)
{
iVar1 = iVar0;
if ((((iVar1 == 17 || iVar1 == 18) || iVar1 == 19) || iVar1 == 20) || iVar1 == 21)
{
(*uParam1)[iVar0] = 0;
if (VEHICLE::IS_TOGGLE_MOD_ON(*iParam0, iVar1))
{
(*uParam1)[iVar0] = 1;
}
}
else if (iVar1 == 22)
{
if (VEHICLE::IS_TOGGLE_MOD_ON(*iParam0, iVar1))
{
switch (VEHICLE::_GET_VEHICLE_XENON_LIGHTS_COLOR(*iParam0))
{
case 255:
(*uParam1)[iVar0] = 1;
break;
case 0:
(*uParam1)[iVar0] = 2;
break;
case 1:
(*uParam1)[iVar0] = 3;
break;
case 2:
(*uParam1)[iVar0] = 4;
break;
case 3:
(*uParam1)[iVar0] = 5;
break;
case 4:
(*uParam1)[iVar0] = 6;
break;
case 5:
(*uParam1)[iVar0] = 7;
break;
case 6:
(*uParam1)[iVar0] = 8;
break;
case 7:
(*uParam1)[iVar0] = 9;
break;
case 8:
(*uParam1)[iVar0] = 10;
break;
case 9:
(*uParam1)[iVar0] = 11;
break;
case 10:
(*uParam1)[iVar0] = 12;
break;
case 11:
(*uParam1)[iVar0] = 13;
break;
case 12:
(*uParam1)[iVar0] = 14;
break;
case 13:
(*uParam1)[iVar0] = 15;
break;
}
}
else
{
(*uParam1)[iVar0] = 0;
}
}
else
{
(*uParam1)[iVar0] = VEHICLE::GET_VEHICLE_MOD(*iParam0, iVar0) + 1;
if (iVar0 == 23)
{
(*uParam2)[0] = VEHICLE::GET_VEHICLE_MOD_VARIATION(*iParam0, iVar0);
}
else if (iVar0 == 24)
{
(*uParam2)[1] = VEHICLE::GET_VEHICLE_MOD_VARIATION(*iParam0, iVar0);
}
}
iVar0++;
}
return 1;
}
int func_321(int iParam0)
{
switch (iParam0)
{
case joaat("granger"):
case joaat("visione"):
return 1;
default:
}
return 0;
}
void func_322(var uParam0)
{
int iVar0;
uParam0->f_66 = 0;
uParam0->f_77 = 0;
uParam0->f_65 = 0;
uParam0->f_62 = 0;
uParam0->f_63 = 0;
uParam0->f_64 = 0;
uParam0->f_74 = 0;
uParam0->f_75 = 0;
uParam0->f_76 = 0;
*uParam0 = 0;
StringCopy(&(uParam0->f_1), "", 16);
uParam0->f_5 = 0;
uParam0->f_6 = 0;
uParam0->f_7 = 0;
uParam0->f_8 = 0;
iVar0 = 0;
while (iVar0 < 49)
{
uParam0->f_9[iVar0] = 0;
iVar0++;
}
iVar0 = 0;
while (iVar0 < 2)
{
uParam0->f_59[iVar0] = 0;
iVar0++;
}
uParam0->f_67 = 0;
uParam0->f_68 = 0;
uParam0->f_69 = 0;
uParam0->f_70 = 1;
uParam0->f_71 = 0;
uParam0->f_72 = 0;
uParam0->f_73 = 0;
}
void func_323(int iParam0)
{
if (iParam0 != 24 && iParam0 != 25)
{
}
func_315(iParam0);
func_311(iParam0, 0);
}
float func_324(int iParam0)
{
switch (iParam0)
{
case 0:
return 192.1528f;
case 1:
return 144.2205f;
case 2:
return 82.0341f;
case 3:
return 134.9389f;
case 4:
return 241.8704f;
case 5:
return 342.318f;
case 6:
return 174.9318f;
case 7:
return 186.4915f;
case 8:
return 93.0806f;
case 9:
return 213.7284f;
case 10:
return 55.5964f;
case 11:
return 61.2421f;
case 12:
return 304.1476f;
default:
}
return 0f;
return 0f;
}
Vector3 func_325(int iParam0)
{
switch (iParam0)
{
case 0:
return -835.2823f, -1303.246f, 4.0004f;
case 1:
return 1236.613f, 143.0208f, 80.8622f;
case 2:
return 2463.523f, 1495.492f, 34.8794f;
case 3:
return -262.0742f, 6590.702f, 0.9787f;
case 4:
return -45.396f, -784.1727f, 43.2721f;
case 5:
return -182.8192f, -890.5899f, 28.3452f;
case 6:
return -1236.648f, 4557.094f, 185.7374f;
case 7:
return -731.5519f, 4497.153f, 75.5991f;
case 8:
return -790.7881f, 293.895f, 84.7917f;
case 9:
return -1426.048f, 4408.049f, 46.1198f;
case 10:
return 2491.808f, 5001.821f, 44.1871f;
case 11:
return 1067.101f, -198.2404f, 68.6323f;
case 12:
return -762.3691f, 4301.332f, 145.2817f;
default:
}
return 0f, 0f, 0f;
return 0f, 0f, 0f;
}
int func_326(int iParam0)
{
if (ENTITY::DOES_ENTITY_EXIST(iParam0))
{
if (ENTITY::IS_ENTITY_DEAD(iParam0, false))
{
return 1;
}
else if (!VEHICLE::IS_VEHICLE_DRIVEABLE(iParam0, false))
{
if (!FIRE::IS_ENTITY_ON_FIRE(iParam0))
{
return 1;
}
}
}
else
{
return 1;
}
return 0;
}
void func_327(int* iParam0)
{
if (*iParam0 != 0)
{
GRAPHICS::SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(iParam0);
*iParam0 = 0;
}
iParam0->f_1 = 0;
iParam0->f_2 = 0;
iParam0->f_12[0] = 0;
iParam0->f_12[1] = 0;
iParam0->f_12[2] = 0;
iParam0->f_12[3] = 0;
iParam0->f_12[4] = 0;
iParam0->f_12[5] = 0;
iParam0->f_12[6] = 0;
iParam0->f_12[7] = 0;
iParam0->f_3[0] = 361;
iParam0->f_3[1] = 361;
iParam0->f_3[2] = 361;
iParam0->f_3[3] = 361;
iParam0->f_3[4] = 361;
iParam0->f_3[5] = 361;
iParam0->f_3[6] = 361;
iParam0->f_3[7] = 361;
iParam0->f_21[0] = 0;
iParam0->f_21[1] = 0;
iParam0->f_21[2] = 0;
iParam0->f_21[3] = 0;
}
int func_328(var uParam0, bool bParam1, int iParam2)
{
if ((MISC::GET_GAME_TIMER() - uParam0->f_5) > iParam2)
{
uParam0->f_4 = MISC::GET_GAME_TIMER();
}
uParam0->f_5 = MISC::GET_GAME_TIMER();
if ((MISC::GET_GAME_TIMER() - uParam0->f_4) > iParam2)
{
if (BitTest(uParam0->f_2, bParam1) && !BitTest(uParam0->f_3, bParam1))
{
uParam0->f_4 = MISC::GET_GAME_TIMER();
return 1;
}
}
return 0;
}
int func_329(var uParam0, int* iParam1, struct<3> Param2, struct<3> Param5, struct<3> Param8, var uParam11, var uParam12)
{
struct<3> Var0;
switch (uParam0->f_3)
{
case 0:
if (func_461(iParam1) >= 0f)
{
Param8.f_2 = func_49(Param8.f_2, -8.909f, 8.909f);
uParam11->f_2 = (uParam11->f_2 + Param8.f_2);
Var0 = { func_463(Param5, Param8.f_2) };
CAM::SET_CAM_PARAMS(func_433(uParam0, 0), Param2 + Var0, *uParam11, *uParam12, 300, 1, 1, 2);
CAM::SET_CAM_ACTIVE_WITH_INTERP(func_433(uParam0, 1), func_433(uParam0, 0), SYSTEM::FLOOR((1000f * (1.1f - 0f))), 2, 1);
uParam0->f_3 = 1;
}
break;
case 1:
if (func_461(iParam1) >= 0f)
{
CAM::SET_GAMEPLAY_CAM_RELATIVE_HEADING(0f);
CAM::SET_GAMEPLAY_CAM_RELATIVE_PITCH(0f, 1f);
CAM::RENDER_SCRIPT_CAMS(false, true, SYSTEM::FLOOR((1000f * (1.1f - 0f))), false, false, 0);
uParam0->f_3 = 2;
}
break;
case 2:
if (func_461(iParam1) >= 1.1f)
{
uParam0->f_3 = 3;
return 1;
}
break;
case 3:
return 1;
break;
}
return 0;
}
void func_330(int iParam0, var uParam1, int* iParam2)
{
struct<3> Var0;
int iVar3;
int iVar4;
struct<3> Var5;
iVar3 = func_433(uParam1, 0);
iVar4 = func_433(uParam1, 1);
CAM::SET_CAM_NEAR_CLIP(iVar4, func_331());
Var5 = { ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(iParam0, 2f, -0.3f, -7.7824f) };
CAM::SET_CAM_COORD(iVar4, Var5);
Var0 = { CAM::GET_CAM_ROT(iVar3, 2) };
Var0.f_0 = 0f;
CAM::SET_CAM_ROT(iVar4, Var0, 2);
CAM::SET_CAM_FOV(iVar4, CAM::GET_CAM_FOV(iVar3));
CAM::RENDER_SCRIPT_CAMS(true, false, 3000, true, false, 0);
uParam1->f_3 = 0;
func_371(iParam2);
}
float func_331()
{
if (MISC::IS_PC_VERSION())
{
return 0.5f;
}
return 0.84f;
}
int func_332(var uParam0, var uParam1, var uParam2, int* iParam3, var uParam4, var uParam5, struct<3> Param6, struct<3> Param9)
{
int iVar0;
struct<3> Var1;
struct<3> Var4;
iVar0 = func_433(uParam1, 0);
Var1 = { func_335(uParam2) };
if (PAD::IS_LOOK_INVERTED())
{
Var1.f_1 = (Var1.f_1 * -1f);
}
if (!PAD::_IS_USING_KEYBOARD(2))
{
uParam5->f_2 = (uParam5->f_2 - ((Var1.f_0 * MISC::GET_FRAME_TIME()) * 100f));
*uParam5 = (*uParam5 + ((Var1.f_1 * MISC::GET_FRAME_TIME()) * 100f));
if (MISC::ABSF(uParam5->f_2) > 0.001f)
{
uParam5->f_2 = (uParam5->f_2 - ((uParam5->f_2 * MISC::GET_FRAME_TIME()) * 4f));
}
else
{
uParam5->f_2 = 0f;
}
if (MISC::ABSF(*uParam5) > 0.001f)
{
*uParam5 = (*uParam5 - ((*uParam5 * MISC::GET_FRAME_TIME()) * 5f));
}
else
{
*uParam5 = 0f;
}
}
else
{
uParam5->f_2 = (-Var1.f_0 * 130f);
*uParam5 = (Var1.f_1 * 130f);
}
uParam4->f_2 = (uParam4->f_2 + (uParam5->f_2 * MISC::GET_FRAME_TIME()));
if (uParam4->f_2 > (0.5f * 43.7465f))
{
uParam4->f_2 = (0.5f * 43.7465f);
uParam5->f_2 = 0f;
}
else if (uParam4->f_2 < (-0.5f * 43.7465f))
{
uParam4->f_2 = (-0.5f * 43.7465f);
uParam5->f_2 = 0f;
}
*uParam4 = (*uParam4 + (*uParam5 * MISC::GET_FRAME_TIME()));
if (*uParam4 > (0.5f * 21.6f))
{
*uParam4 = (0.5f * 21.6f);
*uParam5 = 0f;
}
else if (*uParam4 < (-0.5f * 21.6f))
{
*uParam4 = (-0.5f * 21.6f);
*uParam5 = 0f;
}
Var4 = { func_463(Param9, uParam4->f_2) };
CAM::SET_CAM_COORD(iVar0, Param6 + Var4);
CAM::SET_CAM_ROT(iVar0, (-33f + *uParam4), 0f, ((-88.515f + func_464(uParam0)) + uParam4->f_2), 2);
CAM::SET_CAM_NEAR_CLIP(iVar0, func_331());
if (!CAM::IS_SCREEN_FADED_IN() || !func_462(iParam3))
{
func_371(iParam3);
}
else
{
if (!HUD::IS_HELP_MESSAGE_BEING_DISPLAYED())
{
func_334("BJ_VLOOKHLP");
}
if (func_462(iParam3) && func_461(iParam3) > 0.5f)
{
if (func_333(uParam2, 1))
{
func_458(iParam3);
CAM::DETACH_CAM(iVar0);
return 1;
}
}
}
return 0;
}
bool func_333(var uParam0, bool bParam1)
{
return (BitTest(uParam0->f_2, bParam1) && !BitTest(uParam0->f_3, bParam1));
}
void func_334(char* sParam0)
{
HUD::BEGIN_TEXT_COMMAND_DISPLAY_HELP(sParam0);
HUD::END_TEXT_COMMAND_DISPLAY_HELP(0, true, true, -1);
}
Vector3 func_335(var uParam0)
{
return *uParam0, uParam0->f_1, 0f;
}
void func_336(int iParam0, struct<3> Param1)
{
float fVar0;
float fVar1;
float fVar2;
fVar0 = (0.006f * SYSTEM::SIN((((0.25f * 0.5f) * SYSTEM::TO_FLOAT(MISC::GET_GAME_TIMER())) + 1.5f)));
fVar1 = (0.006f * SYSTEM::SIN((((0.25f * 0.4f) * SYSTEM::TO_FLOAT(MISC::GET_GAME_TIMER())) + 3f)));
fVar2 = (0.006f * SYSTEM::SIN(((0.25f * 1f) * SYSTEM::TO_FLOAT(MISC::GET_GAME_TIMER()))));
if (!ENTITY::IS_ENTITY_DEAD(iParam0, false))
{
ENTITY::SET_ENTITY_COORDS(iParam0, Param1 + Vector(fVar2, fVar1, fVar0), true, false, false, true);
}
}
bool func_337(char* sParam0)
{
HUD::BEGIN_TEXT_COMMAND_IS_THIS_HELP_MESSAGE_BEING_DISPLAYED(sParam0);
return HUD::END_TEXT_COMMAND_IS_THIS_HELP_MESSAGE_BEING_DISPLAYED(0);
}
void func_338(char* sParam0, int iParam1)
{
HUD::BEGIN_TEXT_COMMAND_DISPLAY_HELP(sParam0);
HUD::END_TEXT_COMMAND_DISPLAY_HELP(0, false, true, iParam1);
}
void func_339(var uParam0, bool bParam1)
{
if (bParam1)
{
if (AUDIO::IS_AUDIO_SCENE_ACTIVE("BASEJUMPS_PREP_FOR_JUMP_ON_FOOT"))
{
AUDIO::STOP_AUDIO_SCENE("BASEJUMPS_PREP_FOR_JUMP_ON_FOOT");
func_221(uParam0, 20, 0);
}
}
else if (AUDIO::IS_AUDIO_SCENE_ACTIVE("BASEJUMPS_PREP_FOR_JUMP_MOTO"))
{
AUDIO::STOP_AUDIO_SCENE("BASEJUMPS_PREP_FOR_JUMP_MOTO");
func_221(uParam0, 20, 0);
}
}
void func_340(char* sParam0, int iParam1, int iParam2)
{
iParam2 = iParam2;
HUD::BEGIN_TEXT_COMMAND_PRINT(sParam0);
HUD::END_TEXT_COMMAND_PRINT(iParam1, true);
}
struct<4> func_341(bool bParam0)
{
struct<4> Var0;
switch (bParam0)
{
case 3:
case 12:
case 6:
StringCopy(&Var0, "BJ_OBJ_JCL", 16);
break;
case 4:
StringCopy(&Var0, "BJ_OBJ_JDB", 16);
break;
case 5:
StringCopy(&Var0, "BJ_OBJ_JCR", 16);
break;
case 8:
StringCopy(&Var0, "BJ_OBJ_JB", 16);
break;
default:
break;
}
return Var0;
}
void func_342(int* iParam0, float fParam1)
{
if (!func_462(iParam0))
{
func_42(iParam0, fParam1);
}
}
void func_343(int* iParam0, int iParam1)
{
if (func_462(iParam0))
{
if (func_345(iParam0, (7.5f * IntToFloat(*iParam1))))
{
*iParam1++;
func_217(PLAYER::PLAYER_PED_ID(), "BASEJUMP_ABOUT_TO_JUMP", 24);
}
}
else if (!func_344())
{
func_342(iParam0, 0f);
}
}
int func_344()
{
if (Global_21285 != 0 || AUDIO::IS_SCRIPTED_CONVERSATION_ONGOING())
{
return 1;
}
return 0;
}
int func_345(int* iParam0, float fParam1)
{
if (func_346(iParam0, fParam1))
{
func_458(iParam0);
return 1;
}
return 0;
}
int func_346(int* iParam0, float fParam1)
{
if (func_462(iParam0))
{
if (func_461(iParam0) > fParam1)
{
return 1;
}
}
return 0;
}
void func_347(int* iParam0)
{
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
WEAPON::GET_CURRENT_PED_WEAPON(PLAYER::PLAYER_PED_ID(), iParam0, true);
if ((((*iParam0 != 0 && *iParam0 != joaat("weapon_unarmed")) && *iParam0 != joaat("weapon_electric_fence")) && *iParam0 != joaat("gadget_parachute")) && *iParam0 != joaat("object"))
{
WEAPON::GIVE_WEAPON_TO_PED(PLAYER::PLAYER_PED_ID(), joaat("weapon_unarmed"), -1, false, true);
}
PAD::DISABLE_CONTROL_ACTION(0, 37, true);
PAD::DISABLE_CONTROL_ACTION(0, 66, true);
PAD::DISABLE_CONTROL_ACTION(0, 67, true);
PAD::DISABLE_CONTROL_ACTION(0, 68, true);
PAD::DISABLE_CONTROL_ACTION(0, 99, true);
PAD::DISABLE_CONTROL_ACTION(0, 100, true);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(19);
}
}
int func_348(var uParam0, int iParam1, int iParam2, int iParam3, int iParam4, int iParam5, int iParam6, int iParam7, var uParam8, int iParam9, var uParam10, int* iParam11, int* iParam12, int iParam13, int iParam14, var uParam15, var uParam16, var uParam17, var uParam18, bool bParam19, bool bParam20, float fParam21)
{
struct<3> Var0;
var uVar3;
var uVar6;
struct<3> Var9;
struct<3> Var12;
struct<3> Var15;
struct<3> Var18;
struct<3> Var21;
struct<3> Var24;
struct<3> Var27;
struct<3> Var30;
float fVar33;
float fVar34;
float fVar35;
float fVar36;
bool bVar37;
bool bVar38;
int iVar39;
int iVar40;
int iVar41;
var uVar42;
var uVar43;
var uVar44;
Var12 = { func_369(uParam0, *iParam6) };
bVar37 = *iParam6 == (iParam9 - 1);
(*iParam3)[0] = (*iParam3)[0];
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
ENTITY::GET_ENTITY_MATRIX(PLAYER::PLAYER_PED_ID(), &Var0, &uVar3, &uVar6, &Var9);
}
if (bVar37)
{
if (ENTITY::DOES_ENTITY_EXIST(iParam1) && !ENTITY::IS_ENTITY_DEAD(iParam1, false))
{
Var27 = { ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(iParam1, func_370(uParam0)) };
fVar36 = (Var27.f_2 - Var12.f_2);
if (bParam20)
{
if (HUD::DOES_BLIP_EXIST(*iParam11))
{
HUD::SET_BLIP_COORDS(*iParam11, Var27);
}
else
{
*iParam11 = HUD::ADD_BLIP_FOR_COORD(Var27);
HUD::SET_BLIP_COLOUR(*iParam11, 5);
HUD::SET_BLIP_SCALE(*iParam11, 1.2f);
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(*iParam11, "BJ_BLIP_TGT");
}
}
Var30 = { func_369(uParam0, 0) };
Var27.f_2 = (Var30.f_2 + fVar36);
Var12 = { Var27 };
}
else if (func_368(uParam0) != 0)
{
Var27 = { func_369(uParam0, 0) };
Var12 = { Var27 };
}
else
{
Var27 = { Var12 };
}
Var18 = { Var9 - Var12 };
if (func_368(uParam0) == 0)
{
GRAPHICS::DRAW_MARKER(6, Var27, 0f, 0f, 1f, 0f, 0f, 0f, 4f, 4f, 4f, 240, 200, 80, func_357(Var27, 170, 200), false, false, 2, false, 0, 0, false);
GRAPHICS::DRAW_MARKER(6, Var27, 0f, 0f, 1f, 0f, 0f, 0f, 9f, 9f, 9f, 240, 200, 80, func_357(Var27, 170, 200), false, false, 2, false, 0, 0, false);
GRAPHICS::DRAW_MARKER(6, Var27, 0f, 0f, 1f, 0f, 0f, 0f, 14f, 14f, 14f, 240, 200, 80, func_357(Var27, 170, 200), false, false, 2, false, 0, 0, false);
}
if (*iParam7 != -1)
{
GRAPHICS::DELETE_CHECKPOINT(*iParam4);
*iParam7 = -1;
}
}
else
{
HUD::GET_HUD_COLOUR(134, &iVar39, &iVar40, &iVar41, &uVar42);
Var18 = { Var9 - Var12 };
Var15 = { func_369(uParam0, *iParam6 + 1) };
GRAPHICS::DRAW_MARKER(6, Var12, func_475(Var18), 0f, 0f, 0f, 14f, 14f, 14f, 240, 200, 80, func_357(Var12, 25, 200), false, false, 2, false, 0, 0, false);
if (*iParam7 != *iParam6)
{
if (*iParam7 >= 0)
{
GRAPHICS::DELETE_CHECKPOINT(*iParam4);
*iParam4 = 0;
if (*iParam7 < (iParam9 - 2))
{
GRAPHICS::DELETE_CHECKPOINT(*iParam5);
*iParam4 = 0;
}
}
*iParam4 = GRAPHICS::CREATE_CHECKPOINT(17, Var12, Var15, 9f, iVar39, iVar40, iVar41, func_357(Var27, 25, SYSTEM::CEIL((200f * (SYSTEM::TO_FLOAT(113) / SYSTEM::TO_FLOAT(170))))), 0);
if (*iParam6 < (iParam9 - 2))
{
*iParam5 = GRAPHICS::CREATE_CHECKPOINT(17, Var15, func_369(uParam0, *iParam6 + 2), (9f * 0.5f), iVar39, iVar40, iVar41, func_357(Var27, 25, SYSTEM::CEIL((200f * (SYSTEM::TO_FLOAT(113) / SYSTEM::TO_FLOAT(170))))), 0);
}
*iParam7 = *iParam6;
}
if (*iParam6 + 1 == (iParam9 - 1))
{
GRAPHICS::DRAW_MARKER(6, Var15, 0f, 0f, 1f, 0f, 0f, 0f, (0.5f * 4f), (0.5f * 4f), (0.5f * 4f), 240, 200, 80, func_357(Var15, 170, 200), false, false, 2, false, 0, 0, false);
GRAPHICS::DRAW_MARKER(6, Var15, 0f, 0f, 1f, 0f, 0f, 0f, (0.5f * 9f), (0.5f * 9f), (0.5f * 9f), 240, 200, 80, func_357(Var15, 170, 200), false, false, 2, false, 0, 0, false);
GRAPHICS::DRAW_MARKER(6, Var15, 0f, 0f, 1f, 0f, 0f, 0f, (0.5f * 14f), (0.5f * 14f), (0.5f * 14f), 240, 200, 80, func_357(Var15, 170, 200), false, false, 2, false, 0, 0, false);
}
else
{
GRAPHICS::DRAW_MARKER(6, Var15, func_475(Var9 - Var15), 0f, 0f, 0f, (0.5f * 14f), (0.5f * 14f), (0.5f * 14f), 240, 200, 80, func_357(Var15, 25, 200), false, false, 2, false, 0, 0, false);
}
if (*iParam4 != 0)
{
GRAPHICS::SET_CHECKPOINT_RGBA(*iParam4, iVar39, iVar40, iVar41, func_357(Var12, 25, SYSTEM::CEIL((200f * (SYSTEM::TO_FLOAT(113) / SYSTEM::TO_FLOAT(170))))));
}
if (*iParam5 != 0)
{
GRAPHICS::SET_CHECKPOINT_RGBA(*iParam5, iVar39, iVar40, iVar41, func_357(Var15, 25, SYSTEM::CEIL((200f * (SYSTEM::TO_FLOAT(113) / SYSTEM::TO_FLOAT(170))))));
}
}
if (!bParam19)
{
return 0;
}
if ((PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == 0 || PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == 1) || (PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == 2 && !PAD::IS_CONTROL_PRESSED(0, 80)))
{
if (!GRAPHICS::GET_SCREEN_COORD_FROM_WORLD_COORD(Var12, &uVar43, &uVar44))
{
if (iLocal_582)
{
func_355(Var12, uParam15, uParam16, uParam17);
if (func_462(&iLocal_584))
{
func_458(&iLocal_584);
}
}
else if (func_462(&iLocal_584))
{
if (func_353(&iLocal_584) > 0.5f)
{
func_458(&iLocal_584);
iLocal_582 = 1;
}
}
else
{
func_486(&iLocal_584);
}
}
else if (iLocal_582)
{
func_355(Var12, uParam15, uParam16, uParam17);
if (func_462(&iLocal_584))
{
if (func_353(&iLocal_584) > 0.5f)
{
func_458(&iLocal_584);
iLocal_582 = 0;
}
}
else
{
func_486(&iLocal_584);
}
}
else if (func_462(&iLocal_584))
{
func_458(&iLocal_584);
}
}
else
{
iLocal_582 = 0;
}
if (func_352(iParam14, uParam18, &iParam1))
{
if (HUD::DOES_BLIP_EXIST(*iParam11))
{
HUD::REMOVE_BLIP(iParam11);
}
if (HUD::DOES_BLIP_EXIST(*iParam12))
{
HUD::REMOVE_BLIP(iParam12);
}
if (!bVar37)
{
return 2;
}
fVar34 = SYSTEM::SQRT(((Var18.f_0 * Var18.f_0) + (Var18.f_1 * Var18.f_1)));
if (((Var18.f_2 < 5f && Var18.f_2 > -2f) && fVar34 < 15f) || func_266(iParam1, iParam2))
{
*uParam10 = func_268(SYSTEM::CEIL(((100f * (15f - fVar34)) / 15f)) + 4, 0, 100);
return 1;
}
else
{
return 3;
}
}
else if (func_351())
{
if (PLAYER::GET_PLAYER_INVINCIBLE(PLAYER::PLAYER_ID()))
{
PLAYER::SET_PLAYER_INVINCIBLE(PLAYER::PLAYER_ID(), false);
}
}
else if (!bVar37)
{
fVar33 = SYSTEM::VMAG2(Var18);
if (fVar33 < (22f * 22f))
{
if (fVar33 < (10f * 10f))
{
bVar38 = true;
}
else if (func_275(Var0, -Var18 / FtoV(SYSTEM::SQRT(fVar33))) < 0.08f)
{
bVar38 = true;
}
if (bVar38)
{
*uParam8++;
func_350(iParam13, 1);
func_223(func_428(), 1, SYSTEM::FLOOR((30f * fParam21)), 0, 0);
iLocal_583 = 0;
}
if (!bVar38 && !iLocal_583)
{
iLocal_583 = 1;
}
}
else if (PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == 0 || PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == -1)
{
if (Var18.f_2 < -22f)
{
func_350(iParam13, 0);
bVar38 = true;
}
}
else
{
Var24 = { ENTITY::GET_ENTITY_FORWARD_VECTOR(PLAYER::PLAYER_PED_ID()) };
Var24.f_2 = 0f;
Var24 = { func_475(Var24) };
Var21 = { -Var18.f_0, -Var18.f_1, 0f };
Var21 = { func_475(Var21) };
fVar35 = ((Var9.f_2 - 32f) + (32f * func_349(Var24, Var21)));
fVar34 = SYSTEM::SQRT(((Var18.f_0 * Var18.f_0) + (Var18.f_1 * Var18.f_1)));
if ((Var9.f_2 - fVar35) < fVar34)
{
fVar35 = (fVar35 - (0.05f * ((fVar35 - Var9.f_2) + fVar34)));
if (fVar35 < (Var12.f_2 - 22f))
{
func_350(iParam13, 0);
bVar38 = true;
}
}
}
if (iLocal_583)
{
if (SYSTEM::VMAG2(Var18) >= (22f * 22f))
{
*uParam8++;
func_350(iParam13, 1);
func_223(func_428(), 1, SYSTEM::FLOOR((30f * fParam21)), 0, 0);
bVar38 = true;
iLocal_583 = 0;
}
}
if (bVar38)
{
*iParam6++;
if (HUD::DOES_BLIP_EXIST(*iParam11))
{
HUD::REMOVE_BLIP(iParam11);
}
if (HUD::DOES_BLIP_EXIST(*iParam12))
{
*iParam11 = *iParam12;
*iParam12 = 0;
HUD::SET_BLIP_SCALE(*iParam11, 1.2f);
if (*iParam6 >= (iParam9 - 1))
{
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(*iParam11, "BJ_BLIP_TGT");
}
else
{
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(*iParam11, "BJ_BLIP_CHK");
}
}
if (*iParam6 < (iParam9 - 1))
{
if (!HUD::DOES_BLIP_EXIST(*iParam12))
{
*iParam12 = HUD::ADD_BLIP_FOR_COORD(func_369(uParam0, *iParam6 + 1));
HUD::SET_BLIP_COLOUR(*iParam12, 5);
HUD::SET_BLIP_SCALE(*iParam12, 0.7f);
if (*iParam6 + 1 >= (iParam9 - 1))
{
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(*iParam12, "BJ_BLIP_TGT");
}
else
{
HUD::SET_BLIP_NAME_FROM_TEXT_FILE(*iParam12, "BJ_BLIP_CHK");
}
}
}
else
{
*iParam12 = 0;
}
TASK::TASK_LOOK_AT_COORD(PLAYER::PLAYER_PED_ID(), func_369(uParam0, *iParam6), -1, 0, 2);
}
}
return 0;
}
float func_349(struct<2> Param0, var uParam2, struct<2> Param3, var uParam5)
{
return ((Param0.f_0 * Param3.f_0) + (Param0.f_1 * Param3.f_1));
}
void func_350(var uParam0, bool bParam1)
{
*uParam0 = AUDIO::GET_SOUND_ID();
if (bParam1)
{
AUDIO::PLAY_SOUND_FRONTEND(*uParam0, "CHECKPOINT_NORMAL", "HUD_MINI_GAME_SOUNDSET", true);
}
else
{
func_340("BJ_MISSED", 7500, 1);
AUDIO::PLAY_SOUND_FRONTEND(*uParam0, "CHECKPOINT_MISSED", "HUD_MINI_GAME_SOUNDSET", true);
}
}
int func_351()
{
if (((PED::IS_PED_RAGDOLL(PLAYER::PLAYER_PED_ID()) && (PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == 3 || PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID()) == -1)) && ENTITY::GET_ENTITY_HEIGHT_ABOVE_GROUND(PLAYER::PLAYER_PED_ID()) > 50f) && !PLAYER::GET_PLAYER_HAS_RESERVE_PARACHUTE(PLAYER::PLAYER_ID()))
{
return 1;
}
return 0;
}
bool func_352(var uParam0, var uParam1, int iParam2)
{
int iVar0;
int iVar1;
if (PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
return 1;
}
iVar0 = PLAYER::PLAYER_PED_ID();
if (!*uParam1)
{
iVar1 = PED::GET_PED_PARACHUTE_LANDING_TYPE(iVar0);
if (iVar1 != -1 && !ENTITY::IS_ENTITY_IN_AIR(iVar0))
{
*uParam1 = 1;
*uParam0 = iVar1;
}
}
return (((ENTITY::IS_ENTITY_IN_WATER(PLAYER::PLAYER_PED_ID()) || (PED::GET_PED_PARACHUTE_STATE(iVar0) == 3 && !ENTITY::IS_ENTITY_IN_AIR(iVar0))) || (PED::GET_PED_PARACHUTE_STATE(iVar0) == -1 && !ENTITY::IS_ENTITY_IN_AIR(iVar0))) || (((ENTITY::DOES_ENTITY_EXIST(*iParam2) && !PED::IS_PED_INJURED(iVar0)) && !ENTITY::IS_ENTITY_DEAD(*iParam2, false)) && PED::IS_PED_ON_SPECIFIC_VEHICLE(iVar0, *iParam2)));
}
float func_353(int* iParam0)
{
if (func_462(iParam0))
{
if (func_354(iParam0))
{
return iParam0->f_2;
}
else
{
return (func_43(BitTest(*iParam0, 4)) - iParam0->f_1);
}
}
return 0f;
}
bool func_354(int* iParam0)
{
return BitTest(*iParam0, 2);
}
void func_355(struct<3> Param0, var uParam3, var uParam4, var uParam5)
{
var uVar0;
var uVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
int iVar8;
int iVar9;
if (GRAPHICS::GET_SCREEN_COORD_FROM_WORLD_COORD(Param0, &uVar0, &uVar1))
{
}
fVar4 = 0f;
fVar5 = 0.05f;
fVar6 = 0.05f;
func_356(Param0, &fVar2, &fVar3);
if (fVar2 != 0f && fVar3 != 0f)
{
if (fVar2 >= 0.7999f)
{
fVar4 = 90f;
}
else if (fVar2 <= 0.2f)
{
fVar4 = -90f;
}
else if (fVar3 <= 0.2f)
{
fVar4 = 0f;
}
else if (fVar3 >= 0.7999f)
{
fVar4 = 180f;
}
GRAPHICS::GET_SCREEN_RESOLUTION(&iVar8, &iVar9);
fVar7 = (SYSTEM::TO_FLOAT(iVar8) / SYSTEM::TO_FLOAT(iVar9));
if (fVar4 == 0f || fVar4 == 180f)
{
fVar5 = ((0.05f * 16f) / 9f);
fVar6 = (0.05f / fVar7);
}
else
{
fVar5 = 0.05f;
fVar6 = (0.05f * ((16f / 9f) / fVar7));
}
if ((fVar4 != *uParam5 || (*uParam3 == 0f && *uParam4 == 0f)) || (MISC::ABSF((fVar2 - *uParam3)) < 0.04f && MISC::ABSF((fVar3 - *uParam4)) < 0.04f))
{
GRAPHICS::DRAW_SPRITE("basejumping", "Arrow_Pointer", fVar2, fVar3, fVar6, fVar5, fVar4, 240, 200, 80, 170, false, 0);
}
*uParam5 = fVar4;
}
*uParam3 = fVar2;
*uParam4 = fVar3;
}
void func_356(struct<3> Param0, var uParam3, var uParam4)
{
float fVar0;
float fVar1;
struct<3> Var2;
if (!func_317(Param0, 0f, 0f, 0f, 0))
{
HUD::GET_HUD_SCREEN_POSITION_FROM_WORLD_POSITION(Param0, &fVar0, &fVar1);
}
if (fVar0 >= 0.5f)
{
Var2.f_0 = (fVar0 - 0.5f);
}
else
{
Var2.f_0 = (0.5f - fVar0);
}
if (fVar1 >= 0.5f)
{
Var2.f_1 = (fVar1 - 0.5f);
}
else
{
Var2.f_1 = (0.5f - fVar1);
}
Var2.f_2 = 0f;
func_475(Var2);
Var2.f_0 = (Var2.f_0 * 0.75f);
Var2.f_1 = (Var2.f_1 * 0.75f);
if (fVar0 >= 0.5f)
{
fVar0 = (0.5f + Var2.f_0);
}
else
{
fVar0 = (0.5f - Var2.f_0);
}
if (fVar1 >= 0.5f)
{
fVar1 = (0.5f + Var2.f_1);
}
else
{
fVar1 = (0.5f - Var2.f_1);
}
*uParam3 = fVar0;
*uParam4 = fVar1;
}
int func_357(struct<3> Param0, int iParam3, int iParam4)
{
float fVar0;
int iVar1;
float fVar2;
float fVar3;
fVar0 = 100f;
iVar1 = 50;
if (!ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
fVar2 = MISC::GET_DISTANCE_BETWEEN_COORDS(Param0, ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true), true);
if (fVar2 > fVar0)
{
iVar1 = iParam4;
}
else
{
fVar3 = ((fVar0 - fVar2) / fVar0);
iVar1 = (iParam4 - SYSTEM::CEIL((IntToFloat((iParam4 - iParam3)) * fVar3)));
}
}
if (iVar1 < iParam3)
{
iVar1 = iParam3;
}
return iVar1;
}
void func_358(int* iParam0)
{
if (func_462(iParam0) && func_461(iParam0) > 7.5f)
{
func_458(iParam0);
}
}
int func_359(var uParam0, bool bParam1, var uParam2)
{
int iVar0;
struct<3> Var1;
struct<3> Var4;
float fVar7;
if (ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
return 0;
}
if (PED::IS_PED_IN_FLYING_VEHICLE(PLAYER::PLAYER_PED_ID()))
{
*uParam2 = 1;
return 1;
}
Var1 = { ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true) };
if (PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), true))
{
iVar0 = PED::GET_VEHICLE_PED_IS_IN(PLAYER::PLAYER_PED_ID(), true);
if (ENTITY::IS_ENTITY_IN_AIR(iVar0))
{
return 0;
}
else if (!MISC::GET_GROUND_Z_FOR_3D_COORD(ENTITY::GET_ENTITY_COORDS(iVar0, true), &fVar7, false, false))
{
return 0;
}
else if (Var1.f_2 >= (fVar7 + 1.5f))
{
return 0;
}
}
if (ENTITY::IS_ENTITY_IN_AIR(PLAYER::PLAYER_PED_ID()))
{
return 0;
}
else if (!MISC::GET_GROUND_Z_FOR_3D_COORD(Var1, &fVar7, false, false))
{
return 0;
}
else if (Var1.f_2 >= (fVar7 + 1.5f))
{
return 0;
}
Var4 = { func_369(uParam0, 0) };
if (Var1.f_2 < (Var4.f_2 + 5f))
{
*uParam2 = 1;
return 1;
}
if (bParam1 == 5)
{
if (Var1.f_2 < 288f)
{
*uParam2 = 1;
return 1;
}
}
else if (bParam1 == 4)
{
if (Var1.f_2 < 305f)
{
*uParam2 = 1;
return 1;
}
}
else if (bParam1 == 8)
{
if (Var1.f_2 < 227f)
{
*uParam2 = 1;
return 1;
}
}
else if (bParam1 == 6 || bParam1 == 12)
{
if (SYSTEM::VDIST2(ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true), func_473(bParam1)) > 3600f)
{
*uParam2 = 1;
return 1;
}
}
return 0;
}
int func_360()
{
if (CAM::GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM::_GET_CAM_ACTIVE_VIEW_MODE_CONTEXT()) == 4)
{
return 1;
}
return 0;
}
var func_361(var uParam0)
{
return uParam0->f_84;
}
void func_362(int* iParam0, bool bParam1)
{
int iVar0;
int iVar1;
struct<3> Var2;
struct<3> Var5;
float fVar8;
if (!VEHICLE::IS_VEHICLE_DRIVEABLE(*iParam0, false))
{
return;
}
Var2 = { ENTITY::GET_ENTITY_COORDS(*iParam0, true) };
fVar8 = VEHICLE::GET_VEHICLE_ESTIMATED_MAX_SPEED(*iParam0);
iVar1 = VEHICLE::GET_PED_IN_VEHICLE_SEAT(*iParam0, -1, false);
ENTITY::FREEZE_ENTITY_POSITION(*iParam0, false);
TASK::OPEN_SEQUENCE_TASK(&iVar0);
if (!bParam1)
{
TASK::TASK_VEHICLE_MISSION_COORS_TARGET(0, *iParam0, ENTITY::GET_ENTITY_COORDS(*iParam0, true), 4, 0f, 786469, 2f, 0f, true);
}
TASK::TASK_VEHICLE_MISSION_COORS_TARGET(0, *iParam0, Var2 + Vector(5f, 5f, 5f) * ENTITY::GET_ENTITY_FORWARD_VECTOR(*iParam0) + Vector(20f, 0f, 0f), 4, (0.3f * fVar8), 786469, 5f, 10f, true);
Var5 = { Vector(1000f, 1000f, 1000f) * ENTITY::GET_ENTITY_FORWARD_VECTOR(*iParam0) };
Var5.f_2 = 200f;
TASK::TASK_VEHICLE_MISSION_COORS_TARGET(0, *iParam0, Var2 + Var5, 4, fVar8, 262144, 15f, 10f, true);
TASK::CLOSE_SEQUENCE_TASK(iVar0);
TASK::CLEAR_PED_TASKS(iVar1);
TASK::TASK_PERFORM_SEQUENCE(iVar1, iVar0);
TASK::CLEAR_SEQUENCE_TASK(&iVar0);
}
void func_363(int iParam0, int iParam1)
{
int iVar0;
if (iParam1 < 1)
{
return;
}
if (Global_58438[iParam0 /*7*/].f_2)
{
return;
}
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
return;
}
if (Global_58438[iParam0 /*7*/])
{
STATS::STAT_GET_INT(Global_58438[iParam0 /*7*/].f_1, &iVar0, -1);
iVar0 = (iVar0 + iParam1);
STATS::STAT_SET_INT(Global_58438[iParam0 /*7*/].f_1, iVar0, true);
}
}
void func_364(bool bParam0, bool bParam1, int iParam2)
{
if (bParam0)
{
PLAYER::SET_PLAYER_CONTROL(PLAYER::GET_PLAYER_INDEX(), true, 0);
}
CUTSCENE::_0xC61B86C9F61EB404(true);
func_418(0, 1, iParam2, 0, 0, 0, 0);
if (bParam1)
{
HUD::DISPLAY_RADAR(true);
HUD::DISPLAY_HUD(true);
}
func_558(23, 0);
}
int func_365(int iParam0)
{
switch (iParam0)
{
case joaat("bmx"):
case joaat("scorcher"):
case joaat("tribike"):
case joaat("tribike2"):
case joaat("tribike3"):
case joaat("vader"):
case joaat("akuma"):
case joaat("bagger"):
case joaat("ruffian"):
case joaat("bati"):
case joaat("bati2"):
case joaat("blazer"):
case joaat("blazer2"):
case joaat("cruiser"):
case joaat("hexer"):
case joaat("nemesis"):
case joaat("pcj"):
case joaat("policeb"):
return 1;
default:
}
return 0;
}
int func_366(var uParam0)
{
return *uParam0;
}
int func_367(int iParam0)
{
switch (iParam0)
{
case joaat("freight"):
case joaat("metrotrain"):
return 1;
default:
}
return 0;
}
int func_368(var uParam0)
{
return uParam0->f_1;
}
Vector3 func_369(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 >= 12)
{
return 0f, 0f, 0f;
}
return uParam0->f_12[iParam1 /*3*/];
}
Vector3 func_370(var uParam0)
{
return uParam0->f_6;
}
void func_371(int* iParam0)
{
func_42(iParam0, 0f);
}
int func_372(int iParam0)
{
return SYSTEM::SHIFT_RIGHT(iParam0, 20) & 63;
}
int func_373(int iParam0)
{
return SYSTEM::SHIFT_RIGHT(iParam0, 14) & 63;
}
int func_374(int iParam0)
{
return SYSTEM::SHIFT_RIGHT(iParam0, 9) & 31;
}
void func_375()
{
int iVar0;
STATS::LEADERBOARDS_CLEAR_CACHE_DATA();
iVar0 = 0;
while (iVar0 < 5)
{
Global_2100721.f_81[iVar0] = 0;
iVar0++;
}
}
void func_376()
{
struct<68> Var0;
Global_2097157 = 0;
Global_2097157.f_1 = 0;
Global_2097157.f_2 = 0;
Global_2097157.f_3 = 0;
Global_2097157.f_4 = 0;
func_377(&(Global_2097157.f_73));
func_377(&(Global_2097157.f_142));
func_377(&(Global_2097157.f_211));
func_377(&(Global_2097157.f_280));
StringCopy(&(Global_2097157.f_349), "", 24);
StringCopy(&(Global_2097157.f_355), "", 24);
func_138(&(Global_2097157.f_361));
Global_2097157.f_374 = -1;
Global_2097532 = 0;
Global_2097533 = 0;
Var0.f_2.f_1 = 4;
Global_2097157.f_5 = { Var0 };
}
void func_377(var uParam0)
{
int iVar0;
*uParam0 = 0;
uParam0->f_1 = 0;
uParam0->f_2 = 0;
iVar0 = 0;
while (iVar0 < 32)
{
uParam0->f_3[iVar0] = 0f;
uParam0->f_36[iVar0] = 0;
iVar0++;
}
}
bool func_378(var uParam0)
{
return uParam0->f_83;
}
int func_379(var uParam0, bool bParam1, int* iParam2, var uParam3, var uParam4, int* iParam5, int* iParam6, int* iParam7, int* iParam8, int iParam9, var uParam10, var uParam11, var uParam12)
{
if (CAM::IS_CAM_INTERPOLATING(func_433(uParam3, 1)))
{
func_371(iParam5);
}
if (!*uParam10)
{
if (func_462(iParam7) && func_461(iParam7) >= func_400(uParam0))
{
func_362(iParam2, 0);
func_458(iParam7);
*uParam10 = 1;
}
}
else if (VEHICLE::IS_VEHICLE_DRIVEABLE(*iParam2, false))
{
VEHICLE::SET_HELI_BLADES_SPEED(*iParam2, 0.7f);
}
if (func_462(iParam5) && func_461(iParam5) > 0.2f)
{
func_458(iParam5);
func_458(iParam6);
return 1;
}
if (!func_462(iParam6))
{
func_486(iParam6);
}
else if ((uParam12 && CAM::IS_SCREEN_FADED_IN()) || (func_461(iParam6) > 0.5f && func_333(uParam4, 2)))
{
*uParam11 = 1;
func_458(iParam5);
func_458(iParam6);
return 1;
}
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(2);
if (func_462(iParam8))
{
if (func_466(bParam1) != 0)
{
func_458(iParam8);
}
else if (func_461(iParam8) > func_426(bParam1, iParam9))
{
switch (iParam9)
{
case 0:
TASK::TASK_PLAY_ANIM(PLAYER::PLAYER_PED_ID(), "amb@world_human_hiker_standing@male@idle_a", "idle_a", 8f, -1.4f, -1, 48, 0f, false, false, false);
break;
case 1:
TASK::TASK_PLAY_ANIM(PLAYER::PLAYER_PED_ID(), "amb@world_human_muscle_flex@arms_at_side@base", "base", 8f, -1.4f, -1, 48, 0.681f, false, false, false);
break;
case 2:
TASK::TASK_PLAY_ANIM(PLAYER::PLAYER_PED_ID(), "playidles_cold", "blow_hands", 8f, -1.4f, -1, 48, 0.537f, false, false, false);
break;
}
func_458(iParam8);
}
}
if (CAM::IS_SCREEN_FADED_IN())
{
func_380();
}
else
{
func_371(iParam6);
}
return 0;
}
void func_380()
{
struct<6> Var0;
int iVar6;
iVar6 = Global_112922.f_18967;
func_381(Var0, 0, 0, 0, 0, iVar6);
}
void func_381(struct<6> Param0, int iParam6, int iParam7, int iParam8, int iParam9, int iParam10)
{
float fVar0;
int iVar1;
int iVar2;
int iVar3;
struct<2> Var4;
float fVar6;
float fVar7;
int iVar8;
int iVar9;
int iVar10;
var uVar11;
int iVar12;
if (Global_78112 != 6)
{
if (Global_78114 == -1)
{
if (func_395(1, Param0))
{
if (Global_78115 == 3)
{
fVar0 = 1.5f;
}
else
{
fVar0 = 2.5f;
}
if (fLocal_21 > fVar0)
{
Global_78114 = MISC::GET_GAME_TIMER();
Local_22 = { HUD::GET_HUD_COMPONENT_POSITION(15) };
fLocal_21 = 0f;
}
else
{
fLocal_21 = (fLocal_21 + MISC::GET_FRAME_TIME());
}
}
else
{
fLocal_21 = 0f;
}
}
else
{
if (!func_395(0, Param0))
{
Global_78114 = (MISC::GET_GAME_TIMER() - 9000);
}
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(7);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(6);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(8);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(9);
iVar1 = (MISC::GET_GAME_TIMER() - Global_78114);
if (iVar1 < 9000 && !CAM::IS_SCREEN_FADED_OUT())
{
iVar2 = 255;
if (iVar1 < 1000)
{
iVar2 = SYSTEM::CEIL(((SYSTEM::TO_FLOAT(iVar1) / 1000f) * 255f));
}
else
{
iVar3 = (9000 - iVar1);
if (iVar3 < 1000)
{
iVar2 = SYSTEM::CEIL(((SYSTEM::TO_FLOAT(iVar3) / 1000f) * 255f));
}
}
switch (Global_78112)
{
case 3:
case 5:
if (iParam6 == 1)
{
fVar6 = 0f;
fVar7 = -0.07f;
}
else if (iParam7 == 1)
{
fVar6 = 0f;
fVar7 = -0.077f;
}
else if (iParam8 == 1)
{
fVar6 = 0f;
fVar7 = -0.05f;
}
else if (iParam9 == 1)
{
fVar6 = 0f;
fVar7 = -0.035f;
}
else
{
fVar6 = 0f;
fVar7 = -0.014f;
}
break;
default:
fVar6 = 0f;
fVar7 = -0.014f;
break;
}
GRAPHICS::SET_SCRIPT_GFX_ALIGN(82, 66);
HUD::SET_TEXT_FONT(1);
HUD::SET_TEXT_JUSTIFICATION(2);
iVar12 = func_428();
if (Global_78115 == 1 && Global_78113 == 62)
{
iVar12 = Global_112922.f_2363.f_539.f_4322;
}
switch (iVar12)
{
case 0:
HUD::GET_HUD_COLOUR(143, &iVar8, &iVar9, &iVar10, &uVar11);
break;
case 1:
HUD::GET_HUD_COLOUR(144, &iVar8, &iVar9, &iVar10, &uVar11);
break;
case 2:
HUD::GET_HUD_COLOUR(145, &iVar8, &iVar9, &iVar10, &uVar11);
break;
default:
iVar8 = 240;
iVar9 = 200;
iVar10 = 80;
}
HUD::SET_TEXT_COLOUR(iVar8, iVar9, iVar10, iVar2);
HUD::SET_TEXT_DROP_SHADOW();
Var4 = { func_384(Global_78113, Global_78115, iParam10) };
if (fVar7 == -0.014f)
{
}
GRAPHICS::SET_SCRIPT_GFX_ALIGN_PARAMS(fVar6, fVar7, 0f, 0.01f);
HUD::SET_TEXT_SCALE(0.67f, 0.67f);
if (!GRAPHICS::GET_IS_WIDESCREEN() && !GRAPHICS::GET_IS_HIDEF())
{
fLocal_26 = 0.14f;
}
else
{
fLocal_26 = 0.17f;
}
if (fVar7 == -0.014f)
{
if (func_383(&Var4) > fLocal_26)
{
if (HUD::IS_HUD_COMPONENT_ACTIVE(15))
{
HUD::SET_HUD_COMPONENT_POSITION(15, Local_22.f_0, (Local_22.f_1 + fLocal_25));
Global_78117 = 1;
}
}
}
HUD::BEGIN_TEXT_COMMAND_DISPLAY_TEXT(&Var4);
HUD::END_TEXT_COMMAND_DISPLAY_TEXT(fVar6, fVar7, 0);
GRAPHICS::RESET_SCRIPT_GFX_ALIGN();
if (Global_78116 == 1)
{
func_382();
fLocal_21 = 0f;
}
}
else
{
func_382();
fLocal_21 = 0f;
}
}
}
}
void func_382()
{
if (Global_78112 != 6)
{
}
if (Global_78117)
{
HUD::RESET_HUD_COMPONENT_VALUES(15);
Global_78117 = 0;
Global_22830.f_8680 = 0;
}
Global_78112 = 6;
Global_78114 = -1;
Global_78113 = -1;
}
float func_383(char* sParam0)
{
HUD::_BEGIN_TEXT_COMMAND_GET_WIDTH(sParam0);
return HUD::_END_TEXT_COMMAND_GET_WIDTH(true);
}
struct<2> func_384(int iParam0, int iParam1, int iParam2)
{
struct<2> Var0;
int iVar2;
StringCopy(&Var0, "", 8);
switch (iParam1)
{
case 1:
Var0 = { func_394(iParam0) };
break;
case 7:
Var0 = { func_392(iParam0) };
break;
case 3:
iVar2 = iParam0;
switch (iVar2)
{
case 0:
Var0 = { func_391(iParam2) };
break;
case 8:
Var0 = { func_390(iParam2) };
break;
case 7:
Var0 = { func_389(iParam2) };
break;
case 10:
Var0 = { func_388(iParam2) };
break;
case 5:
Var0 = { func_387(iParam2) };
break;
case 4:
Var0 = { func_386(iParam2) };
break;
default:
StringCopy(&Var0, func_385(iVar2), 8);
break;
}
break;
default:
break;
}
return Var0;
}
char* func_385(int iParam0)
{
switch (iParam0)
{
case 0:
return "MG_BJUM";
break;
case 1:
return "MG_DART";
break;
case 2:
return "MG_GOLF";
break;
case 3:
return "MG_HUNT";
break;
case 4:
return "MG_OFFR";
break;
case 5:
return "MG_PILO";
break;
case 6:
return "MG_RMPG";
break;
case 7:
return "MG_SERA";
break;
case 8:
return "MG_SRAC";
break;
case 9:
return "MG_STRP";
break;
case 10:
return "MG_STNT";
break;
case 11:
return "MG_SHTR";
break;
case 12:
return "MG_TAXI";
break;
case 13:
return "MG_TENN";
break;
case 14:
return "MG_TOWI";
break;
case 15:
return "MG_TRFA";
break;
case 16:
return "MG_TRFG";
break;
case 17:
return "MG_TRIA";
break;
case 18:
return "MG_YOGA";
break;
case 19:
return "MG_CRCE";
break;
}
return "INVALID!";
}
struct<2> func_386(int iParam0)
{
struct<2> Var0;
char[] cVar2[8];
StringCopy(&Var0, "", 8);
IntToString(&cVar2, iParam0, 8);
if (MISC::IS_STRING_NULL_OR_EMPTY(&cVar2))
{
}
else
{
StringCopy(&Var0, "MGOR_", 8);
StringConCat(&Var0, &cVar2, 8);
}
return Var0;
}
struct<2> func_387(int iParam0)
{
struct<2> Var0;
char[] cVar2[8];
StringCopy(&Var0, "", 8);
IntToString(&cVar2, iParam0, 8);
if (MISC::IS_STRING_NULL_OR_EMPTY(&cVar2))
{
}
else
{
StringCopy(&Var0, "MGFS_", 8);
StringConCat(&Var0, &cVar2, 8);
}
return Var0;
}
struct<2> func_388(int iParam0)
{
struct<2> Var0;
char[] cVar2[8];
StringCopy(&Var0, "", 8);
IntToString(&cVar2, iParam0, 8);
if (MISC::IS_STRING_NULL_OR_EMPTY(&cVar2))
{
}
else
{
StringCopy(&Var0, "MGSP_", 8);
StringConCat(&Var0, &cVar2, 8);
}
return Var0;
}
struct<2> func_389(int iParam0)
{
struct<2> Var0;
char[] cVar2[8];
StringCopy(&Var0, "", 8);
IntToString(&cVar2, iParam0, 8);
if (MISC::IS_STRING_NULL_OR_EMPTY(&cVar2))
{
}
else
{
StringCopy(&Var0, "MGSR_", 8);
StringConCat(&Var0, &cVar2, 8);
}
return Var0;
}
struct<2> func_390(int iParam0)
{
struct<2> Var0;
char[] cVar2[8];
StringCopy(&Var0, "", 8);
IntToString(&cVar2, iParam0, 8);
if (MISC::IS_STRING_NULL_OR_EMPTY(&cVar2) || iParam0 == 3)
{
}
else
{
StringCopy(&Var0, "MGCR_", 8);
StringConCat(&Var0, &cVar2, 8);
}
return Var0;
}
struct<2> func_391(int iParam0)
{
struct<2> Var0;
char[] cVar2[8];
StringCopy(&Var0, "", 8);
IntToString(&cVar2, iParam0, 8);
if (MISC::IS_STRING_NULL_OR_EMPTY(&cVar2))
{
}
else
{
StringCopy(&Var0, "MGBJ_", 8);
StringConCat(&Var0, &cVar2, 8);
}
return Var0;
}
struct<2> func_392(int iParam0)
{
struct<2> Var0;
char[] cVar2[8];
StringCopy(&Var0, "", 8);
cVar2 = { func_393(iParam0) };
if (MISC::IS_STRING_NULL_OR_EMPTY(&cVar2))
{
}
else
{
StringCopy(&Var0, "RC_", 8);
StringConCat(&Var0, &cVar2, 8);
}
return Var0;
}
struct<2> func_393(int iParam0)
{
struct<2> Var0;
StringCopy(&Var0, "", 8);
switch (iParam0)
{
case 0:
StringCopy(&Var0, "ABI1", 8);
break;
case 1:
StringCopy(&Var0, "ABI2", 8);
break;
case 2:
StringCopy(&Var0, "BA1", 8);
break;
case 3:
StringCopy(&Var0, "BA2", 8);
break;
case 4:
StringCopy(&Var0, "BA3", 8);
break;
case 5:
StringCopy(&Var0, "BA3A", 8);
break;
case 6:
StringCopy(&Var0, "BA3C", 8);
break;
case 7:
StringCopy(&Var0, "BA4", 8);
break;
case 8:
StringCopy(&Var0, "DRE1", 8);
break;
case 9:
StringCopy(&Var0, "EPS1", 8);
break;
case 10:
StringCopy(&Var0, "EPS2", 8);
break;
case 11:
StringCopy(&Var0, "EPS3", 8);
break;
case 12:
StringCopy(&Var0, "EPS4", 8);
break;
case 13:
StringCopy(&Var0, "EPS5", 8);
break;
case 14:
StringCopy(&Var0, "EPS6", 8);
break;
case 15:
StringCopy(&Var0, "EPS7", 8);
break;
case 16:
StringCopy(&Var0, "EPS8", 8);
break;
case 17:
StringCopy(&Var0, "EXT1", 8);
break;
case 18:
StringCopy(&Var0, "EXT2", 8);
break;
case 19:
StringCopy(&Var0, "EXT3", 8);
break;
case 20:
StringCopy(&Var0, "EXT4", 8);
break;
case 21:
StringCopy(&Var0, "FAN1", 8);
break;
case 22:
StringCopy(&Var0, "FAN2", 8);
break;
case 23:
StringCopy(&Var0, "FAN3", 8);
break;
case 24:
StringCopy(&Var0, "HAO1", 8);
break;
case 25:
StringCopy(&Var0, "HUN1", 8);
break;
case 26:
StringCopy(&Var0, "HUN2", 8);
break;
case 27:
StringCopy(&Var0, "JOS1", 8);
break;
case 28:
StringCopy(&Var0, "JOS2", 8);
break;
case 29:
StringCopy(&Var0, "JOS3", 8);
break;
case 30:
StringCopy(&Var0, "JOS4", 8);
break;
case 31:
StringCopy(&Var0, "MAU1", 8);
break;
case 32:
StringCopy(&Var0, "MIN1", 8);
break;
case 33:
StringCopy(&Var0, "MIN2", 8);
break;
case 34:
StringCopy(&Var0, "MIN3", 8);
break;
case 35:
StringCopy(&Var0, "MRS1", 8);
break;
case 36:
StringCopy(&Var0, "MRS2", 8);
break;
case 37:
StringCopy(&Var0, "NI1", 8);
break;
case 38:
StringCopy(&Var0, "NI1A", 8);
break;
case 39:
StringCopy(&Var0, "NI1B", 8);
break;
case 40:
StringCopy(&Var0, "NI1C", 8);
break;
case 41:
StringCopy(&Var0, "NI1D", 8);
break;
case 42:
StringCopy(&Var0, "NI2", 8);
break;
case 43:
StringCopy(&Var0, "NI3", 8);
break;
case 44:
StringCopy(&Var0, "OME1", 8);
break;
case 45:
StringCopy(&Var0, "OME2", 8);
break;
case 46:
StringCopy(&Var0, "PA1", 8);
break;
case 47:
StringCopy(&Var0, "PA2", 8);
break;
case 48:
StringCopy(&Var0, "PA3", 8);
break;
case 49:
StringCopy(&Var0, "PA3A", 8);
break;
case 50:
StringCopy(&Var0, "PA3B", 8);
break;
case 51:
StringCopy(&Var0, "PA4", 8);
break;
case 52:
StringCopy(&Var0, "RAM1", 8);
break;
case 53:
StringCopy(&Var0, "RAM2", 8);
break;
case 54:
StringCopy(&Var0, "RAM3", 8);
break;
case 55:
StringCopy(&Var0, "RAM4", 8);
break;
case 56:
StringCopy(&Var0, "RAM5", 8);
break;
case 57:
StringCopy(&Var0, "SAS1", 8);
break;
case 58:
StringCopy(&Var0, "TON1", 8);
break;
case 59:
StringCopy(&Var0, "TON2", 8);
break;
case 60:
StringCopy(&Var0, "TON3", 8);
break;
case 61:
StringCopy(&Var0, "TON4", 8);
break;
case 62:
StringCopy(&Var0, "TON5", 8);
break;
default:
break;
}
return Var0;
}
struct<2> func_394(int iParam0)
{
struct<2> Var0;
StringCopy(&Var0, "M_", 8);
StringConCat(&Var0, &(Global_90768[iParam0 /*34*/].f_8), 8);
if (iParam0 == 90)
{
switch (Global_112922.f_9085.f_99.f_205[7])
{
case 1:
StringConCat(&Var0, "A", 8);
break;
case 2:
StringConCat(&Var0, "B", 8);
break;
default:
StringConCat(&Var0, "A", 8);
break;
}
}
return Var0;
}
int func_395(int iParam0, var uParam1, var uParam2, var uParam3, var uParam4, var uParam5, var uParam6)
{
if (((!func_397(0) || Global_78127) || Global_78116 == 1) || !CAM::IS_SCREEN_FADED_IN())
{
return 0;
}
switch (Global_78112)
{
case 0:
if (MISC::ARE_STRINGS_EQUAL(&uParam1, "NONE") || MISC::IS_STRING_NULL_OR_EMPTY(&uParam1))
{
Global_78112 = 3;
}
else
{
Global_78112 = 1;
}
break;
case 1:
if (CUTSCENE::HAS_CUTSCENE_LOADED())
{
Global_78112 = 2;
}
break;
case 2:
if (CUTSCENE::IS_CUTSCENE_PLAYING())
{
Global_78112 = 4;
return 1;
}
else if (!CUTSCENE::IS_CUTSCENE_ACTIVE())
{
Global_78112 = 3;
}
break;
case 3:
if (CUTSCENE::IS_CUTSCENE_PLAYING())
{
}
else
{
Global_78112 = 5;
return 1;
}
break;
case 4:
if (CUTSCENE::IS_CUTSCENE_PLAYING())
{
return 1;
}
else if (iParam0 == 1)
{
Global_78112 = 5;
}
break;
case 5:
if ((CUTSCENE::IS_CUTSCENE_PLAYING() || func_32(0)) || func_396(1))
{
}
else
{
return 1;
}
break;
}
return 0;
}
bool func_396(bool bParam0)
{
if (bParam0)
{
return (Global_22691.f_4 && Global_22691.f_104 == 4);
}
return Global_22691.f_4;
}
int func_397(int iParam0)
{
if (Global_42602 == 15)
{
return 0;
}
if (func_398(iParam0))
{
return 0;
}
return 1;
}
bool func_398(int iParam0)
{
return func_399(iParam0, Global_42602);
}
int func_399(int iParam0, int iParam1)
{
if (iParam1 == 15)
{
return 1;
}
if (iParam0 == 15)
{
return 0;
}
switch (iParam0)
{
case 16:
switch (iParam1)
{
case 9:
case 10:
case 7:
case 13:
case 14:
return 0;
break;
}
return 1;
break;
case 0:
switch (iParam1)
{
case 5:
case 17:
return 1;
break;
}
break;
case 2:
case 3:
switch (iParam1)
{
case 5:
case 6:
case 8:
case 17:
return 1;
break;
}
break;
case 4:
if (iParam1 == 17)
{
return 1;
}
break;
case 5:
break;
case 6:
case 8:
if (iParam1 == 5)
{
return 1;
}
break;
case 7:
if (iParam1 == 6)
{
return 1;
}
break;
case 9:
if (iParam1 == 5)
{
return 1;
}
break;
case 10:
switch (iParam1)
{
case 5:
case 6:
case 17:
return 1;
break;
}
break;
case 11:
if (iParam1 == 5)
{
return 1;
}
break;
case 17:
switch (iParam1)
{
case 17:
case 12:
case 5:
return 1;
break;
}
break;
case 18:
case 12:
switch (iParam1)
{
case 5:
case 6:
case 8:
return 1;
break;
}
break;
case 13:
switch (iParam1)
{
case 5:
return 1;
break;
}
break;
case 14:
switch (iParam1)
{
case 5:
return 1;
break;
}
break;
}
return 0;
}
float func_400(var uParam0)
{
return uParam0->f_80;
}
int func_401(var uParam0, char* sParam1, char* sParam2, int iParam3, int iParam4, int iParam5, int iParam6)
{
func_415(uParam0, 145, sParam1, iParam4, iParam5, iParam6);
if (iParam3 > 7)
{
if (iParam3 < 12)
{
iParam3 = 7;
}
}
Global_21292 = 0;
Global_21294 = 0;
Global_21299 = 0;
Global_22276 = 0;
Global_22278 = 0;
Global_22282 = 0;
Global_2883585 = 0;
return func_402(sParam2, iParam3, 0);
}
int func_402(char* sParam0, int iParam1, bool bParam2)
{
Global_21286 = 0;
if (Global_21285 == 0 || Global_21287 == 2)
{
if (Global_21285 != 0)
{
if (iParam1 > Global_21287)
{
if (Global_21292 == 0)
{
AUDIO::STOP_SCRIPTED_CONVERSATION(false);
Global_19954.f_1 = 3;
Global_21285 = 0;
Global_21286 = 1;
Global_21338 = 0;
Global_21281 = 0;
Global_21282 = 0;
Global_21296 = 0;
Global_21295 = 0;
Global_19953 = 0;
}
else
{
func_414();
return 0;
}
}
else
{
return 0;
}
}
if (AUDIO::IS_SCRIPTED_CONVERSATION_ONGOING())
{
return 0;
}
if (func_413(8, -1))
{
return 0;
}
Global_21361 = { Global_21355 };
func_412();
Global_20574 = { Global_20739 };
Global_21291 = Global_21292;
Global_21298 = Global_21299;
Global_2883586 = Global_2883585;
Global_21300 = { Global_21316 };
Global_21293 = Global_21294;
Global_22275 = Global_22276;
Global_22283 = { Global_22289 };
Global_22277 = Global_22278;
Global_22279 = Global_22280;
Global_22281 = Global_22282;
Global_20904.f_370 = Global_22274;
Global_20904.f_368 = Global_22272;
Global_20904.f_369 = Global_22273;
Global_21281 = Global_21282;
if (Global_21291)
{
MISC::CLEAR_BIT(&Global_7824, 20);
MISC::CLEAR_BIT(&Global_7825, 17);
MISC::CLEAR_BIT(&Global_7826, false);
if (bParam2)
{
func_411();
if (Global_8629[Global_19954 /*2811*/][0 /*281*/].f_259 == 2)
{
if (iParam1 == 13)
{
}
else
{
return 0;
}
}
if (Global_19954.f_1 > 3)
{
return 0;
}
}
if (Global_19920 == 1)
{
return 0;
}
if (PLAYER::IS_PLAYER_PLAYING(PLAYER::PLAYER_ID()))
{
if (PED::IS_PED_IN_MELEE_COMBAT(PLAYER::PLAYER_PED_ID()))
{
return 0;
}
if (func_410())
{
return 0;
}
if (TASK::IS_PED_SPRINTING(PLAYER::PLAYER_PED_ID()))
{
return 0;
}
if (PED::IS_PED_RAGDOLL(PLAYER::PLAYER_PED_ID()))
{
return 0;
}
if (PED::IS_PED_IN_PARACHUTE_FREE_FALL(PLAYER::PLAYER_PED_ID()))
{
return 0;
}
if (WEAPON::GET_IS_PED_GADGET_EQUIPPED(PLAYER::PLAYER_PED_ID(), joaat("gadget_parachute")))
{
return 0;
}
if (!Global_77858)
{
if (ENTITY::IS_ENTITY_IN_WATER(PLAYER::PLAYER_PED_ID()))
{
return 0;
}
if (PLAYER::IS_PLAYER_CLIMBING(PLAYER::PLAYER_ID()))
{
return 0;
}
if (PED::IS_PED_PLANTING_BOMB(PLAYER::PLAYER_PED_ID()))
{
return 0;
}
if (PLAYER::IS_SPECIAL_ABILITY_ACTIVE(PLAYER::PLAYER_ID(), 0))
{
return 0;
}
}
}
if (func_28())
{
return 0;
}
else
{
switch (Global_19954.f_1)
{
case 7:
return 0;
break;
case 8:
return 0;
break;
case 9:
break;
case 10:
break;
default:
break;
}
if (BitTest(Global_7824, 9))
{
return 0;
}
}
func_409();
Global_21295 = bParam2;
}
Global_21287 = iParam1;
StringCopy(&Global_20904, sParam0, 24);
Global_20151 = 0;
func_408();
func_403();
return 1;
}
if (Global_21285 == 5)
{
return 0;
}
if (iParam1 < Global_21287 || iParam1 == Global_21287)
{
return 0;
}
if (iParam1 == 2)
{
}
else
{
func_414();
}
return 0;
}
void func_403()
{
if (!func_404())
{
return;
}
if (Global_21291)
{
MemCopy(&(Global_1973354.f_1), {Global_20904}, 4);
Global_1973354 = Global_7139;
Global_1973354.f_6 = Global_21295;
}
}
int func_404()
{
if (!Global_262145.f_28542)
{
return 0;
}
if (!Global_77858)
{
return 0;
}
if (PLAYER::PLAYER_ID() == func_407())
{
return 0;
}
if (func_405(PLAYER::PLAYER_ID()))
{
return 0;
}
if (BitTest(Global_1893551[PLAYER::PLAYER_ID() /*599*/].f_1, 7))
{
return 0;
}
if (NETWORK::NETWORK_IS_ACTIVITY_SESSION())
{
return 0;
}
return 1;
}
bool func_405(int iParam0)
{
return func_406(iParam0, 20);
}
var func_406(int iParam0, int iParam1)
{
return BitTest(Global_1893551[iParam0 /*599*/].f_10.f_4, iParam1);
}
int func_407()
{
return -1;
}
void func_408()
{
int iVar0;
iVar0 = 0;
while (iVar0 <= 69)
{
StringCopy(&(Global_20153[iVar0 /*6*/]), "", 24);
iVar0++;
}
AUDIO::STOP_SCRIPTED_CONVERSATION(false);
Global_21285 = 1;
}
void func_409()
{
Global_21338 = Global_21337;
Global_21332 = Global_21333;
Global_21379 = { Global_21367 };
Global_21385 = { Global_21373 };
Global_21340 = Global_21339;
Global_21409 = { Global_21391 };
Global_21415 = { Global_21397 };
Global_21421 = { Global_21403 };
Global_21427 = { Global_21433 };
Global_7139 = Global_7140;
Global_7141 = Global_7142;
Global_21296 = Global_21297;
Global_21298 = Global_21299;
Global_21300 = { Global_21316 };
Global_21289 = Global_21290;
Global_22301 = 0;
Global_21334 = 0;
Global_21335 = 0;
MISC::CLEAR_BIT(&Global_7825, 16);
}
int func_410()
{
int iVar0;
int iVar1;
if (Global_77858)
{
iVar0 = 0;
WEAPON::GET_CURRENT_PED_WEAPON(PLAYER::PLAYER_PED_ID(), &iVar1, true);
if (PLAYER::IS_PLAYER_PLAYING(PLAYER::PLAYER_ID()))
{
if ((iVar1 == joaat("weapon_sniperrifle") || iVar1 == joaat("weapon_heavysniper")) || iVar1 == joaat("weapon_remotesniper"))
{
iVar0 = 1;
}
}
if (CAM::IS_AIM_CAM_ACTIVE() && iVar0 == 1)
{
return 1;
}
else
{
return 0;
}
}
if (PLAYER::IS_PLAYER_PLAYING(PLAYER::PLAYER_ID()))
{
if (PED::GET_PED_CONFIG_FLAG(PLAYER::PLAYER_PED_ID(), 78, true))
{
return 1;
}
else
{
return 0;
}
}
return 1;
}
void func_411()
{
if (func_252(14))
{
if (!ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
if (ENTITY::GET_ENTITY_MODEL(PLAYER::PLAYER_PED_ID()) == Global_112922.f_28050[0 /*29*/])
{
Global_19954 = 0;
}
else if (ENTITY::GET_ENTITY_MODEL(PLAYER::PLAYER_PED_ID()) == Global_112922.f_28050[1 /*29*/])
{
Global_19954 = 1;
}
else if (ENTITY::GET_ENTITY_MODEL(PLAYER::PLAYER_PED_ID()) == Global_112922.f_28050[2 /*29*/])
{
Global_19954 = 2;
}
else
{
Global_19954 = 0;
}
}
}
else
{
Global_19954 = func_428();
if (Global_19954 == 145)
{
Global_19954 = 3;
}
if (Global_77858)
{
Global_19954 = 3;
}
if (Global_19954 > 3)
{
Global_19954 = 3;
}
}
}
void func_412()
{
int iVar0;
iVar0 = 0;
while (iVar0 <= 15)
{
Global_20574[iVar0 /*10*/] = 0;
StringCopy(&(Global_20574[iVar0 /*10*/].f_1), "", 24);
Global_20574[iVar0 /*10*/].f_7 = 0;
Global_20574[iVar0 /*10*/].f_8 = 0;
iVar0++;
}
Global_20574.f_161 = -99;
Global_20574.f_162 = { 0f, 0f, 0f };
}
bool func_413(int iParam0, int iParam1)
{
switch (iParam0)
{
case 5:
if (iParam1 > -1)
{
return Global_1644218.f_203[iParam1];
}
break;
}
return BitTest(Global_1644218.f_1048, iParam0);
}
void func_414()
{
AUDIO::RESTART_SCRIPTED_CONVERSATION();
Global_22296 = 0;
if ((AUDIO::IS_MOBILE_PHONE_CALL_ONGOING() || Global_19954.f_1 == 9) || Global_19953 == 1)
{
AUDIO::STOP_SCRIPTED_CONVERSATION(false);
Global_21285 = 6;
Global_19954.f_1 = 3;
return;
}
if (AUDIO::IS_SCRIPTED_CONVERSATION_ONGOING())
{
AUDIO::STOP_SCRIPTED_CONVERSATION(true);
Global_21285 = 6;
return;
}
}
void func_415(var uParam0, int iParam1, char* sParam2, int iParam3, int iParam4, var uParam5)
{
Global_20739 = { *uParam0 };
Global_7140 = iParam1;
StringCopy(&Global_21355, sParam2, 24);
Global_22274 = uParam5;
if (iParam3 == 0)
{
Global_22272 = 1;
Global_22270 = 0;
}
else
{
Global_22272 = 0;
Global_22270 = 1;
}
if (iParam4 == 0)
{
Global_22273 = 1;
Global_22271 = 0;
}
else
{
Global_22273 = 0;
Global_22271 = 1;
}
}
var func_416(var uParam0)
{
return uParam0->f_4;
}
void func_417(var uParam0, var uParam1, var uParam2, var uParam3, var uParam4, int iParam5, var uParam6, var uParam7)
{
int iVar0;
struct<3> Var1;
struct<3> Var4;
struct<3> Var7;
iVar0 = func_433(uParam0, 0);
if (ENTITY::DOES_ENTITY_EXIST(iParam5) && !ENTITY::IS_ENTITY_DEAD(iParam5, false))
{
*uParam2 = { 10.2986f, 0f, 8.909f };
*uParam4 = { Vector(1.2f, 1.2f, 1.2f) * Vector(0f, -SYSTEM::COS((-97.4239f + func_464(uParam1))), SYSTEM::SIN((-97.4239f + func_464(uParam1)))) };
*uParam3 = { ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(iParam5, 1.12046f, -0.317773f, 1.3385f) };
Var1 = { func_463(*uParam4, uParam2->f_2) };
Var7 = { *uParam3 + Var1 };
*uParam6 = { (-33f + *uParam2), 0f, (-88.515f + func_464(uParam1)) };
*uParam7 = 26f;
Var4 = { *uParam6 };
Var4.f_2 = (Var4.f_2 + uParam2->f_2);
CAM::SET_CAM_COORD(iVar0, Var7);
CAM::SET_CAM_ROT(iVar0, Var4, 2);
CAM::SET_CAM_FOV(iVar0, *uParam7);
CAM::SET_CAM_NEAR_CLIP(iVar0, func_331());
}
CAM::SET_CAM_ACTIVE(iVar0, true);
CAM::RENDER_SCRIPT_CAMS(true, false, 3000, true, false, 0);
}
void func_418(bool bParam0, bool bParam1, int iParam2, bool bParam3, bool bParam4, bool bParam5, bool bParam6)
{
if (bParam0)
{
PLAYER::SPECIAL_ABILITY_DEACTIVATE_FAST(PLAYER::PLAYER_ID(), 0);
PLAYER::SET_ALL_RANDOM_PEDS_FLEE(PLAYER::PLAYER_ID(), true);
PLAYER::SET_POLICE_IGNORE_PLAYER(PLAYER::PLAYER_ID(), true);
func_425(1);
HUD::THEFEED_FLUSH_QUEUE();
HUD::THEFEED_PAUSE();
if (Global_19954.f_1 > 3 && !bParam6)
{
if (AUDIO::IS_MOBILE_PHONE_CALL_ONGOING())
{
AUDIO::STOP_SCRIPTED_CONVERSATION(false);
}
if (!func_28())
{
Global_19954.f_1 = 3;
}
Global_21285 = 5;
}
func_424(1, bParam3, iParam2, 0);
Global_62702 = 1;
Global_75030 = 1;
Global_77856 = 1;
}
else
{
func_425(0);
HUD::THEFEED_RESUME();
Global_62702 = 0;
if (bParam1)
{
GRAPHICS::CASCADE_SHADOWS_INIT_SESSION();
}
PLAYER::SET_ALL_RANDOM_PEDS_FLEE(PLAYER::PLAYER_ID(), false);
PLAYER::SET_POLICE_IGNORE_PLAYER(PLAYER::PLAYER_ID(), false);
func_424(0, bParam3, iParam2, 0);
if (NETWORK::NETWORK_IS_GAME_IN_PROGRESS())
{
if (((((!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()) && !func_422(PLAYER::PLAYER_ID())) && !func_420(PLAYER::PLAYER_ID(), 0)) && !func_419()) && !bParam4) && !bParam5)
{
ENTITY::SET_ENTITY_INVINCIBLE(PLAYER::PLAYER_PED_ID(), false);
}
}
else if (((!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()) && !func_422(PLAYER::PLAYER_ID())) && !bParam4) && !bParam5)
{
ENTITY::SET_ENTITY_INVINCIBLE(PLAYER::PLAYER_PED_ID(), false);
}
Global_77856 = 0;
}
}
bool func_419()
{
return BitTest(Global_1853131[PLAYER::PLAYER_ID() /*888*/].f_36.f_18, 14);
}
bool func_420(int iParam0, int iParam1)
{
bool bVar0;
if (iParam0 == PLAYER::PLAYER_ID())
{
bVar0 = func_421(-1, 0) == 8;
}
else
{
bVar0 = Global_1853131[iParam0 /*888*/].f_205 == 8;
}
if (iParam1 == 1)
{
if (NETWORK::NETWORK_IS_PLAYER_ACTIVE(iParam0))
{
bVar0 = PLAYER::GET_PLAYER_TEAM(iParam0) == 8;
}
}
return bVar0;
}
int func_421(int iParam0, bool bParam1)
{
int iVar0;
int iVar1;
iVar1 = iParam0;
if (iVar1 == -1)
{
iVar1 = func_232();
}
if (Global_1575034[iVar1] == 1)
{
if (bParam1)
{
}
iVar0 = 8;
}
else
{
iVar0 = Global_1574909[iVar1];
if (bParam1)
{
}
}
return iVar0;
}
int func_422(int iParam0)
{
if (func_420(iParam0, 0))
{
return 1;
}
if (func_423())
{
if (iParam0 == PLAYER::PLAYER_ID())
{
return 1;
}
}
if (BitTest(Global_2689224[iParam0 /*451*/].f_197, 2))
{
return 1;
}
return 0;
}
bool func_423()
{
return BitTest(Global_2621446, 3);
}
int func_424(bool bParam0, bool bParam1, var uParam2, bool bParam3)
{
int iVar0;
iVar0 = 0;
if (MISC::IS_PC_VERSION())
{
if (CUTSCENE::_0xA0FE76168A189DDB() != bParam0 && uParam2)
{
CUTSCENE::_0x20746F7B1032A3C7(bParam0, bParam1, true, bParam3);
iVar0 = 1;
}
}
return iVar0;
}
void func_425(int iParam0)
{
if (iParam0 == 1)
{
MISC::SET_BIT(&Global_7824, 13);
}
else
{
MISC::CLEAR_BIT(&Global_7824, 13);
}
}
float func_426(bool bParam0, int iParam1)
{
switch (bParam0)
{
case 3:
switch (iParam1)
{
case 0:
return 6f;
case 1:
return 7.3f;
case 2:
return 6.8f;
default:
}
break;
case 8:
switch (iParam1)
{
case 0:
return 4.2f;
case 1:
return 5.5f;
case 2:
return 5f;
default:
}
break;
case 5:
return 0f;
case 6:
return 0f;
case 12:
return 0f;
}
return 0f;
}
int func_427(bool bParam0)
{
switch (bParam0)
{
case 5:
return 3000;
case 6:
return 1500;
case 12:
return 2000;
default:
}
return 0;
}
int func_428()
{
func_429();
return Global_112922.f_2363.f_539.f_4321;
}
void func_429()
{
int iVar0;
if (ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID()))
{
if (func_37(Global_112922.f_2363.f_539.f_4321) != ENTITY::GET_ENTITY_MODEL(PLAYER::PLAYER_PED_ID()))
{
iVar0 = func_36(PLAYER::PLAYER_PED_ID());
if (func_39(iVar0) && (!func_252(14) || Global_111873))
{
if (Global_112922.f_2363.f_539.f_4321 != iVar0 && func_39(Global_112922.f_2363.f_539.f_4321))
{
Global_112922.f_2363.f_539.f_4322 = Global_112922.f_2363.f_539.f_4321;
}
Global_112922.f_2363.f_539.f_4323 = iVar0;
Global_112922.f_2363.f_539.f_4321 = iVar0;
return;
}
}
else
{
if (Global_112922.f_2363.f_539.f_4321 != 145)
{
Global_112922.f_2363.f_539.f_4323 = Global_112922.f_2363.f_539.f_4321;
}
return;
}
}
Global_112922.f_2363.f_539.f_4321 = 145;
}
float func_430(struct<2> Param0, var uParam2, struct<2> Param3, var uParam5)
{
return MISC::GET_HEADING_FROM_VECTOR_2D((Param3.f_0 - Param0.f_0), (Param3.f_1 - Param0.f_1));
}
int func_431(struct<3> Param0)
{
if ((Param0.f_0 == 0f && Param0.f_1 == 0f) && Param0.f_2 == 0f)
{
return 1;
}
return 0;
}
Vector3 func_432(bool bParam0)
{
switch (bParam0)
{
case 5:
return -120.0078f, -976.4348f, 295.2008f;
case 6:
return -1242.709f, 4539.658f, 185.6828f;
case 12:
return -768.0306f, 4330.409f, 147.6768f;
default:
}
return 0f, 0f, 0f;
}
int func_433(var uParam0, int iParam1)
{
if (iParam1 >= 2)
{
return 0;
}
return (*uParam0)[iParam1];
}
void func_434(int iParam0, bool bParam1, int iParam2)
{
PLAYER::SET_PLAYER_CONTROL(PLAYER::GET_PLAYER_INDEX(), false, iParam0);
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
FIRE::STOP_FIRE_IN_RANGE(ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), true), 15f);
}
CUTSCENE::_0xC61B86C9F61EB404(bParam1);
func_27(0);
func_418(1, 1, iParam2, 0, 0, 0, 0);
HUD::DISPLAY_RADAR(false);
HUD::DISPLAY_HUD(false);
func_558(23, 1);
}
void func_435(var uParam0, var uParam1, var uParam2, int* iParam3, int* iParam4, int* iParam5, int* iParam6, int* iParam7, int* iParam8, int* iParam9, int iParam10, int iParam11, int* iParam12, bool bParam13, int iParam14)
{
int iVar0;
int iVar1;
struct<3> Var2;
int iVar5;
int iVar6;
int iVar7;
if (ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
return;
}
if (func_431(func_457(uParam0)))
{
}
else
{
VEHICLE::SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(func_457(uParam0), func_456(uParam0), false, true);
}
iVar5 = 0;
while (iVar5 < 12)
{
if (!func_431(func_369(uParam0, iVar5)))
{
*uParam2 = iVar5 + 1;
}
else
{
iVar5 = 999999;
}
iVar5++;
}
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), false, 0);
WEAPON::SET_CURRENT_PED_WEAPON(PLAYER::PLAYER_PED_ID(), joaat("weapon_unarmed"), false);
WEAPON::GIVE_WEAPON_TO_PED(PLAYER::PLAYER_PED_ID(), joaat("gadget_parachute"), 1, false, false);
ENTITY::SET_ENTITY_INVINCIBLE(PLAYER::PLAYER_PED_ID(), false);
if (bParam13 == 4)
{
iVar1 = PLAYER::GET_PLAYERS_LAST_VEHICLE();
if (ENTITY::DOES_ENTITY_EXIST(iVar1))
{
if (ENTITY::IS_ENTITY_DEAD(iVar1, false))
{
VEHICLE::DELETE_VEHICLE(&iVar1);
}
else
{
Var2 = { ENTITY::GET_ENTITY_COORDS(iVar1, true) };
if (((((Var2.f_2 > 320f && Var2.f_2 < 340f) && Var2.f_0 > -103f) && Var2.f_0 < -45f) && Var2.f_1 > -850f) && Var2.f_1 < -787f)
{
ENTITY::SET_ENTITY_COORDS(iVar1, -89.794f, -742.6727f, 43.7472f, true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar1, -109.33f);
VEHICLE::SET_VEHICLE_DOORS_SHUT(iVar1, true);
}
}
}
}
else if (bParam13 == 3)
{
iVar1 = PLAYER::GET_PLAYERS_LAST_VEHICLE();
if (ENTITY::DOES_ENTITY_EXIST(iVar1))
{
if (ENTITY::IS_ENTITY_DEAD(iVar1, false))
{
VEHICLE::DELETE_VEHICLE(&iVar1);
}
else
{
Var2 = { ENTITY::GET_ENTITY_COORDS(iVar1, true) };
if (((((Var2.f_2 > 689.4f && Var2.f_2 < 701.8875f) && Var2.f_0 > 404.6f) && Var2.f_0 < 413.4f) && Var2.f_1 > 5700.6f) && Var2.f_1 < 5711.9f)
{
ENTITY::SET_ENTITY_COORDS(iVar1, -215.2838f, 6543.57f, 10.0967f, true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar1, 145.5732f);
VEHICLE::SET_VEHICLE_DOORS_SHUT(iVar1, true);
}
}
}
}
else if (bParam13 == 5)
{
iVar1 = PLAYER::GET_PLAYERS_LAST_VEHICLE();
if (ENTITY::DOES_ENTITY_EXIST(iVar1))
{
if (ENTITY::IS_ENTITY_DEAD(iVar1, false))
{
VEHICLE::DELETE_VEHICLE(&iVar1);
}
else
{
Var2 = { ENTITY::GET_ENTITY_COORDS(iVar1, true) };
if (((((Var2.f_2 > 294.5f && Var2.f_2 < 298.9f) && Var2.f_0 > -121.3f) && Var2.f_0 < -116.5f) && Var2.f_1 > -978.1f) && Var2.f_1 < -973.2f)
{
ENTITY::SET_ENTITY_COORDS(iVar1, -118.1021f, -947.3954f, 27.3296f, true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar1, 341.9614f);
VEHICLE::SET_VEHICLE_DOORS_SHUT(iVar1, true);
}
}
}
}
else if (bParam13 == 6)
{
iVar1 = PLAYER::GET_PLAYERS_LAST_VEHICLE();
if (ENTITY::DOES_ENTITY_EXIST(iVar1))
{
if (ENTITY::IS_ENTITY_DEAD(iVar1, false))
{
VEHICLE::DELETE_VEHICLE(&iVar1);
}
else
{
Var2 = { ENTITY::GET_ENTITY_COORDS(iVar1, true) };
if (((((Var2.f_2 > 182.7f && Var2.f_2 < 202.7f) && Var2.f_0 > -1252.7f) && Var2.f_0 < -1227.9f) && Var2.f_1 > 4525.8f) && Var2.f_1 < 4549.3f)
{
ENTITY::SET_ENTITY_COORDS(iVar1, -1237.022f, 4559.404f, 185.9418f, true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar1, 172.2123f);
VEHICLE::SET_VEHICLE_DOORS_SHUT(iVar1, true);
}
}
}
}
else if (bParam13 == 8)
{
iVar1 = PLAYER::GET_PLAYERS_LAST_VEHICLE();
if (ENTITY::DOES_ENTITY_EXIST(iVar1))
{
if (ENTITY::IS_ENTITY_DEAD(iVar1, false))
{
VEHICLE::DELETE_VEHICLE(&iVar1);
}
else
{
Var2 = { ENTITY::GET_ENTITY_COORDS(iVar1, true) };
if (((((Var2.f_2 > 230f && Var2.f_2 < 244.5f) && Var2.f_0 > -809.6f) && Var2.f_0 < -747.7f) && Var2.f_1 > 310.6f) && Var2.f_1 < 346.6f)
{
ENTITY::SET_ENTITY_COORDS(iVar1, -1351.805f, 133.95f, 55.2558f, true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar1, 0.8373f);
VEHICLE::SET_VEHICLE_DOORS_SHUT(iVar1, true);
}
}
}
}
else if (bParam13 == 12)
{
iVar1 = PLAYER::GET_PLAYERS_LAST_VEHICLE();
if (ENTITY::DOES_ENTITY_EXIST(iVar1))
{
if (ENTITY::IS_ENTITY_DEAD(iVar1, false))
{
VEHICLE::DELETE_VEHICLE(&iVar1);
}
else
{
Var2 = { ENTITY::GET_ENTITY_COORDS(iVar1, true) };
if (((((Var2.f_2 > 143.6f && Var2.f_2 < 154.5f) && Var2.f_0 > -777f) && Var2.f_0 < -758.9f) && Var2.f_1 > 4328.3f) && Var2.f_1 < 4344f)
{
ENTITY::SET_ENTITY_COORDS(iVar1, -765.8775f, 4294.807f, 145.6581f, true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar1, 349.2306f);
VEHICLE::SET_VEHICLE_DOORS_SHUT(iVar1, true);
}
}
}
}
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), false, 0);
WEAPON::SET_CURRENT_PED_WEAPON(PLAYER::PLAYER_PED_ID(), joaat("weapon_unarmed"), false);
WEAPON::GIVE_WEAPON_TO_PED(PLAYER::PLAYER_PED_ID(), joaat("gadget_parachute"), 1, false, false);
}
iVar0 = func_466(bParam13);
if (iVar0 != 0)
{
if (!ENTITY::IS_ENTITY_DEAD(*iParam3, false) || ENTITY::DOES_ENTITY_EXIST(*iParam3))
{
VEHICLE::SET_VEHICLE_FIXED(*iParam3);
ENTITY::SET_ENTITY_COORDS(*iParam3, func_473(bParam13), true, false, false, true);
ENTITY::SET_ENTITY_HEADING(*iParam3, func_464(uParam0));
}
else
{
*iParam3 = VEHICLE::CREATE_VEHICLE(iVar0, func_473(bParam13), func_464(uParam0), true, true, false);
}
if (func_465(iVar0))
{
if (!ENTITY::DOES_ENTITY_EXIST(*iParam8) || ENTITY::IS_ENTITY_DEAD(*iParam8, false))
{
*iParam8 = PED::CREATE_PED_INSIDE_VEHICLE(*iParam3, 26, iParam10, -1, true, true);
PED::SET_PED_HELMET(*iParam8, false);
func_455(*iParam8, bParam13);
ENTITY::SET_ENTITY_INVINCIBLE(*iParam8, true);
}
CAM::SHAKE_SCRIPT_GLOBAL("SKY_DIVING_SHAKE", 0.15f);
func_453(uParam1, *iParam8, func_454(bParam13));
func_450(uParam1, PLAYER::PLAYER_PED_ID(), func_452());
VEHICLE::SET_HELI_BLADES_SPEED(*iParam3, 0.7f);
ENTITY::FREEZE_ENTITY_POSITION(*iParam3, true);
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
if (!PED::IS_PED_IN_VEHICLE(PLAYER::PLAYER_PED_ID(), *iParam3, false))
{
ENTITY::DETACH_ENTITY(PLAYER::PLAYER_PED_ID(), true, true);
ENTITY::FREEZE_ENTITY_POSITION(PLAYER::PLAYER_PED_ID(), false);
PED::SET_PED_INTO_VEHICLE(PLAYER::PLAYER_PED_ID(), *iParam3, 2);
}
else if (func_449(PLAYER::PLAYER_PED_ID(), *iParam3) == 1)
{
ENTITY::FREEZE_ENTITY_POSITION(PLAYER::PLAYER_PED_ID(), false);
PED::SET_PED_INTO_VEHICLE(PLAYER::PLAYER_PED_ID(), *iParam3, 2);
}
}
if (!ENTITY::IS_ENTITY_DEAD(*iParam3, false))
{
*iParam14 = PED::CREATE_SYNCHRONIZED_SCENE(0f, 0f, 0f, 0f, 0f, 0f, 2);
PED::ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(*iParam14, *iParam3, ENTITY::GET_ENTITY_BONE_INDEX_BY_NAME(*iParam3, "Chassis"));
TASK::TASK_SYNCHRONIZED_SCENE(PLAYER::PLAYER_PED_ID(), *iParam14, "oddjobs@basejump@", "Heli_door_loop", 4f, -4f, 65, 0, 1000f, 0);
PED::SET_SYNCHRONIZED_SCENE_LOOPED(*iParam14, true);
}
func_486(iParam12);
}
else if (func_365(iVar0))
{
func_450(uParam1, PLAYER::PLAYER_PED_ID(), func_452());
ENTITY::FREEZE_ENTITY_POSITION(PLAYER::PLAYER_PED_ID(), false);
PED::SET_PED_INTO_VEHICLE(PLAYER::PLAYER_PED_ID(), *iParam3, -1);
PED::GIVE_PED_HELMET(PLAYER::PLAYER_PED_ID(), false, 4096, -1);
func_486(iParam12);
}
}
else
{
func_450(uParam1, PLAYER::PLAYER_PED_ID(), func_452());
if (func_378(uParam0))
{
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()) && (PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), true) || PED::IS_PED_ON_VEHICLE(PLAYER::PLAYER_PED_ID())))
{
PED::_0xF9ACF4A08098EA25(PLAYER::PLAYER_PED_ID(), true);
}
ENTITY::SET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), func_473(bParam13), true, false, false, true);
ENTITY::SET_ENTITY_HEADING(PLAYER::PLAYER_PED_ID(), func_464(uParam0));
TASK::TASK_STAND_STILL(PLAYER::PLAYER_PED_ID(), -1);
if (ENTITY::DOES_ENTITY_EXIST(*iParam3))
{
iVar6 = -1;
while (iVar6 <= (VEHICLE::GET_VEHICLE_MAX_NUMBER_OF_PASSENGERS(*iParam3) - 1))
{
if (!VEHICLE::IS_VEHICLE_SEAT_FREE(*iParam3, iVar6, false))
{
iVar7 = VEHICLE::GET_PED_IN_VEHICLE_SEAT(*iParam3, iVar6, false);
PED::DELETE_PED(&iVar7);
}
iVar6++;
}
VEHICLE::DELETE_VEHICLE(iParam3);
}
}
}
PED::SET_PED_RESET_FLAG(PLAYER::PLAYER_PED_ID(), 177, true);
PED::SET_PED_CONFIG_FLAG(PLAYER::PLAYER_PED_ID(), 36, true);
if (func_531(uParam0) != 0)
{
func_445(uParam0, iParam5, bParam13);
}
if (func_444(uParam0) != 0)
{
func_441(uParam0, iParam7);
}
iVar0 = func_368(uParam0);
if (func_367(iVar0))
{
VEHICLE::DELETE_ALL_TRAINS();
VEHICLE::SET_RANDOM_TRAINS(false);
}
else if (iVar0 != 0)
{
MISC::CLEAR_AREA(func_369(uParam0, 0), 100f, true, false, false, false);
if (ENTITY::DOES_ENTITY_EXIST(*iParam4) && ENTITY::IS_ENTITY_DEAD(*iParam4, false))
{
VEHICLE::DELETE_VEHICLE(iParam4);
}
if (!ENTITY::DOES_ENTITY_EXIST(*iParam4))
{
*iParam4 = VEHICLE::CREATE_VEHICLE(iVar0, func_369(uParam0, 0), func_440(uParam0), true, true, false);
if (func_439(func_368(uParam0)))
{
VEHICLE::SET_VEHICLE_COLOUR_COMBINATION(*iParam4, 11);
}
else if (func_438(func_368(uParam0)))
{
VEHICLE::SET_VEHICLE_EXTRA(*iParam4, 1, true);
VEHICLE::SET_VEHICLE_COLOUR_COMBINATION(*iParam4, 6);
VEHICLE::SET_VEHICLE_LIGHTS(*iParam4, 2);
VEHICLE::SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(200f);
ENTITY::SET_ENTITY_LOD_DIST(*iParam4, 1000);
}
ENTITY::SET_ENTITY_LOAD_COLLISION_FLAG(*iParam4, true, 1);
}
else if (!ENTITY::IS_ENTITY_DEAD(*iParam4, false))
{
VEHICLE::SET_VEHICLE_FIXED(*iParam4);
ENTITY::SET_ENTITY_COORDS(*iParam4, func_369(uParam0, 0), true, false, false, true);
ENTITY::SET_ENTITY_HEADING(*iParam4, func_440(uParam0));
}
if (func_439(func_368(uParam0)))
{
if (ENTITY::DOES_ENTITY_EXIST(*iParam6) && ENTITY::IS_ENTITY_DEAD(*iParam6, false))
{
VEHICLE::DELETE_VEHICLE(iParam6);
}
if (!ENTITY::DOES_ENTITY_EXIST(*iParam6))
{
*iParam6 = VEHICLE::CREATE_VEHICLE(joaat("trflat"), ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(*iParam4, 0f, -10f, 0f), func_440(uParam0), true, true, false);
ENTITY::SET_ENTITY_LOAD_COLLISION_FLAG(*iParam6, true, 1);
ENTITY::SET_ENTITY_LOD_DIST(*iParam6, 2000);
}
else if (!ENTITY::IS_ENTITY_DEAD(*iParam6, false))
{
VEHICLE::SET_VEHICLE_FIXED(*iParam6);
}
if (!VEHICLE::IS_VEHICLE_ATTACHED_TO_TRAILER(*iParam4))
{
VEHICLE::ATTACH_VEHICLE_TO_TRAILER(*iParam4, *iParam6, 1f);
}
}
if (ENTITY::DOES_ENTITY_EXIST(*iParam9) && ENTITY::IS_ENTITY_DEAD(*iParam9, false))
{
PED::DELETE_PED(iParam9);
}
if (!ENTITY::DOES_ENTITY_EXIST(*iParam9))
{
*iParam9 = PED::CREATE_PED_INSIDE_VEHICLE(*iParam4, 26, iParam11, -1, true, true);
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(*iParam9, true, false);
PED::SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(*iParam9, true);
func_437(*iParam9, bParam13);
if (bParam13 == 0)
{
func_436(uParam1, 2, *iParam9, "EX3MERC1", 0, 1);
}
}
else
{
ENTITY::SET_ENTITY_HEALTH(*iParam9, ENTITY::GET_ENTITY_MAX_HEALTH(*iParam9), 0);
PED::RESET_PED_VISIBLE_DAMAGE(*iParam9);
TASK::CLEAR_PED_TASKS(*iParam9);
if (!PED::IS_PED_IN_VEHICLE(*iParam9, *iParam4, false) || VEHICLE::GET_PED_IN_VEHICLE_SEAT(*iParam4, -1, false) != *iParam9)
{
if (PED::IS_PED_IN_ANY_VEHICLE(*iParam9, true))
{
PED::_0xF9ACF4A08098EA25(*iParam9, true);
}
PED::SET_PED_INTO_VEHICLE(*iParam9, *iParam4, -1);
}
}
ENTITY::SET_ENTITY_LOAD_COLLISION_FLAG(*iParam9, true, 1);
}
if (func_428() == 0)
{
PED::SET_PED_COMPONENT_VARIATION(PLAYER::PLAYER_PED_ID(), 9, 5, 0, 0);
}
else if (func_428() == 1)
{
PED::SET_PED_COMPONENT_VARIATION(PLAYER::PLAYER_PED_ID(), 8, 1, 0, 0);
}
else if (func_428() == 2)
{
PED::SET_PED_COMPONENT_VARIATION(PLAYER::PLAYER_PED_ID(), 8, 3, 0, 0);
}
}
void func_436(var uParam0, int iParam1, int iParam2, char* sParam3, int iParam4, int iParam5)
{
if ((uParam0[iParam1 /*10*/])->f_7 == 1)
{
}
(*uParam0)[iParam1 /*10*/] = iParam2;
StringCopy(&((uParam0[iParam1 /*10*/])->f_1), sParam3, 24);
(uParam0[iParam1 /*10*/])->f_7 = 1;
(uParam0[iParam1 /*10*/])->f_8 = iParam4;
(uParam0[iParam1 /*10*/])->f_9 = iParam5;
if (!Global_77858)
{
if (!PED::IS_PED_INJURED(iParam2))
{
if ((uParam0[iParam1 /*10*/])->f_8 == 0)
{
PED::SET_PED_CAN_PLAY_AMBIENT_ANIMS(iParam2, false);
}
else
{
PED::SET_PED_CAN_PLAY_AMBIENT_ANIMS(iParam2, true);
}
}
if (!PED::IS_PED_INJURED(iParam2))
{
if ((uParam0[iParam1 /*10*/])->f_9 == 0)
{
PED::SET_PED_CAN_USE_AUTO_CONVERSATION_LOOKAT(iParam2, false);
}
else
{
PED::SET_PED_CAN_USE_AUTO_CONVERSATION_LOOKAT(iParam2, true);
}
}
}
}
void func_437(int iParam0, bool bParam1)
{
if (ENTITY::IS_ENTITY_DEAD(iParam0, false))
{
return;
}
switch (bParam1)
{
case 0:
PED::SET_PED_COMPONENT_VARIATION(iParam0, 0, 1, 0, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 3, 0, 0, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 4, 0, 2, 0);
PED::CLEAR_PED_PROP(iParam0, 0);
PED::SET_PED_PROP_INDEX(iParam0, 1, 1, 0, false);
break;
case 5:
PED::SET_PED_COMPONENT_VARIATION(iParam0, 0, 0, 1, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 2, 0, 1, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 3, 1, 2, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 4, 1, 1, 0);
PED::CLEAR_PED_PROP(iParam0, 0);
PED::CLEAR_PED_PROP(iParam0, 1);
break;
case 7:
PED::SET_PED_COMPONENT_VARIATION(iParam0, 0, 0, 1, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 3, 0, 2, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 4, 0, 2, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 8, 0, 1, 0);
PED::SET_PED_PROP_INDEX(iParam0, 0, 0, 2, false);
break;
}
}
int func_438(int iParam0)
{
switch (iParam0)
{
case joaat("seashark"):
case joaat("seashark2"):
case joaat("dinghy"):
case joaat("jetmax"):
case joaat("marquis"):
case joaat("squalo"):
case joaat("suntrap"):
case joaat("tropic"):
case joaat("predator"):
return 1;
default:
}
return 0;
}
int func_439(int iParam0)
{
switch (iParam0)
{
case joaat("hauler"):
case joaat("biff"):
case joaat("packer"):
case joaat("trash"):
case joaat("benson"):
case joaat("phantom"):
case joaat("pounder"):
return 1;
default:
}
return 0;
}
var func_440(var uParam0)
{
return uParam0->f_77;
}
void func_441(var uParam0, int* iParam1)
{
if (!ENTITY::DOES_ENTITY_EXIST(*iParam1))
{
*iParam1 = VEHICLE::CREATE_VEHICLE(func_444(uParam0), func_443(uParam0), func_442(uParam0), true, true, false);
}
else if (ENTITY::IS_ENTITY_DEAD(*iParam1, false))
{
VEHICLE::DELETE_VEHICLE(iParam1);
*iParam1 = VEHICLE::CREATE_VEHICLE(func_444(uParam0), func_443(uParam0), func_442(uParam0), true, true, false);
}
else
{
VEHICLE::SET_VEHICLE_FIXED(*iParam1);
}
}
var func_442(var uParam0)
{
return uParam0->f_79;
}
Vector3 func_443(var uParam0)
{
return uParam0->f_9;
}
int func_444(var uParam0)
{
return uParam0->f_3;
}
void func_445(var uParam0, var uParam1, bool bParam2)
{
int iVar0;
int iVar1;
int iVar2;
if (ENTITY::DOES_ENTITY_EXIST(*uParam1))
{
if (!func_326(*uParam1) && ENTITY::DOES_ENTITY_EXIST(VEHICLE::GET_PED_IN_VEHICLE_SEAT(*uParam1, -1, false)))
{
iVar1 = VEHICLE::GET_PED_IN_VEHICLE_SEAT(*uParam1, -1, false);
}
iVar2 = *uParam1;
}
iVar0 = func_448(bParam2);
if (iVar0 != 0)
{
if (!ENTITY::DOES_ENTITY_EXIST(iVar2))
{
iVar2 = VEHICLE::CREATE_VEHICLE(func_531(uParam0), func_447(uParam0), func_446(uParam0), true, true, false);
}
else
{
ENTITY::SET_ENTITY_COORDS(iVar2, func_447(uParam0), true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar2, func_446(uParam0));
}
ENTITY::FREEZE_ENTITY_POSITION(iVar2, true);
if (!ENTITY::DOES_ENTITY_EXIST(iVar1))
{
iVar1 = PED::CREATE_PED_INSIDE_VEHICLE(iVar2, 26, iVar0, -1, true, true);
}
PED::SET_PED_HELMET(iVar1, false);
func_455(iVar1, bParam2);
}
else
{
if (!ENTITY::DOES_ENTITY_EXIST(iVar2))
{
iVar2 = VEHICLE::CREATE_VEHICLE(func_531(uParam0), func_447(uParam0), func_446(uParam0), true, true, false);
}
else
{
ENTITY::SET_ENTITY_COORDS(iVar2, func_447(uParam0), true, false, false, true);
ENTITY::SET_ENTITY_HEADING(iVar2, func_446(uParam0));
}
ENTITY::FREEZE_ENTITY_POSITION(iVar2, true);
if (!ENTITY::DOES_ENTITY_EXIST(iVar1))
{
iVar1 = PED::CREATE_PED_INSIDE_VEHICLE(iVar2, 26, joaat("s_m_y_pilot_01"), -1, true, true);
}
PED::SET_PED_HELMET(iVar1, false);
PED::SET_PED_PROP_INDEX(iVar1, 0, 2, 0, false);
PED::SET_PED_PROP_INDEX(iVar1, 1, 0, 0, false);
}
VEHICLE::SET_VEHICLE_ENGINE_ON(iVar2, true, true, false);
VEHICLE::SET_HELI_BLADES_SPEED(iVar2, 0.7f);
TASK::CLEAR_PED_TASKS(iVar1);
TASK::TASK_STAND_STILL(iVar1, -1);
*uParam1 = iVar2;
}
var func_446(var uParam0)
{
return uParam0->f_78;
}
Vector3 func_447(var uParam0)
{
return uParam0->f_70;
}
int func_448(bool bParam0)
{
switch (bParam0)
{
case 0:
return joaat("s_m_y_pilot_01");
case 1:
return joaat("s_m_y_pilot_01");
case 2:
return joaat("s_m_y_pilot_01");
case 3:
return joaat("s_m_y_pilot_01");
case 7:
return joaat("a_m_y_hippy_01");
case 9:
return joaat("s_m_y_pilot_01");
case 10:
return joaat("s_m_y_pilot_01");
case 11:
return joaat("a_m_m_genfat_02");
default:
}
return 0;
}
int func_449(int iParam0, int iParam1)
{
if (!ENTITY::IS_ENTITY_DEAD(iParam0, false) && !ENTITY::IS_ENTITY_DEAD(iParam1, false))
{
if (PED::IS_PED_SITTING_IN_VEHICLE(iParam0, iParam1))
{
if (VEHICLE::GET_PED_IN_VEHICLE_SEAT(iParam1, -1, false) == iParam0)
{
return -1;
}
if (VEHICLE::GET_PED_IN_VEHICLE_SEAT(iParam1, 0, false) == iParam0)
{
return 0;
}
if (VEHICLE::GET_PED_IN_VEHICLE_SEAT(iParam1, 1, false) == iParam0)
{
return 1;
}
if (VEHICLE::GET_PED_IN_VEHICLE_SEAT(iParam1, 2, false) == iParam0)
{
return 2;
}
}
}
return -2;
}
void func_450(var uParam0, int iParam1, char* sParam2)
{
int iVar0;
iVar0 = func_451();
if (!PED::IS_PED_INJURED(iParam1))
{
func_436(uParam0, iVar0, iParam1, sParam2, 1, 1);
}
else
{
func_436(uParam0, iVar0, 0, sParam2, 0, 1);
}
}
int func_451()
{
if (func_428() == 1)
{
return 2;
}
if (func_428() == 2)
{
return 3;
}
return 1;
}
char* func_452()
{
int iVar0;
iVar0 = func_36(PLAYER::PLAYER_PED_ID());
switch (iVar0)
{
case 0:
return "MICHAEL";
case 2:
return "TREVOR";
case 1:
return "FRANKLIN";
default:
}
return "";
}
void func_453(var uParam0, int iParam1, char* sParam2)
{
int iVar0;
iVar0 = 0;
if (!PED::IS_PED_INJURED(iParam1))
{
func_436(uParam0, iVar0, iParam1, sParam2, 1, 1);
}
else
{
func_436(uParam0, iVar0, 0, sParam2, 0, 1);
}
}
char* func_454(bool bParam0)
{
return "EXT1HELIPILOT";
}
void func_455(int iParam0, bool bParam1)
{
if (ENTITY::IS_ENTITY_DEAD(iParam0, false))
{
return;
}
switch (bParam1)
{
case 7:
PED::SET_PED_COMPONENT_VARIATION(iParam0, 0, 0, 1, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 2, 1, 0, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 3, 0, 0, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 4, 0, 0, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 8, 1, 0, 0);
PED::SET_PED_PROP_INDEX(iParam0, 1, 0, 0, false);
break;
case 11:
PED::SET_PED_COMPONENT_VARIATION(iParam0, 0, 1, 0, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 2, 2, 0, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 3, 1, 0, 0);
PED::SET_PED_COMPONENT_VARIATION(iParam0, 4, 0, 2, 0);
PED::SET_PED_PROP_INDEX(iParam0, 0, 1, 2, false);
PED::SET_PED_PROP_INDEX(iParam0, 1, 1, 0, false);
break;
}
}
Vector3 func_456(var uParam0)
{
return uParam0->f_67;
}
Vector3 func_457(var uParam0)
{
return uParam0->f_64;
}
void func_458(int* iParam0)
{
iParam0->f_1 = 0f;
iParam0->f_2 = 0f;
*iParam0 = 0;
}
int func_459(var uParam0, int* iParam1, var uParam2, bool bParam3, int iParam4, bool bParam5)
{
char cVar0[64];
if (!func_465(func_466(bParam3)))
{
STREAMING::REQUEST_ADDITIONAL_COLLISION_AT_COORD(func_473(bParam3));
}
if (func_462(iParam1))
{
if (func_461(iParam1) >= 5f)
{
return 1;
}
}
else
{
func_342(iParam1, 0f);
}
if (CAM::IS_SCREEN_FADED_OUT())
{
if (!STREAMING::IS_NEW_LOAD_SCENE_LOADED())
{
return 0;
}
}
if (func_465(func_466(bParam3)))
{
if (!STREAMING::HAS_ANIM_DICT_LOADED("veh@helicopter@rps@base"))
{
return 0;
}
}
if (func_426(bParam3, 0) > 0f)
{
switch (iParam4)
{
case 0:
StringCopy(&cVar0, "amb@world_human_hiker_standing@male@idle_a", 64);
break;
case 1:
StringCopy(&cVar0, "amb@world_human_muscle_flex@arms_at_side@base", 64);
break;
case 2:
StringCopy(&cVar0, "playidles_cold", 64);
break;
}
if (!STREAMING::HAS_ANIM_DICT_LOADED(&cVar0))
{
return 0;
}
}
if (func_460(uParam0))
{
if (GRAPHICS::HAS_SCALEFORM_MOVIE_LOADED(*uParam2))
{
if (HUD::HAS_ADDITIONAL_TEXT_LOADED(2))
{
if (GRAPHICS::HAS_STREAMED_TEXTURE_DICT_LOADED("basejumping"))
{
if (((STREAMING::HAS_ANIM_DICT_LOADED("oddjobs@basejump@") && STREAMING::HAS_ANIM_DICT_LOADED("skydive@freefall")) && STREAMING::HAS_ANIM_DICT_LOADED("skydive@parachute@chute")) && STREAMING::HAS_ANIM_DICT_LOADED("skydive@parachute@"))
{
if (PED::CAN_CREATE_RANDOM_PED(false))
{
if (!bParam5 || CAM::IS_SCREEN_FADED_OUT())
{
return 1;
}
}
}
}
}
}
}
return 0;
}
int func_460(var uParam0)
{
int iVar0;
iVar0 = 0;
while (iVar0 < *uParam0)
{
if ((*uParam0)[iVar0] != 0)
{
if (!STREAMING::HAS_MODEL_LOADED((*uParam0)[iVar0]))
{
if (!STREAMING::HAS_MODEL_LOADED((*uParam0)[iVar0]))
{
}
return 0;
}
}
iVar0++;
}
return 1;
}
float func_461(int* iParam0)
{
if (func_462(iParam0))
{
if (func_354(iParam0))
{
return iParam0->f_2;
}
else
{
return (func_43(BitTest(*iParam0, 4)) - iParam0->f_1);
}
}
return iParam0->f_1;
}
bool func_462(int* iParam0)
{
return BitTest(*iParam0, 1);
}
Vector3 func_463(struct<3> Param0, float fParam3)
{
struct<3> Var0;
float fVar3;
float fVar4;
fVar3 = SYSTEM::SIN(fParam3);
fVar4 = SYSTEM::COS(fParam3);
Var0.f_0 = ((Param0.f_0 * fVar4) - (Param0.f_1 * fVar3));
Var0.f_1 = ((Param0.f_0 * fVar3) + (Param0.f_1 * fVar4));
Var0.f_2 = Param0.f_2;
return Var0;
}
float func_464(var uParam0)
{
return uParam0->f_76;
}
int func_465(int iParam0)
{
switch (iParam0)
{
case joaat("annihilator"):
case joaat("buzzard"):
case joaat("buzzard2"):
case joaat("cargobob"):
case joaat("cargobob2"):
case joaat("frogger"):
case joaat("maverick"):
case joaat("polmav"):
case joaat("skylift"):
return 1;
default:
}
return 0;
}
int func_466(bool bParam0)
{
switch (bParam0)
{
case 0:
case 1:
case 2:
case 7:
case 9:
case 10:
case 11:
return joaat("maverick");
break;
case 4:
return joaat("bati");
break;
}
return 0;
}
void func_467(var uParam0, bool bParam1, var uParam2, var uParam3, var uParam4, var uParam5, var uParam6)
{
int iVar0;
int iVar1;
func_26(1);
AUDIO::SET_FRONTEND_RADIO_ACTIVE(false);
if (!ENTITY::IS_ENTITY_DEAD(PLAYER::PLAYER_PED_ID(), false))
{
PED::SET_PED_LOD_MULTIPLIER(PLAYER::PLAYER_PED_ID(), 2f);
}
switch (bParam1)
{
case 0:
PED::ADD_SCENARIO_BLOCKING_AREA(-901.2005f, 4422.489f, 19.3471f, -906.842f, 4424.97f, 300.017f, false, true, true, true);
break;
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
func_472(1, 1);
break;
case 9:
break;
case 10:
break;
case 11:
break;
case 12:
break;
}
if (CAM::IS_SCREEN_FADED_OUT())
{
MISC::CLEAR_AREA(func_473(bParam1), 5000f, true, false, false, false);
}
HUD::REQUEST_ADDITIONAL_TEXT("BJUMP", 2);
iVar0 = func_466(bParam1);
if (iVar0 != 0)
{
if (func_465(iVar0))
{
STREAMING::REQUEST_ANIM_DICT("veh@helicopter@rps@base");
*uParam3 = func_448(bParam1);
func_470(uParam2, *uParam3);
}
func_470(uParam2, iVar0);
}
if (func_531(uParam0) != 0)
{
func_470(uParam2, func_531(uParam0));
if (func_448(bParam1) != 0)
{
func_470(uParam2, func_448(bParam1));
}
else
{
func_470(uParam2, joaat("s_m_y_pilot_01"));
}
}
iVar1 = func_368(uParam0);
if (iVar1 != 0)
{
*uParam4 = func_469(bParam1);
func_470(uParam2, *uParam4);
func_470(uParam2, iVar1);
func_470(uParam2, joaat("trflat"));
}
if (func_367(iVar1))
{
func_470(uParam2, joaat("freight"));
func_470(uParam2, joaat("freightcar"));
func_470(uParam2, joaat("freightgrain"));
func_470(uParam2, joaat("freightcont1"));
func_470(uParam2, joaat("freightcont2"));
func_470(uParam2, joaat("tankercar"));
func_470(uParam2, joaat("metrotrain"));
}
if (func_444(uParam0) != 0)
{
func_470(uParam2, func_444(uParam0));
}
*uParam5 = func_171();
func_468(uParam2);
STREAMING::REQUEST_ANIM_DICT("oddjobs@basejump@");
STREAMING::REQUEST_ANIM_DICT("skydive@freefall");
STREAMING::REQUEST_ANIM_DICT("skydive@parachute@chute");
STREAMING::REQUEST_ANIM_DICT("skydive@parachute@");
GRAPHICS::REQUEST_STREAMED_TEXTURE_DICT("basejumping", false);
if (func_426(bParam1, 0) > 0f)
{
*uParam6 = MISC::GET_RANDOM_INT_IN_RANGE(0, 2);
switch (*uParam6)
{
case 0:
STREAMING::REQUEST_ANIM_DICT("amb@world_human_hiker_standing@male@idle_a");
break;
case 1:
STREAMING::REQUEST_ANIM_DICT("amb@world_human_muscle_flex@arms_at_side@base");
break;
}
}
if (func_466(bParam1) == 0)
{
STREAMING::REQUEST_ADDITIONAL_COLLISION_AT_COORD(func_473(bParam1));
}
}
void func_468(var uParam0)
{
int iVar0;
iVar0 = 0;
while (iVar0 < *uParam0)
{
if ((*uParam0)[iVar0] != 0)
{
STREAMING::REQUEST_MODEL((*uParam0)[iVar0]);
}
iVar0++;
}
}
int func_469(bool bParam0)
{
switch (bParam0)
{
case 0:
return joaat("a_m_y_beach_01");
case 5:
return joaat("s_m_m_trucker_01");
case 7:
return joaat("a_m_y_beach_01");
default:
}
return 0;
}
int func_470(var uParam0, int iParam1)
{
int iVar0;
int iVar1;
iVar0 = 0;
while (iVar0 < *uParam0)
{
if ((*uParam0)[iVar0] != 0)
{
if ((*uParam0)[iVar0] == iParam1)
{
return 0;
}
}
iVar0++;
}
iVar1 = func_471(uParam0);
if (iVar1 < 0 || iVar1 >= *uParam0)
{
return 0;
}
(*uParam0)[iVar1] = iParam1;
return 1;
}
int func_471(var uParam0)
{
int iVar0;
iVar0 = 0;
while (iVar0 < *uParam0)
{
if ((*uParam0)[iVar0] == 0)
{
return iVar0;
}
iVar0++;
}
return -1;
}
void func_472(bool bParam0, int iParam1)
{
MISC::SET_BIT(&Global_31670, bParam0);
StringCopy(&(Global_31671[bParam0 /*6*/]), SCRIPT::GET_THIS_SCRIPT_NAME(), 24);
Global_31726[bParam0] = iParam1;
}
Vector3 func_473(bool bParam0)
{
switch (bParam0)
{
case 0:
return -1152.053f, -1857.884f, 204.0663f;
case 1:
return 885.114f, -437.352f, 529.867f;
case 2:
return 2034.912f, 1971.051f, 582.7461f;
case 3:
return 409.7498f, 5703.525f, 695.17f;
case 4:
return -74.9632f, -827.4467f, 324.9521f;
case 5:
return -117.6998f, -975.571f, 295f;
case 6:
return -1243.784f, 4534.163f, 184.8471f;
case 7:
return -359.1f, 4119.5f, 304.1f;
case 8:
return -807.073f, 330.8846f, 232.6766f;
case 9:
return -1286.99f, 3668.922f, 1072.466f;
case 10:
return 1018.441f, 3956.706f, 1354f;
case 11:
return 1627.196f, -421.7584f, 1321.484f;
case 12:
return -766.5999f, 4334.805f, 147.1205f;
default:
}
return 0f, 0f, 0f;
}
int func_474(bool bParam0)
{
if (CAM::IS_SCREEN_FADED_OUT())
{
if (ENTITY::IS_ENTITY_AT_COORD(PLAYER::PLAYER_PED_ID(), func_473(bParam0), 15f, 15f, 15f, false, true, 0))
{
return 1;
}
ENTITY::SET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), func_473(bParam0), false, false, false, true);
if (ENTITY::IS_ENTITY_AT_COORD(PLAYER::PLAYER_PED_ID(), func_473(bParam0), 15f, 15f, 15f, false, true, 0))
{
return 1;
}
}
return 0;
}
Vector3 func_475(struct<3> Param0)
{
float fVar0;
float fVar1;
fVar0 = SYSTEM::VMAG(Param0);
if (fVar0 != 0f)
{
fVar1 = (1f / fVar0);
Param0 = { Param0 * Vector(fVar1, fVar1, fVar1) };
}
else
{
Param0.f_0 = 0f;
Param0.f_1 = 0f;
Param0.f_2 = 0f;
}
return Param0;
}
Vector3 func_476(bool bParam0)
{
switch (bParam0)
{
case 0:
return -21.7965f, -0.0328f, 70.0438f;
case 1:
return -26.5541f, 0.0092f, -86.4416f;
case 2:
return -11.2825f, 0.0213f, 148.5283f;
case 3:
return -39.935f, 0f, 12.8174f;
case 4:
return 0.9749f, 0f, -5.2236f;
case 5:
return -12.889f, 0f, 1.6227f;
case 6:
return -48.5605f, 0f, 160.4909f;
case 7:
return -37.0509f, 0.0324f, 24.0288f;
case 8:
return -17.4118f, 0f, 117.7175f;
case 9:
return -15.4633f, 0.0328f, -5.1142f;
case 10:
return -20.9567f, 0f, 170.5743f;
case 11:
return 1.9344f, 0f, -55.2084f;
case 12:
return -46.0342f, 0f, 37.5935f;
default:
}
return 0f, 0f, 0f;
}
void func_477(var uParam0, var uParam1, bool bParam2, bool bParam3)
{
struct<3> Var0;
struct<3> Var3;
float fVar6;
struct<3> Var7;
Var0 = { func_485(uParam1) };
Var3 = { func_484(uParam1) };
fVar6 = func_483(uParam1);
if (!CAM::DOES_CAM_EXIST(func_433(uParam0, 0)))
{
func_482(uParam0, 0, CAM::CREATE_CAMERA_WITH_PARAMS(26379945, Var0, Var3, 65f, false, 2), 1);
}
else
{
CAM::SET_CAM_COORD(func_433(uParam0, 0), Var0);
CAM::SET_CAM_ROT(func_433(uParam0, 0), Var3, 2);
}
CAM::SET_CAM_FOV(func_433(uParam0, 0), fVar6);
CAM::SET_CAM_ACTIVE(func_433(uParam0, 0), true);
if (bParam3)
{
Var7 = { Var0 };
Var7.f_2 = (Var7.f_2 + 8f);
CAM::SET_CAM_PARAMS(func_433(uParam0, 0), Var7, Var3, fVar6, func_481(bParam2), 1, 1, 2);
}
Var0 = { func_480(uParam1) };
Var3 = { func_479(uParam1) };
fVar6 = func_478(uParam1);
if (!CAM::DOES_CAM_EXIST(func_433(uParam0, 1)))
{
func_482(uParam0, 1, CAM::CREATE_CAMERA_WITH_PARAMS(26379945, Var0, Var3, 65f, false, 2), 1);
}
else
{
CAM::SET_CAM_COORD(func_433(uParam0, 1), Var0);
CAM::SET_CAM_ROT(func_433(uParam0, 1), Var3, 2);
}
CAM::SET_CAM_FOV(func_433(uParam0, 1), fVar6);
if (!CAM::IS_SCREEN_FADED_OUT())
{
CAM::SET_CAM_ACTIVE_WITH_INTERP(func_433(uParam0, 1), func_433(uParam0, 0), func_481(bParam2), 1, 1);
}
CAM::RENDER_SCRIPT_CAMS(true, false, 3000, true, false, 0);
CAM::SHAKE_SCRIPT_GLOBAL("HAND_SHAKE", 0.2f);
HUD::DISPLAY_RADAR(false);
HUD::DISPLAY_HUD(false);
}
float func_478(var uParam0)
{
return uParam0->f_82;
}
Vector3 func_479(var uParam0)
{
return uParam0->f_58;
}
Vector3 func_480(var uParam0)
{
return uParam0->f_55;
}
int func_481(int iParam0)
{
switch (iParam0)
{
case 5:
case 6:
case 12:
return 6000;
break;
}
return 10000;
}
void func_482(var uParam0, int iParam1, int iParam2, int iParam3)
{
if (iParam1 >= 2)
{
return;
}
if (iParam3 && !CAM::DOES_CAM_EXIST(iParam2))
{
return;
}
(*uParam0)[iParam1] = iParam2;
}
var func_483(var uParam0)
{
return uParam0->f_81;
}
Vector3 func_484(var uParam0)
{
return uParam0->f_52;
}
Vector3 func_485(var uParam0)
{
return uParam0->f_49;
}
void func_486(int* iParam0)
{
if (!func_462(iParam0))
{
func_371(iParam0);
}
}
void func_487(struct<3> Param0, float fParam3, bool bParam4)
{
int iVar0;
iVar0 = 0;
while (iVar0 < 68)
{
if (func_307(&(Global_76676.f_555[0 /*21*/]), iVar0))
{
if (MISC::GET_DISTANCE_BETWEEN_COORDS(Param0, Global_76676.f_555[0 /*21*/], bParam4) <= fParam3)
{
func_488(iVar0);
}
}
iVar0++;
}
}
void func_488(int iParam0)
{
bool bVar0;
if (iParam0 == -1)
{
return;
}
if (func_307(&(Global_76676.f_555[0 /*21*/]), iParam0))
{
if (ENTITY::DOES_ENTITY_EXIST(Global_76676.f_139[iParam0]))
{
bVar0 = true;
if (!PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
if (VEHICLE::IS_VEHICLE_DRIVEABLE(Global_76676.f_139[iParam0], false))
{
if (PED::IS_PED_IN_VEHICLE(PLAYER::PLAYER_PED_ID(), Global_76676.f_139[iParam0], false))
{
bVar0 = false;
}
}
}
if (bVar0)
{
ENTITY::SET_ENTITY_AS_MISSION_ENTITY(Global_76676.f_139[iParam0], true, true);
VEHICLE::DELETE_VEHICLE(&(Global_76676.f_139[iParam0]));
}
}
Global_76676[iParam0] = 1;
if (BitTest(Global_76676.f_555[0 /*21*/].f_9, 13))
{
if (((((iParam0 == 24 && func_313(iParam0, 0)) && Global_77585.f_66 == 0) && Global_112922.f_32749.f_1958[Global_76676.f_555[0 /*21*/].f_14] != 0) && Global_112922.f_32749.f_1958[Global_76676.f_555[0 /*21*/].f_14] > 3) && (!func_489(0, Global_76676.f_555[0 /*21*/].f_12) || !func_489(1, Global_76676.f_555[0 /*21*/].f_12)))
{
func_314(&(Global_112922.f_32749.f_69[Global_76676.f_555[0 /*21*/].f_14 /*78*/]), &Global_77585);
Global_77663 = Global_112922.f_32749.f_5591;
}
func_311(iParam0, 0);
}
}
}
int func_489(int iParam0, int iParam1)
{
int iVar0;
switch (iParam1)
{
case 0:
iVar0 = 0;
break;
case 1:
iVar0 = 1;
break;
case 2:
iVar0 = 2;
break;
}
if (iParam0 < 0 || iParam0 >= func_490(&(Global_112922.f_32749.f_5038[iVar0 /*157*/])))
{
return 0;
}
return func_291(Global_112922.f_32749.f_5038[iVar0 /*157*/][iParam0 /*78*/].f_66, 0);
}
int func_490(var uParam0)
{
return *uParam0;
}
void func_491(char* sParam0, int iParam1)
{
int iVar0;
int iVar1;
if (Global_111562 && iParam1)
{
if (func_337(sParam0) && !HUD::IS_HELP_MESSAGE_FADING_OUT())
{
HUD::CLEAR_HELP(false);
}
}
iVar0 = 0;
while (iVar0 < Global_112922.f_20410.f_145)
{
if (MISC::ARE_STRINGS_EQUAL(sParam0, &(Global_112922.f_20410[iVar0 /*16*/])))
{
iVar1 = iVar0;
while (iVar1 <= (Global_112922.f_20410.f_145 - 2))
{
func_494(iVar1, iVar1 + 1);
iVar1++;
}
func_493((Global_112922.f_20410.f_145 - 1));
Global_112922.f_20410.f_145 = (Global_112922.f_20410.f_145 - 1);
func_492();
return;
}
iVar0++;
}
}
void func_492()
{
int iVar0;
iVar0 = 0;
while (iVar0 < 3)
{
Global_112922.f_20410.f_146[iVar0] = 0;
iVar0++;
}
iVar0 = 0;
while (iVar0 < Global_112922.f_20410.f_145)
{
if (BitTest(Global_112922.f_20410[iVar0 /*16*/].f_11, 0))
{
if (Global_112922.f_20410[iVar0 /*16*/].f_12 > Global_112922.f_20410.f_146[0])
{
Global_112922.f_20410.f_146[0] = Global_112922.f_20410[iVar0 /*16*/].f_12;
}
}
if (BitTest(Global_112922.f_20410[iVar0 /*16*/].f_11, 1))
{
if (Global_112922.f_20410[iVar0 /*16*/].f_12 > Global_112922.f_20410.f_146[1])
{
Global_112922.f_20410.f_146[1] = Global_112922.f_20410[iVar0 /*16*/].f_12;
}
}
if (BitTest(Global_112922.f_20410[iVar0 /*16*/].f_11, 2))
{
if (Global_112922.f_20410[iVar0 /*16*/].f_12 > Global_112922.f_20410.f_146[2])
{
Global_112922.f_20410.f_146[2] = Global_112922.f_20410[iVar0 /*16*/].f_12;
}
}
iVar0++;
}
}
void func_493(int iParam0)
{
StringCopy(&(Global_112922.f_20410[iParam0 /*16*/]), "", 16);
StringCopy(&(Global_112922.f_20410[iParam0 /*16*/].f_4), "", 16);
Global_112922.f_20410[iParam0 /*16*/].f_8 = 0;
Global_112922.f_20410[iParam0 /*16*/].f_9 = 0;
Global_112922.f_20410[iParam0 /*16*/].f_11 = 0;
Global_112922.f_20410[iParam0 /*16*/].f_10 = -1;
Global_112922.f_20410[iParam0 /*16*/].f_12 = 0;
Global_112922.f_20410[iParam0 /*16*/].f_13 = 0;
Global_112922.f_20410[iParam0 /*16*/].f_14 = 0;
Global_112922.f_20410[iParam0 /*16*/].f_15 = 0;
}
void func_494(int iParam0, int iParam1)
{
Global_112922.f_20410[iParam0 /*16*/] = { Global_112922.f_20410[iParam1 /*16*/] };
Global_112922.f_20410[iParam0 /*16*/].f_4 = { Global_112922.f_20410[iParam1 /*16*/].f_4 };
Global_112922.f_20410[iParam0 /*16*/].f_8 = Global_112922.f_20410[iParam1 /*16*/].f_8;
Global_112922.f_20410[iParam0 /*16*/].f_10 = Global_112922.f_20410[iParam1 /*16*/].f_10;
Global_112922.f_20410[iParam0 /*16*/].f_9 = Global_112922.f_20410[iParam1 /*16*/].f_9;
Global_112922.f_20410[iParam0 /*16*/].f_11 = Global_112922.f_20410[iParam1 /*16*/].f_11;
Global_112922.f_20410[iParam0 /*16*/].f_12 = Global_112922.f_20410[iParam1 /*16*/].f_12;
Global_112922.f_20410[iParam0 /*16*/].f_13 = Global_112922.f_20410[iParam1 /*16*/].f_13;
Global_112922.f_20410[iParam0 /*16*/].f_14 = Global_112922.f_20410[iParam1 /*16*/].f_14;
Global_112922.f_20410[iParam0 /*16*/].f_15 = Global_112922.f_20410[iParam1 /*16*/].f_15;
}
void func_495(bool bParam0)
{
if (bParam0)
{
MISC::SET_FADE_IN_AFTER_DEATH_ARREST(false);
MISC::PAUSE_DEATH_ARREST_RESTART(true);
MISC::SET_FADE_OUT_AFTER_DEATH(false);
func_17(1);
Global_95238 = 1;
}
else
{
MISC::SET_FADE_IN_AFTER_DEATH_ARREST(true);
MISC::PAUSE_DEATH_ARREST_RESTART(false);
MISC::SET_FADE_OUT_AFTER_DEATH(true);
func_17(0);
Global_95238 = 0;
}
}
void func_496()
{
func_497(&uLocal_144, 0);
}
void func_497(var uParam0, int iParam1)
{
if (uParam0->f_4 != 0)
{
func_153(&(uParam0->f_4), &(uParam0->f_5), &(uParam0->f_44));
}
if ((((*uParam0)[0] != 0 || (*uParam0)[1] != 0) || (*uParam0)[2] != 0) || iParam1 == 1)
{
func_501(uParam0);
func_500(uParam0);
func_126(&Global_2101867);
}
if (Global_2097536.f_2708 != 0 || Global_2097536.f_3184)
{
func_498();
}
if (AUDIO::IS_AUDIO_SCENE_ACTIVE("LEADERBOARD_SCENE"))
{
AUDIO::STOP_AUDIO_SCENE("LEADERBOARD_SCENE");
}
if (NETWORK::NETWORK_IS_SIGNED_ONLINE())
{
func_94(&(Global_2103068.f_49));
}
Global_2810701.f_4032 = 0;
}
void func_498()
{
int iVar0;
int iVar1;
struct<75> Var2;
Var2.f_60 = 6;
Var2.f_67 = 6;
iVar0 = 0;
while (iVar0 < 3)
{
iVar1 = 0;
while (iVar1 < 12)
{
Global_2097536[iVar0 /*901*/][iVar1 /*75*/] = { Var2 };
iVar1++;
}
Global_2097536.f_2704[iVar0] = 0;
iVar0++;
}
Global_2097536.f_2708 = 0;
Global_2097536.f_2709 = 0;
iVar0 = 0;
iVar0 = 0;
while (iVar0 < 6)
{
Global_2097536.f_2710[iVar0] = 0;
StringCopy(&(Global_2097536.f_2717[iVar0 /*6*/]), "", 24);
Global_2097536.f_2754[iVar0] = 0;
Global_2097536.f_2761[iVar0] = 0;
iVar0++;
}
Global_2097536.f_2768 = 0;
Global_2097536.f_2769 = 0;
Global_2097536.f_2770 = 0;
iVar0 = 0;
iVar0 = 0;
while (iVar0 < 3)
{
Global_2097536.f_2771[iVar0] = 0;
Global_2097536.f_2775[iVar0] = 0;
iVar0++;
}
Global_2097536.f_2779 = 0;
func_499(&(Global_2097536.f_2780));
func_94(&(Global_2097536.f_2823));
Global_2097536.f_2825 = -1;
Global_2097536.f_2826 = 0;
func_94(&(Global_2097536.f_2827));
Global_2097536.f_2829 = 0;
func_94(&(Global_2097536.f_2830));
Global_2097536.f_2832 = 0;
Global_2097536.f_2780.f_28 = 0;
Global_2097536.f_2780.f_27 = 0;
Global_2097536.f_3184 = 0;
}
void func_499(var uParam0)
{
int iVar0;
*uParam0 = 0;
StringCopy(&(uParam0->f_1), "", 32);
StringCopy(&(uParam0->f_9), "", 64);
uParam0->f_25 = 1;
uParam0->f_26 = 0;
uParam0->f_27 = 0;
uParam0->f_28 = 0;
iVar0 = 0;
while (iVar0 < 6)
{
uParam0->f_29[iVar0] = 0;
uParam0->f_36[iVar0] = 0;
iVar0++;
}
}
void func_500(var uParam0)
{
int iVar0;
struct<13> Var1;
uParam0->f_246 = 0;
uParam0->f_246.f_1 = -1;
uParam0->f_246.f_2 = 0;
func_94(&(uParam0->f_246.f_3));
uParam0->f_246.f_5 = 0;
iVar0 = 0;
while (iVar0 < 12)
{
uParam0->f_246.f_6[iVar0 /*15*/] = -1;
uParam0->f_246.f_6[iVar0 /*15*/].f_1 = 0;
uParam0->f_246.f_6[iVar0 /*15*/].f_2 = { Var1 };
iVar0++;
}
iVar0 = 0;
while (iVar0 < 3)
{
uParam0->f_246.f_187[iVar0] = 0;
iVar0++;
}
}
void func_501(var uParam0)
{
int iVar0;
struct<35> Var1;
(*uParam0)[0] = 0;
(*uParam0)[1] = 0;
(*uParam0)[2] = 0;
uParam0->f_4 = 0;
uParam0->f_6 = 0;
uParam0->f_7 = { Var1 };
uParam0->f_42 = 0;
uParam0->f_43 = 0;
uParam0->f_44 = 0;
uParam0->f_44.f_1 = 0;
uParam0->f_44.f_2 = 0;
uParam0->f_44.f_3 = 0;
iVar0 = 0;
while (iVar0 < 4)
{
StringCopy(&(uParam0->f_44.f_3.f_1[iVar0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_44.f_3.f_1[iVar0 /*16*/].f_8), "", 32);
iVar0++;
}
uParam0->f_113[0 /*66*/] = 0;
iVar0 = 0;
while (iVar0 < 4)
{
StringCopy(&(uParam0->f_113[0 /*66*/].f_1[iVar0 /*16*/]), "", 32);
StringCopy(&(uParam0->f_113[0 /*66*/].f_1[iVar0 /*16*/].f_8), "", 32);
iVar0++;
}
}
void func_502()
{
Global_22691.f_5 = 1;
}
void func_503(var uParam0, int iParam1, bool bParam2, bool bParam3)
{
int iVar0;
if (iParam1 < 11)
{
if (!func_263(uParam0, 19))
{
if ((iParam1 == 4 && !bParam3) && (CAM::IS_SCREEN_FADED_IN() || CAM::IS_SCREEN_FADING_IN()))
{
if (func_505(func_506(bParam2, 19), "", &(uParam0->f_607), 19))
{
}
}
}
if (!func_263(uParam0, 20))
{
if (iParam1 > 4)
{
if (func_505(func_506(bParam2, 20), func_506(bParam2, 19), &(uParam0->f_607), 20))
{
}
}
}
else if (!func_263(uParam0, 21))
{
if (iParam1 == 9)
{
if (func_505(func_506(bParam2, 21), func_506(bParam2, 20), &(uParam0->f_607), 21))
{
}
}
else if (iParam1 == 8)
{
if (func_505(func_506(bParam2, 21), func_506(bParam2, 20), &(uParam0->f_607), 21))
{
}
}
}
else if (!func_263(uParam0, 22))
{
if (iParam1 == 9)
{
iVar0 = PED::GET_PED_PARACHUTE_STATE(PLAYER::PLAYER_PED_ID());
if (iVar0 == 1 || iVar0 == 2)
{
if (func_505(func_506(bParam2, 22), func_506(bParam2, 21), &(uParam0->f_607), 22))
{
}
}
}
}
else if (iParam1 == 10 && !func_263(uParam0, 23))
{
func_504(func_506(bParam2, 22), &(uParam0->f_607), 23);
}
else if (!func_263(uParam0, 23) && !PLAYER::IS_PLAYER_PLAYING(PLAYER::PLAYER_ID()))
{
AUDIO::STOP_AUDIO_SCENES();
}
}
}
void func_504(char* sParam0, int* iParam1, bool bParam2)
{
if (!BitTest(*iParam1, bParam2))
{
AUDIO::STOP_AUDIO_SCENE(sParam0);
MISC::SET_BIT(iParam1, bParam2);
}
}
int func_505(char* sParam0, char* sParam1, int* iParam2, bool bParam3)
{
if (!MISC::IS_STRING_NULL_OR_EMPTY(sParam1))
{
if (AUDIO::IS_AUDIO_SCENE_ACTIVE(sParam1))
{
AUDIO::STOP_AUDIO_SCENE(sParam1);
}
}
if (!BitTest(*iParam2, bParam3))
{
if (AUDIO::START_AUDIO_SCENE(sParam0))
{
MISC::SET_BIT(iParam2, bParam3);
return 1;
}
}
else
{
return 1;
}
return 0;
}
char* func_506(int iParam0, int iParam1)
{
char* sVar0;
sVar0 = "";
switch (iParam1)
{
case 19:
return "BASEJUMPS_OVERVIEW_CUTSCENE";
case 20:
if (func_465(func_466(iParam0)))
{
sVar0 = "BASEJUMPS_PREP_FOR_JUMP_HELI";
}
else if (PED::IS_PED_IN_ANY_VEHICLE(PLAYER::PLAYER_PED_ID(), false) && func_365(ENTITY::GET_ENTITY_MODEL(PED::GET_VEHICLE_PED_IS_IN(PLAYER::PLAYER_PED_ID(), false))))
{
sVar0 = "BASEJUMPS_PREP_FOR_JUMP_MOTO";
}
else
{
sVar0 = "BASEJUMPS_PREP_FOR_JUMP_ON_FOOT";
}
return sVar0;
case 21:
return "BASEJUMPS_SKYDIVE";
case 22:
return "BASEJUMPS_OPEN_PARACHUTE";
default:
}
return "";
}
void func_507(var uParam0, int iParam1)
{
if (iParam1 < 11)
{
if (!func_263(uParam0, 15))
{
if (iParam1 >= 4 && (CAM::IS_SCREEN_FADED_IN() || CAM::IS_SCREEN_FADING_IN()))
{
if (func_509(func_510(11), &(uParam0->f_607), 11))
{
func_508(func_510(15), &(uParam0->f_607), 15);
}
}
}
else if (!func_263(uParam0, 16))
{
if (iParam1 == 9)
{
if (func_509(func_510(12), &(uParam0->f_607), 12))
{
func_508(func_510(16), &(uParam0->f_607), 16);
}
}
else if (iParam1 == 8)
{
if (func_509(func_510(12), &(uParam0->f_607), 12))
{
func_508(func_510(16), &(uParam0->f_607), 16);
}
}
}
else if (iParam1 == 10 && !func_263(uParam0, 17))
{
if (func_509(func_510(13), &(uParam0->f_607), 13))
{
func_508(func_510(17), &(uParam0->f_607), 17);
}
}
}
}
int func_508(char* sParam0, int* iParam1, bool bParam2)
{
if (!BitTest(*iParam1, bParam2))
{
if (AUDIO::PREPARE_MUSIC_EVENT(sParam0))
{
if (AUDIO::TRIGGER_MUSIC_EVENT(sParam0))
{
MISC::SET_BIT(iParam1, bParam2);
return 1;
}
}
}
else
{
return 1;
}
return 0;
}
int func_509(char* sParam0, int* iParam1, bool bParam2)
{
if (!BitTest(*iParam1, bParam2))
{
if (AUDIO::PREPARE_MUSIC_EVENT(sParam0))
{
MISC::SET_BIT(iParam1, bParam2);
return 1;
}
}
else
{
return 1;
}
return 0;
}
char* func_510(int iParam0)
{
switch (iParam0)
{
case 15:
case 11:
return "OJBJ_START";
case 16:
case 12:
return "OJBJ_JUMPED";
case 17:
case 13:
return "OJBJ_LANDED";
case 18:
case 14:
return "OJBJ_STOP";
default:
}
return "";
}
void func_511(var uParam0)
{
struct<2> Var0;
var uVar3;
var uVar4;
int iVar5;
int iVar6;
PAD::_0x7F4724035FDCA1DD(0);
PAD::_0x7F4724035FDCA1DD(2);
func_518(&uVar3, &uVar4, &iVar5, &iVar6, PLAYER::IS_PLAYER_CONTROL_ON(PLAYER::PLAYER_ID()), PAD::_IS_USING_KEYBOARD(2));
Var0.f_0 = (SYSTEM::TO_FLOAT(iVar5) / 128f);
Var0.f_1 = (SYSTEM::TO_FLOAT(iVar6) / -128f);
func_515(uParam0, Var0.f_0, Var0.f_1);
func_514(uParam0);
if (PAD::IS_CONTROL_PRESSED(2, 224))
{
func_513(uParam0, 0, 1);
}
if (PAD::IS_CONTROL_PRESSED(0, 22) || PAD::IS_DISABLED_CONTROL_PRESSED(0, 22))
{
func_513(uParam0, 1, 1);
}
if (func_512())
{
func_513(uParam0, 2, 1);
}
if (PAD::IS_DISABLED_CONTROL_PRESSED(2, 22))
{
func_513(uParam0, 3, 1);
}
if (PAD::IS_CONTROL_PRESSED(2, 216))
{
func_513(uParam0, 4, 1);
}
if (PAD::IS_CONTROL_PRESSED(2, 215) || PAD::IS_DISABLED_CONTROL_PRESSED(2, 200))
{
func_513(uParam0, 5, 1);
}
if (PAD::IS_CONTROL_PRESSED(2, 201))
{
func_513(uParam0, 6, 1);
}
if (PAD::IS_CONTROL_PRESSED(2, 202))
{
func_513(uParam0, 7, 1);
}
if (PAD::IS_CONTROL_PRESSED(2, 211))
{
func_513(uParam0, 8, 1);
}
}
int func_512()
{
if (HUD::IS_PAUSE_MENU_ACTIVE())
{
return 0;
}
if (PAD::IS_CONTROL_PRESSED(0, 18) || PAD::IS_CONTROL_PRESSED(2, 18))
{
return 1;
}
return 0;
}
void func_513(var uParam0, bool bParam1, bool bParam2)
{
if (bParam2)
{
MISC::SET_BIT(&(uParam0->f_2), bParam1);
}
else
{
MISC::CLEAR_BIT(&(uParam0->f_2), bParam1);
}
}
void func_514(var uParam0)
{
uParam0->f_3 = uParam0->f_2;
uParam0->f_2 = 0;
}
void func_515(var uParam0, var uParam1, var uParam2)
{
func_517(uParam0, uParam1);
func_516(uParam0, uParam2);
}
void func_516(var uParam0, var uParam1)
{
uParam0->f_1 = uParam1;
}
void func_517(var uParam0, var uParam1)
{
*uParam0 = uParam1;
}
void func_518(var uParam0, var uParam1, var uParam2, var uParam3, bool bParam4, bool bParam5)
{
float fVar0;
float fVar1;
float fVar2;
float fVar3;
if (bParam5 == 0)
{
if (bParam4)
{
fVar0 = PAD::GET_CONTROL_NORMAL(0, 218);
fVar1 = PAD::GET_CONTROL_NORMAL(0, 219);
fVar2 = PAD::GET_CONTROL_NORMAL(0, 220);
fVar3 = PAD::GET_CONTROL_NORMAL(0, 221);
}
else
{
fVar0 = PAD::GET_DISABLED_CONTROL_NORMAL(0, 218);
fVar1 = PAD::GET_DISABLED_CONTROL_NORMAL(0, 219);
fVar2 = PAD::GET_DISABLED_CONTROL_NORMAL(0, 220);
fVar3 = PAD::GET_DISABLED_CONTROL_NORMAL(0, 221);
}
}
else if (bParam4)
{
fVar0 = PAD::GET_CONTROL_UNBOUND_NORMAL(0, 218);
fVar1 = PAD::GET_CONTROL_UNBOUND_NORMAL(0, 219);
fVar2 = PAD::GET_CONTROL_UNBOUND_NORMAL(0, 220);
fVar3 = PAD::GET_CONTROL_UNBOUND_NORMAL(0, 221);
}
else
{
fVar0 = PAD::GET_DISABLED_CONTROL_UNBOUND_NORMAL(0, 218);
fVar1 = PAD::GET_DISABLED_CONTROL_UNBOUND_NORMAL(0, 219);
fVar2 = PAD::GET_DISABLED_CONTROL_UNBOUND_NORMAL(0, 220);
fVar3 = PAD::GET_DISABLED_CONTROL_UNBOUND_NORMAL(0, 221);
}
*uParam0 = SYSTEM::ROUND((128f * fVar0));
*uParam1 = SYSTEM::ROUND((128f * fVar1));
*uParam2 = SYSTEM::ROUND((128f * fVar2));
*uParam3 = SYSTEM::ROUND((128f * fVar3));
}
void func_519()
{
PAD::DISABLE_CONTROL_ACTION(0, 81, true);
PAD::DISABLE_CONTROL_ACTION(0, 82, true);
PAD::DISABLE_CONTROL_ACTION(0, 85, true);
PAD::DISABLE_CONTROL_ACTION(0, 37, true);
PAD::DISABLE_CONTROL_ACTION(0, 12, true);
PAD::DISABLE_CONTROL_ACTION(0, 13, true);
PAD::DISABLE_CONTROL_ACTION(0, 14, true);
PAD::DISABLE_CONTROL_ACTION(0, 15, true);
PAD::DISABLE_CONTROL_ACTION(0, 16, true);
PAD::DISABLE_CONTROL_ACTION(0, 17, true);
PAD::DISABLE_CONTROL_ACTION(0, 25, true);
PAD::DISABLE_CONTROL_ACTION(0, 24, true);
PAD::DISABLE_CONTROL_ACTION(0, 50, true);
PAD::DISABLE_CONTROL_ACTION(0, 53, true);
PAD::DISABLE_CONTROL_ACTION(0, 54, true);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(19);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(2);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(14);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(16);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(6);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(7);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(8);
HUD::HIDE_HUD_COMPONENT_THIS_FRAME(9);
}
var func_520()
{
var uVar0;
func_530(&uVar0, CLOCK::GET_CLOCK_SECONDS());
func_529(&uVar0, CLOCK::GET_CLOCK_MINUTES());
func_528(&uVar0, CLOCK::GET_CLOCK_HOURS());
func_523(&uVar0, CLOCK::GET_CLOCK_DAY_OF_MONTH());
func_522(&uVar0, CLOCK::GET_CLOCK_MONTH());
func_521(&uVar0, CLOCK::GET_CLOCK_YEAR());
return uVar0;
}
void func_521(var uParam0, int iParam1)
{
if (iParam1 <= 0)
{
return;
}
if (iParam1 > 2043 || iParam1 < 1979)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 2080374784);
if (iParam1 < 2011)
{
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT((2011 - iParam1), 26));
*uParam0 |= -2147483648;
}
else
{
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT((iParam1 - 2011), 26));
*uParam0 = (*uParam0 - *uParam0 & -2147483648);
}
}
void func_522(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 > 11)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 15);
*uParam0 = (*uParam0 || iParam1);
}
void func_523(var uParam0, int iParam1)
{
int iVar0;
int iVar1;
iVar0 = func_527(*uParam0);
iVar1 = func_525(*uParam0);
if (iParam1 < 1 || iParam1 > func_524(iVar0, iVar1))
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 496);
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT(iParam1, 4));
}
int func_524(int iParam0, int iParam1)
{
if (iParam1 < 0)
{
iParam1 = 0;
}
switch (iParam0)
{
case 0:
case 2:
case 4:
case 6:
case 7:
case 9:
case 11:
return 31;
break;
case 3:
case 5:
case 8:
case 10:
return 30;
break;
case 1:
if ((iParam1 % 4) == 0)
{
if ((iParam1 % 100) != 0)
{
return 29;
}
else if ((iParam1 % 400) == 0)
{
return 29;
}
}
return 28;
break;
}
return 30;
}
var func_525(int iParam0)
{
return (SYSTEM::SHIFT_RIGHT(iParam0, 26) & 31 * func_526(BitTest(iParam0, 31), -1, 1)) + 2011;
}
int func_526(bool bParam0, int iParam1, int iParam2)
{
if (bParam0)
{
return iParam1;
}
return iParam2;
}
int func_527(var uParam0)
{
return uParam0 & 15;
}
void func_528(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 > 24)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 15872);
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT(iParam1, 9));
}
void func_529(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 >= 60)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 1032192);
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT(iParam1, 14));
}
void func_530(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 >= 60)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 66060288);
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT(iParam1, 20));
}
int func_531(var uParam0)
{
return uParam0->f_2;
}
void func_532(var uParam0, bool bParam1)
{
int iVar0;
iVar0 = func_36(PLAYER::PLAYER_PED_ID());
switch (bParam1)
{
case 0:
func_557(uParam0, 125);
func_556(uParam0, joaat("squalo"));
func_555(uParam0, 41.0737f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, -1039.712f, -1731.145f, 1f);
func_546(uParam0, 317.8872f);
func_545(uParam0, 0f, -2f, 0f);
func_544(uParam0, "BJ_01P");
func_542(uParam0, func_543(0));
func_541(uParam0, func_476(0));
func_540(uParam0, 53.4142f);
func_539(uParam0, -1151.402f, -1864.369f, 214.9385f);
func_538(uParam0, -55.1298f, -0.0328f, -19.7985f);
func_537(uParam0, 39.6124f);
func_536(uParam0, 0);
func_535(uParam0, 0);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 1:
func_557(uParam0, 126);
func_556(uParam0, 0);
func_555(uParam0, 10.5f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, 978.232f, -397.611f, 416.607f);
func_547(uParam0, 1, 873.389f, -183.851f, 302.972f);
func_547(uParam0, 2, 1082.347f, -86.822f, 174.287f);
func_547(uParam0, 3, 1151.098f, 124.6955f, 81.4805f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
func_544(uParam0, "BJ_02P");
func_542(uParam0, func_543(1));
func_541(uParam0, func_476(1));
func_540(uParam0, 52.5984f);
func_539(uParam0, 886.5799f, -442.7917f, 535.8002f);
func_538(uParam0, -41.778f, 0.0092f, -13.8287f);
func_537(uParam0, 41.3305f);
func_536(uParam0, 0);
func_535(uParam0, 0);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 2:
func_557(uParam0, 127);
func_556(uParam0, 0);
func_555(uParam0, 289.2623f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, 2028.516f, 1759.102f, 424.7939f);
func_547(uParam0, 1, 2230.78f, 1600.25f, 318.384f);
func_547(uParam0, 2, 2410.55f, 1739.71f, 253.494f);
func_547(uParam0, 3, 2273.787f, 1885.168f, 152.702f);
func_547(uParam0, 4, 2111.912f, 1887.456f, 92.5308f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
func_544(uParam0, "BJ_03P");
func_542(uParam0, func_543(2));
func_541(uParam0, func_476(2));
func_540(uParam0, 31.9702f);
func_539(uParam0, 2038.807f, 1971.563f, 591.7618f);
func_538(uParam0, -79.6953f, 0.0213f, 159.6313f);
func_537(uParam0, 50.8804f);
func_536(uParam0, 0);
func_535(uParam0, 0);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 3:
func_557(uParam0, 128);
func_556(uParam0, 0);
func_555(uParam0, 60.1427f);
func_554(uParam0, joaat("frogger"));
func_553(uParam0, 402.6013f, 5736.451f, 696.3928f);
func_552(uParam0, 119.8889f);
func_551(uParam0, 5f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, 320.69f, 5808.49f, 550.56f);
func_547(uParam0, 1, 220.59f, 5943.149f, 415.514f);
func_547(uParam0, 2, 30.63f, 6117.63f, 227.9f);
func_547(uParam0, 3, -80.95f, 6440.43f, 100.48f);
func_547(uParam0, 4, -273.773f, 6633.584f, 6.533f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
if (iVar0 == 0)
{
func_544(uParam0, "BJ_04M");
}
else if (iVar0 == 1)
{
func_544(uParam0, "BJ_04F");
}
else
{
func_544(uParam0, "BJ_04T");
}
func_542(uParam0, func_543(3));
func_541(uParam0, func_476(3));
func_540(uParam0, 44.3626f);
func_539(uParam0, 409.9299f, 5701.477f, 696.7185f);
func_538(uParam0, -5.0705f, 0f, 20.8267f);
func_537(uParam0, 43.8549f);
func_536(uParam0, 0);
func_535(uParam0, 1);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 4:
func_557(uParam0, 129);
func_556(uParam0, 0);
func_555(uParam0, 1.8891f);
func_554(uParam0, joaat("skylift"));
func_553(uParam0, -75.3f, -823.9f, 329.2f);
func_552(uParam0, 150f);
func_551(uParam0, 4f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, -77.2067f, -444.208f, 37f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
if (iVar0 == 0)
{
func_544(uParam0, "BJ_05M");
}
else if (iVar0 == 1)
{
func_544(uParam0, "BJ_05F");
}
else
{
func_544(uParam0, "BJ_05T");
}
func_542(uParam0, func_543(4));
func_541(uParam0, func_476(4));
func_540(uParam0, 26.7726f);
func_539(uParam0, -111.8981f, -862.3896f, 334.5773f);
func_538(uParam0, -5.4775f, 0.0397f, -29.0222f);
func_537(uParam0, 30.0131f);
func_536(uParam0, 0);
func_535(uParam0, 0);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 5:
func_557(uParam0, 130);
func_556(uParam0, joaat("hauler"));
func_555(uParam0, 358.9586f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, -96.9738f, -662.5833f, 34.7843f);
func_546(uParam0, -18.6f);
func_545(uParam0, 0f, -6f, 0f);
if (iVar0 == 0)
{
func_544(uParam0, "BJ_06M");
}
else if (iVar0 == 1)
{
func_544(uParam0, "BJ_06F");
}
else
{
func_544(uParam0, "BJ_06T");
}
func_542(uParam0, func_543(5));
func_541(uParam0, func_476(5));
func_540(uParam0, 55.7667f);
func_539(uParam0, -117.2447f, -977.6218f, 297.0984f);
func_538(uParam0, -7.6574f, 0f, 0.8528f);
func_537(uParam0, 60f);
func_536(uParam0, 0);
func_535(uParam0, 1);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 6:
func_557(uParam0, 131);
func_556(uParam0, 0);
func_555(uParam0, 164.6178f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, joaat("blazer"));
func_549(uParam0, -1310.948f, 4330.126f, 7.2444f);
func_548(uParam0, 87.84f);
func_547(uParam0, 0, -1246.49f, 4482.091f, 100.349f);
func_547(uParam0, 1, -1309.67f, 4400.428f, 50.542f);
func_547(uParam0, 2, -1304.67f, 4348.428f, 5.75f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
if (iVar0 == 0)
{
func_544(uParam0, "BJ_07M");
}
else if (iVar0 == 1)
{
func_544(uParam0, "BJ_07F");
}
else
{
func_544(uParam0, "BJ_07T");
}
func_542(uParam0, func_543(6));
func_541(uParam0, func_476(6));
func_540(uParam0, 47.1789f);
func_539(uParam0, -1242.731f, 4536.298f, 186.6862f);
func_538(uParam0, -13.6409f, 0f, 172.0553f);
func_537(uParam0, 47.1789f);
func_536(uParam0, 0);
func_535(uParam0, 1);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 7:
func_557(uParam0, 132);
func_556(uParam0, joaat("freight"));
func_555(uParam0, 112.6f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, -487.5452f, 4252.192f, 87.712f);
func_546(uParam0, 10.8894f);
func_545(uParam0, 0f, -20f, 4f);
func_544(uParam0, "BJ_08P");
func_542(uParam0, func_543(7));
func_541(uParam0, func_476(7));
func_540(uParam0, 24.3623f);
func_539(uParam0, -337.5233f, 4110.16f, 315.6679f);
func_538(uParam0, -29.1422f, 0.0324f, 47.5813f);
func_537(uParam0, 37.0424f);
func_536(uParam0, 0);
func_535(uParam0, 0);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 8:
func_557(uParam0, 133);
func_556(uParam0, 0);
func_555(uParam0, 104.207f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, -1154.443f, 204.1726f, 64.4915f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
if (iVar0 == 0)
{
func_544(uParam0, "BJ_09M");
}
else if (iVar0 == 1)
{
func_544(uParam0, "BJ_09F");
}
else
{
func_544(uParam0, "BJ_09T");
}
func_542(uParam0, func_543(8));
func_541(uParam0, func_476(8));
func_540(uParam0, 50f);
func_539(uParam0, -805.2963f, 332.5761f, 234.6604f);
func_538(uParam0, -19.7458f, 0f, 116.6405f);
func_537(uParam0, 55.2882f);
func_536(uParam0, 0);
func_535(uParam0, 1);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 9:
func_557(uParam0, 134);
func_556(uParam0, 0);
func_555(uParam0, 329.4791f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, joaat("blazer"));
func_549(uParam0, -818.3042f, 4405.675f, 20.1095f);
func_548(uParam0, -89.36f);
func_547(uParam0, 0, -1200f, 3616f, 964f);
func_547(uParam0, 1, -1240f, 3307f, 854f);
func_547(uParam0, 2, -1552f, 3456f, 655f);
func_547(uParam0, 3, -1616f, 3808f, 505f);
func_547(uParam0, 4, -1157.684f, 4128.348f, 288.607f);
func_547(uParam0, 5, -1063.995f, 4246.137f, 163.291f);
func_547(uParam0, 6, -938.541f, 4360.14f, 82.372f);
func_547(uParam0, 7, -828.1418f, 4413.562f, 20.062f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
func_544(uParam0, "BJ_10P");
func_542(uParam0, func_543(9));
func_541(uParam0, func_476(9));
func_540(uParam0, 31.7648f);
func_539(uParam0, -1286.976f, 3660.137f, 1082.208f);
func_538(uParam0, -47.0453f, 0.0328f, -13.4198f);
func_537(uParam0, 39.6786f);
func_536(uParam0, 0);
func_535(uParam0, 0);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 10:
func_557(uParam0, 135);
func_556(uParam0, 0);
func_555(uParam0, 0f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, 0);
func_549(uParam0, 0f, 0f, 0f);
func_548(uParam0, 0f);
func_547(uParam0, 0, 1239.342f, 4008.389f, 1135.372f);
func_547(uParam0, 1, 1374.479f, 4156.592f, 1019.694f);
func_547(uParam0, 2, 1391.31f, 4362.621f, 909.212f);
func_547(uParam0, 3, 1240.832f, 4598.044f, 758.002f);
func_547(uParam0, 4, 1382.169f, 4377.629f, 600.013f);
func_547(uParam0, 5, 1624.116f, 4207.519f, 471.225f);
func_547(uParam0, 6, 1910.345f, 4175.518f, 362.862f);
func_547(uParam0, 7, 2236.975f, 4282.967f, 218.116f);
func_547(uParam0, 8, 2330.282f, 4534.43f, 90f);
func_547(uParam0, 9, 2473.344f, 4715.347f, 33.524f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
func_544(uParam0, "BJ_11P");
func_542(uParam0, func_543(10));
func_541(uParam0, func_476(10));
func_540(uParam0, 27.2187f);
func_539(uParam0, 1012.673f, 3960.436f, 1367.701f);
func_538(uParam0, -54.7868f, 0f, -90.128f);
func_537(uParam0, 35.5634f);
func_536(uParam0, 0);
func_535(uParam0, 0);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 11:
func_557(uParam0, 136);
func_556(uParam0, 0);
func_555(uParam0, 24.92f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, joaat("sanchez"));
func_549(uParam0, 1280.933f, -50.6157f, 61.8195f);
func_548(uParam0, 130.39f);
func_547(uParam0, 0, 1829.46f, -260.665f, 1141.852f);
func_547(uParam0, 1, 1816.46f, -10.665f, 1033.084f);
func_547(uParam0, 2, 1688.46f, 218.335f, 924.307f);
func_547(uParam0, 3, 1503.46f, 382.335f, 815.529f);
func_547(uParam0, 4, 1554.46f, 598.335f, 706.751f);
func_547(uParam0, 5, 1813.46f, 724.335f, 597.973f);
func_547(uParam0, 6, 1975.46f, 519.335f, 486.196f);
func_547(uParam0, 7, 1946.46f, 125.335f, 364.417f);
func_547(uParam0, 8, 1663.46f, -15.665f, 241.64f);
func_547(uParam0, 9, 1396.64f, -62.665f, 118f);
func_547(uParam0, 10, 1278.5f, -41.05f, 61.7f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
func_544(uParam0, "BJ_12P");
func_542(uParam0, func_543(11));
func_541(uParam0, func_476(11));
func_540(uParam0, 18.9374f);
func_539(uParam0, 1628.156f, -431.2605f, 1332.761f);
func_538(uParam0, -54.5827f, 0f, -2.0463f);
func_537(uParam0, 56.4495f);
func_536(uParam0, 0);
func_535(uParam0, 0);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
case 12:
func_557(uParam0, 137);
func_556(uParam0, 0);
func_555(uParam0, 359.2885f);
func_554(uParam0, 0);
func_553(uParam0, 0f, 0f, 0f);
func_552(uParam0, 0f);
func_551(uParam0, 0f);
func_550(uParam0, joaat("sanchez"));
func_549(uParam0, -885.2659f, 4433.592f, 20.381f);
func_548(uParam0, 104.35f);
func_547(uParam0, 0, -771.9196f, 4400.453f, 60.5786f);
func_547(uParam0, 1, -892.6581f, 4427.487f, 19.8561f);
func_546(uParam0, 0f);
func_545(uParam0, 0f, 0f, 0f);
if (iVar0 == 0)
{
func_544(uParam0, "BJ_13M");
}
else if (iVar0 == 1)
{
func_544(uParam0, "BJ_13F");
}
else
{
func_544(uParam0, "BJ_13T");
}
func_542(uParam0, func_543(12));
func_541(uParam0, func_476(12));
func_540(uParam0, 48.3921f);
func_539(uParam0, -765.6544f, 4332.836f, 149.0282f);
func_538(uParam0, -18.0357f, 0f, 6.0212f);
func_537(uParam0, 48.3921f);
func_536(uParam0, 0);
func_535(uParam0, 1);
func_534(uParam0, 0f, 0f, 0f);
func_533(uParam0, 0f, 0f, 0f);
break;
}
}
void func_533(var uParam0, struct<3> Param1)
{
uParam0->f_67 = { Param1 };
}
void func_534(var uParam0, struct<3> Param1)
{
uParam0->f_64 = { Param1 };
}
void func_535(var uParam0, int iParam1)
{
uParam0->f_84 = iParam1;
}
void func_536(var uParam0, int iParam1)
{
uParam0->f_83 = iParam1;
}
void func_537(var uParam0, float fParam1)
{
uParam0->f_82 = fParam1;
}
void func_538(var uParam0, struct<3> Param1)
{
uParam0->f_58 = { Param1 };
}
void func_539(var uParam0, struct<3> Param1)
{
uParam0->f_55 = { Param1 };
}
void func_540(var uParam0, float fParam1)
{
uParam0->f_81 = fParam1;
}
void func_541(var uParam0, struct<3> Param1)
{
uParam0->f_52 = { Param1 };
}
void func_542(var uParam0, struct<3> Param1)
{
uParam0->f_49 = { Param1 };
}
Vector3 func_543(int iParam0)
{
switch (iParam0)
{
case 0:
return -1143.586f, -1859.747f, 208.3878f;
case 1:
return 877.5864f, -436.3322f, 536.9036f;
case 2:
return 2041.231f, 1978.98f, 585.9358f;
case 3:
return 405.2326f, 5705.887f, 697.2318f;
case 4:
return -103.8901f, -870.8046f, 298.7574f;
case 5:
return -118.2569f, -975.1133f, 297.3781f;
case 6:
return -1237.465f, 4526.661f, 181.7929f;
case 7:
return -357.7932f, 4107.914f, 314.8059f;
case 8:
return -809.6324f, 331.3331f, 233.2818f;
case 9:
return -1286.926f, 3660.203f, 1076.051f;
case 10:
return 1022.178f, 3975.738f, 1362.533f;
case 11:
return 1608.553f, -434.5186f, 1321.916f;
case 12:
return -756.3533f, 4341.521f, 143.8134f;
default:
}
return 0f, 0f, 0f;
}
void func_544(var uParam0, char* sParam1)
{
uParam0->f_4 = sParam1;
}
void func_545(var uParam0, struct<3> Param1)
{
uParam0->f_6 = { Param1 };
}
void func_546(var uParam0, float fParam1)
{
uParam0->f_77 = fParam1;
}
void func_547(var uParam0, int iParam1, struct<3> Param2)
{
if (iParam1 < 0 || iParam1 >= 12)
{
return;
}
uParam0->f_12[iParam1 /*3*/] = { Param2 };
}
void func_548(var uParam0, float fParam1)
{
uParam0->f_79 = fParam1;
}
void func_549(var uParam0, struct<3> Param1)
{
uParam0->f_9 = { Param1 };
}
void func_550(var uParam0, int iParam1)
{
uParam0->f_3 = iParam1;
}
void func_551(var uParam0, float fParam1)
{
uParam0->f_80 = fParam1;
}
void func_552(var uParam0, float fParam1)
{
uParam0->f_78 = fParam1;
}
void func_553(var uParam0, struct<3> Param1)
{
uParam0->f_70 = { Param1 };
}
void func_554(var uParam0, int iParam1)
{
uParam0->f_2 = iParam1;
}
void func_555(var uParam0, float fParam1)
{
uParam0->f_76 = fParam1;
}
void func_556(var uParam0, int iParam1)
{
uParam0->f_1 = iParam1;
}
void func_557(var uParam0, int iParam1)
{
*uParam0 = iParam1;
}
void func_558(bool bParam0, bool bParam1)
{
if (bParam1)
{
MISC::SET_BIT(&Global_31759, iParam0);
}
else
{
MISC::CLEAR_BIT(&Global_31759, bParam0);
}
}
void func_559(int iParam0)
{
func_382();
Global_78113 = iParam0;
Global_78112 = 0;
Global_78115 = 3;
}
void func_560(var uParam0, var uParam1, int* iParam2, int* iParam3, int* iParam4, var uParam5, int iParam6, var uParam7, int* iParam8, var uParam9, var uParam10, var uParam11, int iParam12, int iParam13, int iParam14, int iParam15, var uParam16, bool bParam17)
{
int iVar0;
int iVar1;
int iVar2;
func_376();
func_375();
func_496();
func_566(uParam1);
func_558(23, 0);
func_565(*uParam1);
VEHICLE::REMOVE_VEHICLE_COMBAT_AVOIDANCE_AREA(*uParam16);
AUDIO::CANCEL_MUSIC_EVENT("OJBJ_START");
AUDIO::CANCEL_MUSIC_EVENT("OJBJ_JUMPED");
AUDIO::CANCEL_MUSIC_EVENT("OJBJ_LANDED");
AUDIO::TRIGGER_MUSIC_EVENT("OJBJ_STOP");
AUDIO::STOP_AUDIO_SCENE("BASEJUMPS_OPEN_PARACHUTE");
AUDIO::STOP_AUDIO_SCENE("BASEJUMPS_PREP_FOR_JUMP_ON_FOOT");
AUDIO::STOP_AUDIO_SCENE("BASEJUMPS_PREP_FOR_JUMP_MOTO");
AUDIO::STOP_AUDIO_SCENE("BASEJUMPS_SKYDIVE");
AUDIO::STOP_AUDIO_SCENE("BASEJUMPS_OPEN_PARACHUTE");
AUDIO::STOP_AUDIO_SCENES();
uParam11 = uParam11;
Global_95237 = 0;
Global_95238 = 0;
Global_95239 = 0;
func_20(0, 1);
func_18(0, 1);
func_17(0);
MISC::SET_FADE_OUT_AFTER_DEATH(true);
MISC::PAUSE_DEATH_ARREST_RESTART(false);
MISC::IGNORE_NEXT_RESTART(false);
while (CAM::IS_SCREEN_FADING_OUT())
{
SYSTEM::WAIT(0);
}
if (CAM::IS_SCRIPT_GLOBAL_SHAKING())
{
CAM::STOP_SCRIPT_GLOBAL_SHAKING(true);
}
if (HUD::DOES_BLIP_EXIST(iParam13))
{
HUD::REMOVE_BLIP(&iParam13);
}
if (HUD::DOES_BLIP_EXIST(iParam14))
{
HUD::REMOVE_BLIP(&iParam14);
}
func_382();
func_26(0);
PLAYER::SET_PLAYER_CAN_LEAVE_PARACHUTE_SMOKE_TRAIL(PLAYER::PLAYER_ID(), false);
func_564(1, 1);
if (func_431(func_457(uParam0)))
{
}
else
{
VEHICLE::_0x0A436B8643716D14();
}
PED::REMOVE_SCENARIO_BLOCKING_AREAS();
func_562(uParam7);
func_283();
HUD::_SET_MINIMAP_ALTITUDE_INDICATOR_LEVEL(0f, false, 21);
GRAPHICS::CASCADE_SHADOWS_SET_AIRCRAFT_MODE(false);
func_220(0, 0);
PLAYER::SET_PLAYER_CONTROL(PLAYER::PLAYER_ID(), true, 0);
if (iParam15 == 5)
{
PED::SET_PED_CONFIG_FLAG(PLAYER::PLAYER_PED_ID(), 146, false);
}
if (ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID()) && !PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID()))
{
PED::SET_PED_RESET_FLAG(PLAYER::PLAYER_PED_ID(), 177, false);
PED::SET_PED_CONFIG_FLAG(PLAYER::PLAYER_PED_ID(), 36, false);
PLAYER::SET_PLAYER_INVINCIBLE(PLAYER::PLAYER_ID(), false);
PED::SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(PLAYER::PLAYER_PED_ID(), 0);
if (!bParam17)
{
WEAPON::REMOVE_WEAPON_FROM_PED(PLAYER::PLAYER_PED_ID(), joaat("gadget_parachute"));
}
PED::SET_PED_LOD_MULTIPLIER(PLAYER::PLAYER_PED_ID(), 1f);
PED::SET_PED_HELMET(PLAYER::PLAYER_PED_ID(), true);
}
iVar1 = 0;
while (iVar1 < *uParam10)
{
if (ENTITY::DOES_ENTITY_EXIST((*uParam10)[iVar1]) && !ENTITY::IS_ENTITY_DEAD((*uParam10)[iVar1], false))
{
TASK::CLEAR_PED_TASKS((*uParam10)[iVar1]);
(*uParam10)[iVar1] = 0;
}
iVar1++;
}
if ((ENTITY::DOES_ENTITY_EXIST(*iParam6) && *iParam6 != PLAYER::GET_PLAYERS_LAST_VEHICLE()) && !ENTITY::IS_ENTITY_DEAD(*iParam6, false))
{
VEHICLE::SET_PLAYERS_LAST_VEHICLE(*iParam6);
func_286(*iParam6, func_325(iParam15), func_324(iParam15), 24, 0);
}
if (!PED::IS_PED_INJURED(*iParam8))
{
if (!ENTITY::IS_ENTITY_ON_SCREEN(*iParam8))
{
PED::DELETE_PED(iParam8);
}
else
{
ENTITY::SET_PED_AS_NO_LONGER_NEEDED(iParam8);
}
}
if (!PED::IS_PED_INJURED(*uParam9))
{
TASK::CLEAR_PED_TASKS(*uParam9);
PED::SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(*uParam9, true);
}
if (ENTITY::DOES_ENTITY_EXIST(*iParam2))
{
if (func_465(func_466(iParam15)))
{
if ((!ENTITY::IS_ENTITY_DEAD(*iParam2, false) && !PED::IS_PED_INJURED(PLAYER::PLAYER_PED_ID())) && PED::IS_PED_IN_VEHICLE(PLAYER::PLAYER_PED_ID(), *iParam2, false))
{
PED::_0xF9ACF4A08098EA25(PLAYER::PLAYER_PED_ID(), true);
}
if (!ENTITY::IS_ENTITY_ON_SCREEN(*iParam2))
{
VEHICLE::DELETE_VEHICLE(iParam2);
}
else
{
ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(iParam2);
}
}
else
{
ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(iParam2);
}
}
if (ENTITY::DOES_ENTITY_EXIST(*iParam3))
{
if (func_367(func_368(uParam0)))
{
VEHICLE::SET_MISSION_TRAIN_AS_NO_LONGER_NEEDED(iParam3, false);
VEHICLE::SET_RANDOM_TRAINS(true);
}
}
if (ENTITY::DOES_ENTITY_EXIST(*iParam4) && !ENTITY::IS_ENTITY_DEAD(*iParam4, false))
{
iVar0 = VEHICLE::GET_PED_IN_VEHICLE_SEAT(*iParam4, -1, false);
if (ENTITY::DOES_ENTITY_EXIST(iVar0))
{
PED::DELETE_PED(&iVar0);
}
VEHICLE::DELETE_VEHICLE(iParam4);
}
iVar2 = 0;
while (iVar2 < *uParam5)
{
if (ENTITY::DOES_ENTITY_EXIST((*uParam5)[iVar2]) && !ENTITY::IS_ENTITY_DEAD((*uParam5)[iVar2], false))
{
VEHICLE::SET_VEHICLE_LOD_MULTIPLIER((*uParam5)[iVar2], 1f);
ENTITY::SET_ENTITY_LOAD_COLLISION_FLAG((*uParam5)[iVar2], false, 1);
}
iVar2++;
}
*iParam12 = 1;
HUD::CLEAR_HELP(true);
CAM::RENDER_SCRIPT_CAMS(false, false, 3000, true, false, 0);
HUD::DISPLAY_RADAR(true);
HUD::DISPLAY_HUD(true);
AUDIO::SET_FRONTEND_RADIO_ACTIVE(true);
func_561();
SCRIPT::SET_NO_LOADING_SCREEN(false);
Global_112922.f_18967 = -1;
SCRIPT::TERMINATE_THIS_THREAD();
}
void func_561()
{
Global_22691.f_5 = 0;
}
void func_562(var uParam0)
{
func_563(uParam0, 0);
func_563(uParam0, 1);
func_563(uParam0, 2);
}
void func_563(var uParam0, int iParam1)
{
if ((uParam0[iParam1 /*10*/])->f_7 == 1)
{
(uParam0[iParam1 /*10*/])->f_7 = 0;
}
}
void func_564(bool bParam0, bool bParam1)
{
if (BitTest(Global_31670, bParam0))
{
if (!bParam1)
{
MISC::CLEAR_BIT(&Global_31670, bParam0);
StringCopy(&(Global_31671[bParam0 /*6*/]), "NULL", 24);
Global_31726[bParam0] = bParam1;
}
}
}
void func_565(var uParam0)
{
GRAPHICS::SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(&uParam0);
}
void func_566(var uParam0)
{
func_565(*uParam0);
}
| 24.349314
| 962
| 0.591124
|
[
"object",
"vector"
] |
7f21f017f76d77719116d46c029b7891c1590d8f
| 1,457
|
h
|
C
|
model/ezsignfolder_get_forms_data_v1_response_all_of.h
|
ezmaxinc/eZmax-SDK-c
|
725eab79d6311127a2d5bd731b978bce94142d69
|
[
"curl",
"MIT"
] | null | null | null |
model/ezsignfolder_get_forms_data_v1_response_all_of.h
|
ezmaxinc/eZmax-SDK-c
|
725eab79d6311127a2d5bd731b978bce94142d69
|
[
"curl",
"MIT"
] | null | null | null |
model/ezsignfolder_get_forms_data_v1_response_all_of.h
|
ezmaxinc/eZmax-SDK-c
|
725eab79d6311127a2d5bd731b978bce94142d69
|
[
"curl",
"MIT"
] | null | null | null |
/*
* ezsignfolder_get_forms_data_v1_response_all_of.h
*
*
*/
#ifndef _ezsignfolder_get_forms_data_v1_response_all_of_H_
#define _ezsignfolder_get_forms_data_v1_response_all_of_H_
#include <string.h>
#include "../external/cJSON.h"
#include "../include/list.h"
#include "../include/keyValuePair.h"
#include "../include/binary.h"
typedef struct ezsignfolder_get_forms_data_v1_response_all_of_t ezsignfolder_get_forms_data_v1_response_all_of_t;
#include "ezsignfolder_get_forms_data_v1_response_m_payload.h"
typedef struct ezsignfolder_get_forms_data_v1_response_all_of_t {
struct ezsignfolder_get_forms_data_v1_response_m_payload_t *m_payload; //model
} ezsignfolder_get_forms_data_v1_response_all_of_t;
ezsignfolder_get_forms_data_v1_response_all_of_t *ezsignfolder_get_forms_data_v1_response_all_of_create(
ezsignfolder_get_forms_data_v1_response_m_payload_t *m_payload
);
void ezsignfolder_get_forms_data_v1_response_all_of_free(ezsignfolder_get_forms_data_v1_response_all_of_t *ezsignfolder_get_forms_data_v1_response_all_of);
ezsignfolder_get_forms_data_v1_response_all_of_t *ezsignfolder_get_forms_data_v1_response_all_of_parseFromJSON(cJSON *ezsignfolder_get_forms_data_v1_response_all_ofJSON);
cJSON *ezsignfolder_get_forms_data_v1_response_all_of_convertToJSON(ezsignfolder_get_forms_data_v1_response_all_of_t *ezsignfolder_get_forms_data_v1_response_all_of);
#endif /* _ezsignfolder_get_forms_data_v1_response_all_of_H_ */
| 37.358974
| 170
| 0.888126
|
[
"model"
] |
b205608e4f8ecbe301db492327a021954493d281
| 3,533
|
h
|
C
|
ref-impl/src/impl/ImplAAFConstantValue.h
|
Phygon/aaf
|
faef720e031f501190481e1d1fc1870a7dc8f98b
|
[
"Linux-OpenIB"
] | null | null | null |
ref-impl/src/impl/ImplAAFConstantValue.h
|
Phygon/aaf
|
faef720e031f501190481e1d1fc1870a7dc8f98b
|
[
"Linux-OpenIB"
] | null | null | null |
ref-impl/src/impl/ImplAAFConstantValue.h
|
Phygon/aaf
|
faef720e031f501190481e1d1fc1870a7dc8f98b
|
[
"Linux-OpenIB"
] | null | null | null |
//@doc
//@class AAFConstantValue | Implementation class for AAFConstantValue
#ifndef __ImplAAFConstantValue_h__
#define __ImplAAFConstantValue_h__
//=---------------------------------------------------------------------=
//
// $Id$ $Name$
//
// The contents of this file are subject to the AAF SDK Public Source
// License Agreement Version 2.0 (the "License"); You may not use this
// file except in compliance with the License. The License is available
// in AAFSDKPSL.TXT, or you may obtain a copy of the License from the
// Advanced Media Workflow Association, Inc., or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and limitations
// under the License. Refer to Section 3.3 of the License for proper use
// of this Exhibit.
//
// WARNING: Please contact the Advanced Media Workflow Association,
// Inc., for more information about any additional licenses to
// intellectual property covering the AAF Standard that may be required
// to create and distribute AAF compliant products.
// (http://www.amwa.tv/policies).
//
// Copyright Notices:
// The Original Code of this file is Copyright 1998-2009, licensor of the
// Advanced Media Workflow Association. All rights reserved.
//
// The Initial Developer of the Original Code of this file and the
// licensor of the Advanced Media Workflow Association is
// Avid Technology.
// All rights reserved.
//
//=---------------------------------------------------------------------=
class ImplAAFDataDef;
class ImplAAFParameter;
#ifndef __ImplAAFParameter_h__
#include "ImplAAFParameter.h"
#endif
#include "OMVariableSizeProperty.h"
class ImplAAFTypeDef;
class ImplAAFConstantValue : public ImplAAFParameter
{
public:
//
// Constructor/destructor
//
//********
ImplAAFConstantValue ();
//****************
// Initialize()
//
virtual AAFRESULT STDMETHODCALLTYPE
Initialize
(// @parm [in] // Parameter definition for this object (this determines the type of the constant value)
ImplAAFParameterDef * pParameterDef,
// @parm [in] Size of preallocated buffer
aafUInt32 valueSize,
// @parm [in, size_is(valueSize)] buffer containing value
aafDataBuffer_t pValue);
protected:
virtual ~ImplAAFConstantValue ();
public:
/****/
//****************
// GetValue()
//
virtual AAFRESULT STDMETHODCALLTYPE
GetValue
(// @parm [in] Size of preallocated buffer
aafUInt32 valueSize,
// @parm [out, size_is(valueSize),length_is(*bytesRead)] Preallocated buffer to hold value
aafDataBuffer_t pValue,
// @parm [out] Number of actual bytes read
aafUInt32* bytesRead);
//****************
// GetValueBufLen()
//
virtual AAFRESULT STDMETHODCALLTYPE
GetValueBufLen
// @parm [out] Mob Name
(aafUInt32 * pLen);
/****/
//****************
// SetValue()
//
virtual AAFRESULT STDMETHODCALLTYPE
SetValue
(// @parm [in] Size of preallocated buffer
aafUInt32 valueSize,
// @parm [in, size_is(valueSize)] buffer containing value
aafDataBuffer_t pValue);
virtual AAFRESULT STDMETHODCALLTYPE
GetTypeDefinition (
ImplAAFTypeDef **ppTypeDef);
private:
OMVariableSizeProperty<aafUInt8> _value;
ImplAAFTypeDef * _cachedTypeDef;
};
#endif // ! __ImplAAFConstantValue_h__
| 26.765152
| 111
| 0.658364
|
[
"object"
] |
b20716700009f4c612b392955b4b7711defc3489
| 571,931
|
c
|
C
|
subversion/bindings/swig/python/svn_repos.c
|
tux-mind/platform_external_subversion
|
e3e715b637b0b7c6a6a02316f3be48f2c1d5181c
|
[
"Apache-2.0"
] | null | null | null |
subversion/bindings/swig/python/svn_repos.c
|
tux-mind/platform_external_subversion
|
e3e715b637b0b7c6a6a02316f3be48f2c1d5181c
|
[
"Apache-2.0"
] | null | null | null |
subversion/bindings/swig/python/svn_repos.c
|
tux-mind/platform_external_subversion
|
e3e715b637b0b7c6a6a02316f3be48f2c1d5181c
|
[
"Apache-2.0"
] | 1
|
2020-11-04T07:17:20.000Z
|
2020-11-04T07:17:20.000Z
|
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 2.0.4
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
* changes to this file unless you know what you are doing--modify the SWIG
* interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIG_PYTHON_CLASSIC
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Python.h has to appear first */
#include <Python.h>
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if (<obj is ok>) {
if (<need new object>) {
*ptr = <ptr to new allocated object>;
return SWIG_NEWOBJ;
} else {
*ptr = <ptr to old object>;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows to return the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
#define SWIG_ERROR (-1)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class<int>" == "Class<int >", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like <name1>|<name2>|...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
int equiv = 0;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (!equiv && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like <name1>|<name2>|...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCompare(const char *nb, const char *tb) {
int equiv = 0;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (!equiv && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
if (*ne) ++ne;
}
return equiv;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. We choose
to print the last name, as it is often (?) the most
specific. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
register size_t l = 0;
register size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
register size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
register int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
register size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
register const unsigned char *u = (unsigned char *) ptr;
register const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
register unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
register unsigned char *u = (unsigned char *) ptr;
register const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
register char d = *(c++);
register unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = ((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = ((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* Errors in SWIG */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
/* Warning: This function will allocate a new string in Python 3,
* so please call SWIG_Python_str_DelForPy3(x) to free the space.
*/
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03000000
char *cstr;
char *newstr;
Py_ssize_t len;
str = PyUnicode_AsUTF8String(str);
PyBytes_AsStringAndSize(str, &cstr, &len);
newstr = (char *) malloc(len+1);
memcpy(newstr, cstr, len+1);
Py_XDECREF(str);
return newstr;
#else
return PyString_AsString(str);
#endif
}
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#else
# define SWIG_Python_str_DelForPy3(x)
#endif
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
# define PyOS_snprintf _snprintf
# else
# define PyOS_snprintf snprintf
# endif
#endif
/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000
#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif
static PyObject *
PyString_FromFormat(const char *fmt, ...) {
va_list ap;
char buf[SWIG_PYBUFFER_SIZE * 2];
int res;
va_start(ap, fmt);
res = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
}
#endif
/* Add PyObject_Del for old Pythons */
#if PY_VERSION_HEX < 0x01060000
# define PyObject_Del(op) PyMem_DEL((op))
#endif
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* A crude PyExc_StopIteration exception for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# ifndef PyExc_StopIteration
# define PyExc_StopIteration PyExc_RuntimeError
# endif
# ifndef PyObject_GenericGetAttr
# define PyObject_GenericGetAttr 0
# endif
#endif
/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
# define Py_NotImplemented PyExc_RuntimeError
# endif
#endif
/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
# endif
#endif
/* PySequence_Size for old Pythons */
#if PY_VERSION_HEX < 0x02000000
# ifndef PySequence_Size
# define PySequence_Size PySequence_Length
# endif
#endif
/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
PyObject *PyBool_FromLong(long ok)
{
PyObject *result = ok ? Py_True : Py_False;
Py_INCREF(result);
return result;
}
#endif
/* Py_ssize_t for old Pythons */
/* This code is as recommended by: */
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intintargfunc ssizessizeargfunc;
typedef intobjargproc ssizeobjargproc;
typedef intintobjargproc ssizessizeobjargproc;
typedef getreadbufferproc readbufferproc;
typedef getwritebufferproc writebufferproc;
typedef getsegcountproc segcountproc;
typedef getcharbufferproc charbufferproc;
static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
{
long result = 0;
PyObject *i = PyNumber_Int(x);
if (i) {
result = PyInt_AsLong(i);
Py_DECREF(i);
}
return result;
}
#endif
#if PY_VERSION_HEX < 0x02040000
#define Py_VISIT(op) \
do { \
if (op) { \
int vret = visit((op), arg); \
if (vret) \
return vret; \
} \
} while (0)
#endif
#if PY_VERSION_HEX < 0x02030000
typedef struct {
PyTypeObject type;
PyNumberMethods as_number;
PyMappingMethods as_mapping;
PySequenceMethods as_sequence;
PyBufferProcs as_buffer;
PyObject *name, *slots;
} PyHeapTypeObject;
#endif
#if PY_VERSION_HEX < 0x02030000
typedef destructor freefunc;
#endif
#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
(PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
(PY_MAJOR_VERSION > 3))
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
#endif
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
if (value) {
char *tmp;
PyObject *old_str = PyObject_Str(value);
PyErr_Clear();
Py_XINCREF(type);
PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
SWIG_Python_str_DelForPy3(tmp);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
# define SWIG_PYTHON_USE_GIL
# endif
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# ifndef SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
/* -----------------------------------------------------------------------------
* Wrapper of PyInstanceMethod_New() used in Python 3
* It is exported to the generated module, used for -fastproxy
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX >= 0x03000000
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
{
return PyInstanceMethod_New(func);
}
#else
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
{
return NULL;
}
#endif
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, (char *) msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, (char *)name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, (char *)name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
PyList_SetItem(result, 0, o2);
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
#else
PyObject* o2;
PyObject* o3;
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyTuple_Check(result)) {
o2 = result;
result = PyTuple_New(1);
PyTuple_SET_ITEM(result, 0, o2);
}
o3 = PyTuple_New(1);
PyTuple_SET_ITEM(o3, 0, obj);
o2 = result;
result = PySequence_Concat(o2, o3);
Py_DECREF(o2);
Py_DECREF(o3);
}
return result;
#endif
}
/* Unpack the argument tuple */
SWIGINTERN int
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
register int i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
register Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
register int i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
/* A functor is a function object with one single object argument */
#if PY_VERSION_HEX >= 0x02020000
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
#else
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
#endif
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* How to access Py_None */
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# ifndef SWIG_PYTHON_NO_BUILD_NONE
# ifndef SWIG_PYTHON_BUILD_NONE
# define SWIG_PYTHON_BUILD_NONE
# endif
# endif
#endif
#ifdef SWIG_PYTHON_BUILD_NONE
# ifdef Py_None
# undef Py_None
# define Py_None SWIG_Py_None()
# endif
SWIGRUNTIMEINLINE PyObject *
_SWIG_Py_None(void)
{
PyObject *none = Py_BuildValue((char*)"");
Py_DECREF(none);
return none;
}
SWIGRUNTIME PyObject *
SWIG_Py_None(void)
{
static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
return none;
}
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
return data ? data->implicitconv : 0;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
data->newargs = obj;
Py_INCREF(obj);
} else {
#if (PY_VERSION_HEX < 0x02020000)
data->newraw = 0;
#else
data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
#endif
if (data->newraw) {
Py_INCREF(data->newraw);
data->newargs = PyTuple_New(1);
PyTuple_SetItem(data->newargs, 0, obj);
} else {
data->newargs = obj;
}
Py_INCREF(data->newargs);
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
int flags;
Py_INCREF(data->destroy);
flags = PyCFunction_GET_FLAGS(data->destroy);
#ifdef METH_O
data->delargs = !(flags & (METH_O));
#else
data->delargs = 0;
#endif
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data) {
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
Py_DECREF(args);
}
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
#ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject *v)
#else
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#endif
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, (void *)v);
if (v->next) {
# ifdef METH_NOARGS
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# else
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
# endif
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
}
return repr;
}
SWIGRUNTIME int
SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
char *str;
#ifdef METH_NOARGS
PyObject *repr = SwigPyObject_repr(v);
#else
PyObject *repr = SwigPyObject_repr(v, NULL);
#endif
if (repr) {
str = SWIG_Python_str_AsChar(repr);
fputs(str, fp);
SWIG_Python_str_DelForPy3(str);
Py_DECREF(repr);
return 0;
} else {
return 1;
}
}
SWIGRUNTIME PyObject *
SwigPyObject_str(SwigPyObject *v)
{
char result[SWIG_BUFFER_SIZE];
return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
SWIG_Python_str_FromChar(result) : 0;
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
res = SWIG_Python_CallFunctor(destroy, tmp);
Py_DECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
}
Py_XDECREF(next);
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
#ifndef METH_O
PyObject *tmp = 0;
if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
next = tmp;
#endif
if (!SwigPyObject_Check(next)) {
return NULL;
}
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
#ifdef METH_NOARGS
SwigPyObject_next(PyObject* v)
#else
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_disown(PyObject *v)
#else
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_acquire(PyObject *v)
#else
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
#if (PY_VERSION_HEX < 0x02020000)
if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#else
if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
#endif
{
return NULL;
}
else
{
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
#ifdef METH_NOARGS
if (PyObject_IsTrue(val)) {
SwigPyObject_acquire(v);
} else {
SwigPyObject_disown(v);
}
#else
if (PyObject_IsTrue(val)) {
SwigPyObject_acquire(v,args);
} else {
SwigPyObject_disown(v,args);
}
#endif
}
return obj;
}
}
#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
{(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
{(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
{(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
{(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
{(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
{(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
{0, 0, 0, 0}
};
#else
static PyMethodDef
swigobject_methods[] = {
{(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
{(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
{(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
{(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
{(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
{(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
{0, 0, 0, 0}
};
#endif
#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
/* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
(char *)"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
(printfunc)SwigPyObject_print, /* tp_print */
#if PY_VERSION_HEX < 0x02020000
(getattrfunc)SwigPyObject_getattr, /* tp_getattr */
#else
(getattrfunc)0, /* tp_getattr */
#endif
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyObject_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
0, /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
0, /* tp_version */
#endif
#ifdef COUNT_ALLOCS
0,0,0,0 /* tp_alloc -> tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
#if PY_VERSION_HEX < 0x02020000
swigpyobject_type.ob_type = &PyType_Type;
#else
if (PyType_Ready(&swigpyobject_type) < 0)
return NULL;
#endif
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME int
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
char result[SWIG_BUFFER_SIZE];
fputs("<Swig Packed ", fp);
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
fputs("at ", fp);
fputs(result, fp);
}
fputs(v->ty->name,fp);
fputs(">", fp);
return 0;
}
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
/* PyObject header changed in Python 3 */
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
(char *)"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
(printfunc)SwigPyPacked_print, /* tp_print */
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
0, /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
0, /* tp_version */
#endif
#ifdef COUNT_ALLOCS
0,0,0,0 /* tp_alloc -> tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
#if PY_VERSION_HEX < 0x02020000
swigpypacked_type.ob_type = &PyType_Type;
#else
if (PyType_Ready(&swigpypacked_type) < 0)
return NULL;
#endif
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
return SWIG_Python_str_FromChar("this");
}
static PyObject *swig_this = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (swig_this == NULL)
swig_this = _SWIG_This();
return swig_this;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None) {
if (ptr)
*ptr = 0;
return SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
res = SWIG_OK;
} else {
if (flags & SWIG_POINTER_IMPLICIT_CONV) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
if (ty) {
swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
} else {
*ptr = vptr;
}
return SWIG_OK;
}
}
/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
#if (PY_VERSION_HEX >= 0x02020000)
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
PyDict_SetItem(dict, SWIG_This(), swig_this);
}
}
#else
PyObject *key = SWIG_This();
PyObject_SetAttr(inst, key, swig_this);
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
PyObject_SetAttr(inst, SWIG_This(), swig_this);
Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
#else
PyObject *dict = PyDict_New();
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
#endif
}
return inst;
#else
#if (PY_VERSION_HEX >= 0x02010000)
PyObject *inst;
PyObject *dict = PyDict_New();
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
return (PyObject *) inst;
#else
PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
if (inst == NULL) {
return NULL;
}
inst->in_class = (PyClassObject *)data->newargs;
Py_INCREF(inst->in_class);
inst->in_dict = PyDict_New();
if (inst->in_dict == NULL) {
Py_DECREF(inst);
return NULL;
}
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
inst->in_weakreflist = NULL;
#endif
#ifdef Py_TPFLAGS_GC
PyObject_GC_Init(inst);
#endif
PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
return (PyObject *) inst;
#endif
#endif
}
SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
PyObject *dict;
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
PyDict_SetItem(dict, SWIG_This(), swig_this);
return;
}
#endif
dict = PyObject_GetAttrString(inst, (char*)"__dict__");
PyDict_SetItem(dict, SWIG_This(), swig_this);
Py_DECREF(dict);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
SwigPyObject_append((PyObject*) sthis, obj[1]);
} else {
SWIG_Python_SetSwigThis(obj[0], obj[1]);
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
if (inst) {
Py_DECREF(robj);
robj = inst;
}
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void) {
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
# ifdef SWIGPY_USE_CAPSULE
type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
# else
type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
# endif
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
}
return (swig_module_info *) type_pointer;
}
#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0. The following function
is copied out of Python/modsupport.c in python version 2.3.4 */
SWIGINTERN int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
PyObject *dict;
if (!PyModule_Check(m)) {
PyErr_SetString(PyExc_TypeError,
"PyModule_AddObject() needs module as first arg");
return SWIG_ERROR;
}
if (!o) {
PyErr_SetString(PyExc_TypeError,
"PyModule_AddObject() needs non-NULL value");
return SWIG_ERROR;
}
dict = PyModule_GetDict(m);
if (dict == NULL) {
/* Internal error -- modules must have a dict! */
PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
PyModule_GetName(m));
return SWIG_ERROR;
}
if (PyDict_SetItemString(dict, name, o))
return SWIG_ERROR;
Py_DECREF(o);
return SWIG_OK;
}
#endif
SWIGRUNTIME void
#ifdef SWIGPY_USE_CAPSULE
SWIG_Python_DestroyModule(PyObject *obj)
#else
SWIG_Python_DestroyModule(void *vptr)
#endif
{
#ifdef SWIGPY_USE_CAPSULE
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
#else
swig_module_info *swig_module = (swig_module_info *) vptr;
#endif
swig_type_info **types = swig_module->types;
size_t i;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
swig_this = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
#ifdef SWIGPY_USE_CAPSULE
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
} else {
Py_XDECREF(pointer);
}
#else
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
if (pointer && module) {
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
} else {
Py_XDECREF(pointer);
}
#endif
}
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
return cache;
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
#ifdef SWIGPY_USE_CAPSULE
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
#else
descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
#endif
} else {
swig_module_info *swig_module = SWIG_Python_GetModule();
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
#ifdef SWIGPY_USE_CAPSULE
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
#else
obj = PyCObject_FromVoidPtr(descriptor, NULL);
#endif
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
char *tmp;
PyObject *old_str = PyObject_Str(value);
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
} else {
PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
}
SWIG_Python_str_DelForPy3(tmp);
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : (char*)"";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
SWIG_Python_str_DelForPy3(cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
#if SWIG_POINTER_EXCEPTION
if (flags) {
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
SWIG_Python_ArgFail(argnum);
}
#endif
}
return result;
}
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res;
#ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
#else
if (!PyString_Check(name))
#endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) < 0)
goto done;
}
res = -1;
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
#define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_apr_array_header_t swig_types[0]
#define SWIGTYPE_p_apr_hash_t swig_types[1]
#define SWIGTYPE_p_apr_int32_t swig_types[2]
#define SWIGTYPE_p_apr_int64_t swig_types[3]
#define SWIGTYPE_p_apr_pool_t swig_types[4]
#define SWIGTYPE_p_char swig_types[5]
#define SWIGTYPE_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[6]
#define SWIGTYPE_p_f_p_p_svn_stream_t_p_void__p_svn_error_t swig_types[7]
#define SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[8]
#define SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[9]
#define SWIGTYPE_p_f_p_q_const__svn_commit_info_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[10]
#define SWIGTYPE_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[11]
#define SWIGTYPE_p_f_p_svn_location_segment_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[12]
#define SWIGTYPE_p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t swig_types[13]
#define SWIGTYPE_p_f_p_void__p_svn_error_t swig_types[14]
#define SWIGTYPE_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[15]
#define SWIGTYPE_p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t swig_types[16]
#define SWIGTYPE_p_f_p_void_p_q_const__char__p_svn_error_t swig_types[17]
#define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t swig_types[18]
#define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t swig_types[19]
#define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t swig_types[20]
#define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[21]
#define SWIGTYPE_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void swig_types[22]
#define SWIGTYPE_p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t swig_types[23]
#define SWIGTYPE_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[24]
#define SWIGTYPE_p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t swig_types[25]
#define SWIGTYPE_p_int swig_types[26]
#define SWIGTYPE_p_long swig_types[27]
#define SWIGTYPE_p_p_apr_array_header_t swig_types[28]
#define SWIGTYPE_p_p_apr_hash_t swig_types[29]
#define SWIGTYPE_p_p_char swig_types[30]
#define SWIGTYPE_p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[31]
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[32]
#define SWIGTYPE_p_p_f_p_void__p_svn_error_t swig_types[33]
#define SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[34]
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t swig_types[35]
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t swig_types[36]
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[37]
#define SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void swig_types[38]
#define SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[39]
#define SWIGTYPE_p_p_svn_authz_t swig_types[40]
#define SWIGTYPE_p_p_svn_delta_editor_t swig_types[41]
#define SWIGTYPE_p_p_svn_dirent_t swig_types[42]
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[43]
#define SWIGTYPE_p_p_svn_lock_t swig_types[44]
#define SWIGTYPE_p_p_svn_repos_parse_fns2_t swig_types[45]
#define SWIGTYPE_p_p_svn_repos_parse_fns_t swig_types[46]
#define SWIGTYPE_p_p_svn_repos_t swig_types[47]
#define SWIGTYPE_p_p_svn_stream_t swig_types[48]
#define SWIGTYPE_p_p_svn_string_t swig_types[49]
#define SWIGTYPE_p_p_void swig_types[50]
#define SWIGTYPE_p_svn_auth_baton_t swig_types[51]
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[52]
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[53]
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[54]
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[55]
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[56]
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[57]
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[58]
#define SWIGTYPE_p_svn_auth_provider_t swig_types[59]
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[60]
#define SWIGTYPE_p_svn_authz_t swig_types[61]
#define SWIGTYPE_p_svn_commit_info_t swig_types[62]
#define SWIGTYPE_p_svn_config_t swig_types[63]
#define SWIGTYPE_p_svn_delta_editor_t swig_types[64]
#define SWIGTYPE_p_svn_depth_t swig_types[65]
#define SWIGTYPE_p_svn_dirent_t swig_types[66]
#define SWIGTYPE_p_svn_errno_t swig_types[67]
#define SWIGTYPE_p_svn_error_t swig_types[68]
#define SWIGTYPE_p_svn_fs_access_t swig_types[69]
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[70]
#define SWIGTYPE_p_svn_fs_history_t swig_types[71]
#define SWIGTYPE_p_svn_fs_id_t swig_types[72]
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[73]
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[74]
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[75]
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[76]
#define SWIGTYPE_p_svn_fs_root_t swig_types[77]
#define SWIGTYPE_p_svn_fs_t swig_types[78]
#define SWIGTYPE_p_svn_fs_txn_t swig_types[79]
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[80]
#define SWIGTYPE_p_svn_io_dirent_t swig_types[81]
#define SWIGTYPE_p_svn_io_file_del_t swig_types[82]
#define SWIGTYPE_p_svn_location_segment_t swig_types[83]
#define SWIGTYPE_p_svn_lock_t swig_types[84]
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[85]
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[86]
#define SWIGTYPE_p_svn_log_entry_t swig_types[87]
#define SWIGTYPE_p_svn_merge_range_t swig_types[88]
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[89]
#define SWIGTYPE_p_svn_node_kind_t swig_types[90]
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[91]
#define SWIGTYPE_p_svn_opt_revision_t swig_types[92]
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[93]
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[94]
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[95]
#define SWIGTYPE_p_svn_prop_kind swig_types[96]
#define SWIGTYPE_p_svn_repos_authz_access_t swig_types[97]
#define SWIGTYPE_p_svn_repos_node_t swig_types[98]
#define SWIGTYPE_p_svn_repos_notify_action_t swig_types[99]
#define SWIGTYPE_p_svn_repos_notify_t swig_types[100]
#define SWIGTYPE_p_svn_repos_notify_warning_t swig_types[101]
#define SWIGTYPE_p_svn_repos_parse_fns2_t swig_types[102]
#define SWIGTYPE_p_svn_repos_parse_fns_t swig_types[103]
#define SWIGTYPE_p_svn_repos_revision_access_level_t swig_types[104]
#define SWIGTYPE_p_svn_repos_t swig_types[105]
#define SWIGTYPE_p_svn_stream_mark_t swig_types[106]
#define SWIGTYPE_p_svn_stream_t swig_types[107]
#define SWIGTYPE_p_svn_string_t swig_types[108]
#define SWIGTYPE_p_svn_stringbuf_t swig_types[109]
#define SWIGTYPE_p_svn_tristate_t swig_types[110]
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[111]
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[112]
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[113]
#define SWIGTYPE_p_svn_version_checklist_t swig_types[114]
#define SWIGTYPE_p_svn_version_t swig_types[115]
#define SWIGTYPE_p_unsigned_long swig_types[116]
#define SWIGTYPE_p_void swig_types[117]
static swig_type_info *swig_types[119];
static swig_module_info swig_module = {swig_types, 118, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#if (PY_VERSION_HEX <= 0x02000000)
# if !defined(SWIG_PYTHON_CLASSIC)
# error "This python version requires swig to be run with the '-classic' option"
# endif
#endif
/*-----------------------------------------------
@(target):= _repos.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__repos
#else
# define SWIG_init init_repos
#endif
#define SWIG_name "_repos"
#define SWIGVERSION 0x020004
#define SWIG_VERSION SWIGVERSION
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include "svn_time.h"
#include "svn_pools.h"
#include "swigutil_py.h"
static PyObject * _global_py_pool = NULL;
#define svn_argnum_obj0 1
#define svn_argnum_obj1 2
#define svn_argnum_obj2 3
#define svn_argnum_obj3 4
#define svn_argnum_obj4 5
#define svn_argnum_obj5 6
#define svn_argnum_obj6 7
#define svn_argnum_obj7 8
#define svn_argnum_obj8 9
#define svn_argnum_obj9 10
#define svn_argnum_obj10 11
#define svn_argnum_obj11 12
#define svn_argnum_obj12 13
#define svn_argnum_obj13 14
#define svn_argnum_obj14 15
#define svn_argnum_obj15 16
#define svn_argnum_obj16 17
#define svn_argnum_obj17 18
#define svn_argnum_obj18 19
#define svn_argnum_obj19 20
#define svn_argnum_obj20 21
#define svn_argnum_obj21 22
#define svn_argnum_obj22 23
#define svn_argnum_obj23 24
#define svn_argnum_obj24 25
#define svn_argnum_obj25 26
#define svn_argnum_obj26 27
#define svn_argnum_obj27 28
#define svn_argnum_obj28 29
#define svn_argnum_obj29 30
#define svn_argnum_obj30 31
#define svn_argnum_obj31 32
#define svn_argnum_obj32 33
#define svn_argnum_obj33 34
#define svn_argnum_obj34 35
#define svn_argnum_obj35 36
#define svn_argnum_obj36 37
#define svn_argnum_obj37 38
#define svn_argnum_obj38 39
#define svn_argnum_obj39 40
#include "svn_repos.h"
#define SWIG_From_long PyInt_FromLong
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
} else if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include <float.h>
#include <math.h>
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERNINLINE long
SWIG_As_long (PyObject* obj)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (!SWIG_IsOK(res)) {
/*
this is needed to make valgrind/purify happier.
*/
memset((void*)&v, 0, sizeof(long));
SWIG_Error(res, "");
}
return v;
}
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
if (PyUnicode_Check(obj))
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
#if PY_VERSION_HEX>=0x03000000
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
PyBytes_AsStringAndSize(obj, &cstr, &len);
if(alloc) *alloc = SWIG_NEWOBJ;
#else
PyString_AsStringAndSize(obj, &cstr, &len);
#endif
if (cptr) {
if (alloc) {
/*
In python the user should not be able to modify the inner
string representation. To warranty that, if you define
SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
buffer is always returned.
The default behavior is just to return the pointer value,
so, be careful.
*/
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
if (*alloc != SWIG_OLDOBJ)
#else
if (*alloc == SWIG_NEWOBJ)
#endif
{
*cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
*alloc = SWIG_NEWOBJ;
}
else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
#if PY_VERSION_HEX>=0x03000000
assert(0); /* Should never reach here in Python 3 */
#endif
*cptr = SWIG_Python_str_AsChar(obj);
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000
Py_XDECREF(obj);
#endif
return SWIG_OK;
} else {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
if (carray) {
if (size > INT_MAX) {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
return pchar_descriptor ?
SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromStringAndSize(carray, (int)(size));
#else
return PyString_FromStringAndSize(carray, (int)(size));
#endif
}
} else {
return SWIG_Py_Void();
}
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char *cptr)
{
return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}
SWIGINTERNINLINE PyObject *
SWIG_From_int (int value)
{
return SWIG_From_long (value);
}
SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{
char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
if (SWIG_IsOK(res)) {
if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
if (csize <= size) {
if (val) {
if (csize) memcpy(val, cptr, csize*sizeof(char));
if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
}
if (alloc == SWIG_NEWOBJ) {
free((char*)cptr);
res = SWIG_DelNewMask(res);
}
return res;
}
if (alloc == SWIG_NEWOBJ) free((char*)cptr);
}
return SWIG_TypeError;
}
#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{
int res = SWIG_AsCharArray(obj, val, 1);
if (!SWIG_IsOK(res)) {
long v;
res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
if (SWIG_IsOK(res)) {
if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
if (val) *val = (char)(v);
} else {
res = SWIG_OverflowError;
}
}
}
return res;
}
SWIGINTERNINLINE PyObject *
SWIG_From_char (char c)
{
return SWIG_FromCharPtrAndSize(&c,1);
}
static svn_error_t * svn_repos_parse_fns2_invoke_new_revision_record(
svn_repos_parse_fns2_t * _obj, void **revision_baton, apr_hash_t *headers, void *parse_baton, apr_pool_t *pool) {
return (_obj->new_revision_record)(revision_baton, headers, parse_baton, pool);
}
static svn_error_t * svn_repos_parse_fns2_invoke_uuid_record(
svn_repos_parse_fns2_t * _obj, const char *uuid, void *parse_baton, apr_pool_t *pool) {
return (_obj->uuid_record)(uuid, parse_baton, pool);
}
static svn_error_t * svn_repos_parse_fns2_invoke_new_node_record(
svn_repos_parse_fns2_t * _obj, void **node_baton, apr_hash_t *headers, void *revision_baton, apr_pool_t *pool) {
return (_obj->new_node_record)(node_baton, headers, revision_baton, pool);
}
static svn_error_t * svn_repos_parse_fns2_invoke_set_revision_property(
svn_repos_parse_fns2_t * _obj, void *revision_baton, const char *name, const svn_string_t *value) {
return (_obj->set_revision_property)(revision_baton, name, value);
}
static svn_error_t * svn_repos_parse_fns2_invoke_set_node_property(
svn_repos_parse_fns2_t * _obj, void *node_baton, const char *name, const svn_string_t *value) {
return (_obj->set_node_property)(node_baton, name, value);
}
static svn_error_t * svn_repos_parse_fns2_invoke_delete_node_property(
svn_repos_parse_fns2_t * _obj, void *node_baton, const char *name) {
return (_obj->delete_node_property)(node_baton, name);
}
static svn_error_t * svn_repos_parse_fns2_invoke_remove_node_props(
svn_repos_parse_fns2_t * _obj, void *node_baton) {
return (_obj->remove_node_props)(node_baton);
}
static svn_error_t * svn_repos_parse_fns2_invoke_set_fulltext(
svn_repos_parse_fns2_t * _obj, svn_stream_t **stream, void *node_baton) {
return (_obj->set_fulltext)(stream, node_baton);
}
static svn_error_t * svn_repos_parse_fns2_invoke_apply_textdelta(
svn_repos_parse_fns2_t * _obj, svn_txdelta_window_handler_t *handler, void **handler_baton, void *node_baton) {
return (_obj->apply_textdelta)(handler, handler_baton, node_baton);
}
static svn_error_t * svn_repos_parse_fns2_invoke_close_node(
svn_repos_parse_fns2_t * _obj, void *node_baton) {
return (_obj->close_node)(node_baton);
}
static svn_error_t * svn_repos_parse_fns2_invoke_close_revision(
svn_repos_parse_fns2_t * _obj, void *revision_baton) {
return (_obj->close_revision)(revision_baton);
}
static svn_error_t * svn_repos_invoke_authz_func(
svn_repos_authz_func_t _obj, svn_boolean_t *allowed, svn_fs_root_t *root, const char *path, void *baton, apr_pool_t *pool) {
return _obj(allowed, root, path, baton, pool);
}
static svn_error_t * svn_repos_invoke_authz_callback(
svn_repos_authz_callback_t _obj, svn_repos_authz_access_t required, svn_boolean_t *allowed, svn_fs_root_t *root, const char *path, void *baton, apr_pool_t *pool) {
return _obj(required, allowed, root, path, baton, pool);
}
static svn_error_t * svn_repos_invoke_file_rev_handler(
svn_repos_file_rev_handler_t _obj, void *baton, const char *path, svn_revnum_t rev, apr_hash_t *rev_props, svn_txdelta_window_handler_t *delta_handler, void **delta_baton, apr_array_header_t *prop_diffs, apr_pool_t *pool) {
return _obj(baton, path, rev, rev_props, delta_handler, delta_baton, prop_diffs, pool);
}
static void svn_repos_invoke_notify_func(
svn_repos_notify_func_t _obj, void *baton, const svn_repos_notify_t *notify, apr_pool_t *scratch_pool) {
_obj(baton, notify, scratch_pool);
}
static svn_error_t * svn_repos_invoke_history_func(
svn_repos_history_func_t _obj, void *baton, const char *path, svn_revnum_t revision, apr_pool_t *pool) {
return _obj(baton, path, revision, pool);
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_svn_repos_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_version_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":svn_repos_version")) SWIG_fail;
{
svn_swig_py_release_py_lock();
result = (svn_version_t *)svn_repos_version();
svn_swig_py_acquire_py_lock();
}
resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_version_t,
_global_py_pool, args);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_action_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
svn_repos_notify_action_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_action_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_repos_notify_action_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->action = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_action_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
svn_repos_notify_action_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_action_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_repos_notify_action_t) ((arg1)->action);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_revision_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
svn_revnum_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_revision_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->revision = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_revision_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
svn_revnum_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_revision_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_revnum_t) ((arg1)->revision);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_warning_str_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
char *arg2 = (char *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"Os:svn_repos_notify_t_warning_str_set",&obj0,&arg2)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
apr_size_t len = strlen(arg2) + 1;
char *copied;
if (arg1->warning_str) free((char *)arg1->warning_str);
copied = malloc(len);
memcpy(copied, arg2, len);
arg1->warning_str = copied;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_warning_str_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_warning_str_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (char *) ((arg1)->warning_str);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_warning_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
svn_repos_notify_warning_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_warning_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_repos_notify_warning_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->warning = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_warning_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
svn_repos_notify_warning_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_warning_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_repos_notify_warning_t) ((arg1)->warning);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_shard_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
apr_int64_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_shard_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
arg2 = (apr_int64_t) PyLong_AsLongLong(obj1);
if (arg1) (arg1)->shard = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_shard_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
apr_int64_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_shard_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = ((arg1)->shard);
resultobj = PyLong_FromLongLong((apr_int64_t)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_new_revision_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
svn_revnum_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_new_revision_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->new_revision = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_new_revision_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
svn_revnum_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_new_revision_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_revnum_t) ((arg1)->new_revision);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_old_revision_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
svn_revnum_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_old_revision_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->old_revision = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_old_revision_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
svn_revnum_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_old_revision_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_revnum_t) ((arg1)->old_revision);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_node_action_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
enum svn_node_action arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_notify_t_node_action_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (enum svn_node_action)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->node_action = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_node_action_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
enum svn_node_action result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_node_action_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (enum svn_node_action) ((arg1)->node_action);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_path_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
char *arg2 = (char *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"Os:svn_repos_notify_t_path_set",&obj0,&arg2)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
apr_size_t len = strlen(arg2) + 1;
char *copied;
if (arg1->path) free((char *)arg1->path);
copied = malloc(len);
memcpy(copied, arg2, len);
arg1->path = copied;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_t_path_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_t *arg1 = (svn_repos_notify_t *) 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_notify_t_path_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (char *) ((arg1)->path);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *svn_repos_notify_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_svn_repos_notify_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_svn_repos_notify_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_action_t arg1 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_repos_notify_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_notify_create",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_notify_action_t)SWIG_As_long (obj0);
if (SWIG_arg_fail(svn_argnum_obj0)) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_repos_notify_t *)svn_repos_notify_create(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_notify_t,
_global_py_pool, args);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_find_root_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"s|O:svn_repos_find_root_path",&arg1,&obj1)) SWIG_fail;
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_find_root_path((char const *)arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_open2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t **arg1 = (svn_repos_t **) 0 ;
char *arg2 = (char *) 0 ;
apr_hash_t *arg3 = (apr_hash_t *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_repos_t *temp1 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"sO|O:svn_repos_open2",&arg2,&obj1,&obj2)) SWIG_fail;
{
/* PYTHON-FIXME: Handle None -> NULL. */
arg3 = svn_swig_py_stringhash_from_dict(obj1, _global_pool);
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_open2(arg1,(char const *)arg2,arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t **arg1 = (svn_repos_t **) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_repos_t *temp1 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"s|O:svn_repos_open",&arg2,&obj1)) SWIG_fail;
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_open(arg1,(char const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t **arg1 = (svn_repos_t **) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
apr_hash_t *arg6 = (apr_hash_t *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_repos_t *temp1 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"szzOO|O:svn_repos_create",&arg2,&arg3,&arg4,&obj3,&obj4,&obj5)) SWIG_fail;
{
if (_global_pool == NULL)
{
if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
}
arg5 = svn_swig_py_struct_ptr_hash_from_dict(obj3,
SWIGTYPE_p_svn_config_t, _global_pool);
if (PyErr_Occurred())
SWIG_fail;
}
{
/* PYTHON-FIXME: Handle None -> NULL. */
arg6 = svn_swig_py_stringhash_from_dict(obj4, _global_pool);
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_create(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_upgrade2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
svn_boolean_t arg2 ;
svn_repos_notify_func_t arg3 = (svn_repos_notify_func_t) 0 ;
void *arg4 = (void *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"sOOO|O:svn_repos_upgrade2",&arg1,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg2 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
svn_repos_notify_func_t * tmp =
svn_swig_MustGetPtr(obj2, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj2);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg3 = *tmp;
}
{
if (obj3 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj3, (void **) &arg4, 0, 0) == -1) {
arg4 = (void *) obj3;
PyErr_Clear();
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_upgrade2((char const *)arg1,arg2,arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_upgrade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
svn_boolean_t arg2 ;
svn_error_t *(*arg3)(void *) = (svn_error_t *(*)(void *)) 0 ;
void *arg4 = (void *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"sOOO|O:svn_repos_upgrade",&arg1,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg2 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_upgrade" "', argument " "3"" of type '" "svn_error_t *(*)(void *)""'");
}
}
{
if (obj3 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj3, (void **) &arg4, 0, 0) == -1) {
arg4 = (void *) obj3;
PyErr_Clear();
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_upgrade((char const *)arg1,arg2,arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"s|O:svn_repos_delete",&arg1,&obj1)) SWIG_fail;
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_delete((char const *)arg1,arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_has_capability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_boolean_t *arg2 = (svn_boolean_t *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_boolean_t temp2 ;
int res2 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_has_capability",&obj0,&arg3,&obj2)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_has_capability(arg1,arg2,(char const *)arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
if (SWIG_IsTmpObj(res2)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
} else {
int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
PyObject * obj0 = 0 ;
svn_fs_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_fs",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_fs_t *)svn_repos_fs(arg1);
svn_swig_py_acquire_py_lock();
}
resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_t,
_global_py_pool, args);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_hotcopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
svn_boolean_t arg3 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"ssO|O:svn_repos_hotcopy",&arg1,&arg2,&obj2,&obj3)) SWIG_fail;
{
arg3 = (svn_boolean_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_hotcopy((char const *)arg1,(char const *)arg2,arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_pack2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_repos_notify_func_t arg2 = (svn_repos_notify_func_t) 0 ;
void *arg3 = (void *) 0 ;
svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
void *arg5 = (void *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_fs_pack2",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
svn_repos_notify_func_t * tmp =
svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj1);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg2 = *tmp;
}
{
if (obj2 == Py_None) {
arg3 = NULL;
} else if (SWIG_ConvertPtr(obj2, (void **) &arg3, 0, 0) == -1) {
arg3 = (void *) obj2;
PyErr_Clear();
}
}
{
arg4 = svn_swig_py_cancel_func;
arg5 = obj3; /* our function is the baton. */
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_pack2(arg1,arg2,arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_pack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_fs_pack_notify_t arg2 = (svn_fs_pack_notify_t) 0 ;
void *arg3 = (void *) 0 ;
svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
void *arg5 = (void *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_fs_pack",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
svn_fs_pack_notify_t * tmp =
svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj1);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg2 = *tmp;
}
{
if (obj2 == Py_None) {
arg3 = NULL;
} else if (SWIG_ConvertPtr(obj2, (void **) &arg3, 0, 0) == -1) {
arg3 = (void *) obj2;
PyErr_Clear();
}
}
{
arg4 = svn_swig_py_cancel_func;
arg5 = obj3; /* our function is the baton. */
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_pack(arg1,arg2,arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_recover4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
svn_boolean_t arg2 ;
svn_repos_notify_func_t arg3 = (svn_repos_notify_func_t) 0 ;
void *arg4 = (void *) 0 ;
svn_cancel_func_t arg5 = (svn_cancel_func_t) 0 ;
void *arg6 = (void *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"sOOOO|O:svn_repos_recover4",&arg1,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg2 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
svn_repos_notify_func_t * tmp =
svn_swig_MustGetPtr(obj2, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj2);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg3 = *tmp;
}
{
if (obj3 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj3, (void **) &arg4, 0, 0) == -1) {
arg4 = (void *) obj3;
PyErr_Clear();
}
}
{
arg5 = svn_swig_py_cancel_func;
arg6 = obj4; /* our function is the baton. */
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_recover4((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_recover3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
svn_boolean_t arg2 ;
svn_error_t *(*arg3)(void *) = (svn_error_t *(*)(void *)) 0 ;
void *arg4 = (void *) 0 ;
svn_cancel_func_t arg5 = (svn_cancel_func_t) 0 ;
void *arg6 = (void *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"sOOOO|O:svn_repos_recover3",&arg1,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg2 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_recover3" "', argument " "3"" of type '" "svn_error_t *(*)(void *)""'");
}
}
{
if (obj3 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj3, (void **) &arg4, 0, 0) == -1) {
arg4 = (void *) obj3;
PyErr_Clear();
}
}
{
arg5 = svn_swig_py_cancel_func;
arg6 = obj4; /* our function is the baton. */
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_recover3((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_recover2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
svn_boolean_t arg2 ;
svn_error_t *(*arg3)(void *) = (svn_error_t *(*)(void *)) 0 ;
void *arg4 = (void *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"sOOO|O:svn_repos_recover2",&arg1,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg2 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_recover2" "', argument " "3"" of type '" "svn_error_t *(*)(void *)""'");
}
}
{
if (obj3 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj3, (void **) &arg4, 0, 0) == -1) {
arg4 = (void *) obj3;
PyErr_Clear();
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_recover2((char const *)arg1,arg2,arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_recover(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"s|O:svn_repos_recover",&arg1,&obj1)) SWIG_fail;
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_recover((char const *)arg1,arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_db_logfiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
char *arg2 = (char *) 0 ;
svn_boolean_t arg3 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
apr_array_header_t *temp1 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"sO|O:svn_repos_db_logfiles",&arg2,&obj1,&obj2)) SWIG_fail;
{
arg3 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_db_logfiles(arg1,(char const *)arg2,arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_array_to_list(*arg1));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_path",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_path(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_db_env(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_db_env",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_db_env(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_conf_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_conf_dir",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_conf_dir(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_svnserve_conf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_svnserve_conf",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_svnserve_conf(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_lock_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_lock_dir",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_lock_dir(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_db_lockfile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_db_lockfile",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_db_lockfile(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_db_logs_lockfile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_db_logs_lockfile",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_db_logs_lockfile(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_hook_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_hook_dir",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_hook_dir(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_start_commit_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_start_commit_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_start_commit_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_pre_commit_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_pre_commit_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_pre_commit_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_post_commit_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_post_commit_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_post_commit_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_pre_revprop_change_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_pre_revprop_change_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_pre_revprop_change_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_post_revprop_change_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_post_revprop_change_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_post_revprop_change_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_pre_lock_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_pre_lock_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_pre_lock_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_post_lock_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_post_lock_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_post_lock_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_pre_unlock_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_pre_unlock_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_pre_unlock_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_post_unlock_hook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_post_unlock_hook",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (char *)svn_repos_post_unlock_hook(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_FromCharPtr((const char *)result);
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_begin_report2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void **arg1 = (void **) 0 ;
svn_revnum_t arg2 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
svn_boolean_t arg7 ;
svn_depth_t arg8 ;
svn_boolean_t arg9 ;
svn_boolean_t arg10 ;
svn_delta_editor_t *arg11 = (svn_delta_editor_t *) 0 ;
void *arg12 = (void *) 0 ;
svn_repos_authz_func_t arg13 = (svn_repos_authz_func_t) 0 ;
void *arg14 = (void *) 0 ;
apr_pool_t *arg15 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
void *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
PyObject * obj12 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg15 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OOsszOOOOOOO|O:svn_repos_begin_report2",&obj0,&obj1,&arg4,&arg5,&arg6,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
{
arg2 = (svn_revnum_t)SWIG_As_long (obj0);
if (SWIG_arg_fail(svn_argnum_obj0)) {
SWIG_fail;
}
}
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg8 = (svn_depth_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
arg9 = (svn_boolean_t)SWIG_As_long (obj7);
if (SWIG_arg_fail(svn_argnum_obj7)) {
SWIG_fail;
}
}
{
arg10 = (svn_boolean_t)SWIG_As_long (obj8);
if (SWIG_arg_fail(svn_argnum_obj8)) {
SWIG_fail;
}
}
{
arg11 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj9, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj9);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj10 == Py_None) {
arg12 = NULL;
} else if (SWIG_ConvertPtr(obj10, (void **) &arg12, 0, 0) == -1) {
arg12 = (void *) obj10;
PyErr_Clear();
}
}
{
/* FIXME: Handle the NULL case. */
arg13 = svn_swig_py_repos_authz_func;
arg14 = obj11;
}
if (obj12) {
/* Verify that the user supplied a valid pool */
if (obj12 != Py_None && obj12 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj12);
SWIG_arg_fail(svn_argnum_obj12);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_begin_report2(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,arg9,arg10,(struct svn_delta_editor_t const *)arg11,arg12,arg13,arg14,arg15);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_begin_report(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void **arg1 = (void **) 0 ;
svn_revnum_t arg2 ;
char *arg3 = (char *) 0 ;
svn_repos_t *arg4 = (svn_repos_t *) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
char *arg7 = (char *) 0 ;
svn_boolean_t arg8 ;
svn_boolean_t arg9 ;
svn_boolean_t arg10 ;
svn_delta_editor_t *arg11 = (svn_delta_editor_t *) 0 ;
void *arg12 = (void *) 0 ;
svn_repos_authz_func_t arg13 = (svn_repos_authz_func_t) 0 ;
void *arg14 = (void *) 0 ;
apr_pool_t *arg15 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
void *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
PyObject * obj12 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg15 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OsOsszOOOOOO|O:svn_repos_begin_report",&obj0,&arg3,&obj2,&arg5,&arg6,&arg7,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
{
arg2 = (svn_revnum_t)SWIG_As_long (obj0);
if (SWIG_arg_fail(svn_argnum_obj0)) {
SWIG_fail;
}
}
{
arg4 = (svn_repos_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_repos_t, svn_argnum_obj2);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg8 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
arg9 = (svn_boolean_t)SWIG_As_long (obj7);
if (SWIG_arg_fail(svn_argnum_obj7)) {
SWIG_fail;
}
}
{
arg10 = (svn_boolean_t)SWIG_As_long (obj8);
if (SWIG_arg_fail(svn_argnum_obj8)) {
SWIG_fail;
}
}
{
arg11 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj9, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj9);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj10 == Py_None) {
arg12 = NULL;
} else if (SWIG_ConvertPtr(obj10, (void **) &arg12, 0, 0) == -1) {
arg12 = (void *) obj10;
PyErr_Clear();
}
}
{
/* FIXME: Handle the NULL case. */
arg13 = svn_swig_py_repos_authz_func;
arg14 = obj11;
}
if (obj12) {
/* Verify that the user supplied a valid pool */
if (obj12 != Py_None && obj12 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj12);
SWIG_arg_fail(svn_argnum_obj12);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_begin_report(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8,arg9,arg10,(struct svn_delta_editor_t const *)arg11,arg12,arg13,arg14,arg15);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_set_path3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
char *arg2 = (char *) 0 ;
svn_revnum_t arg3 ;
svn_depth_t arg4 ;
svn_boolean_t arg5 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj6 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOOOz|O:svn_repos_set_path3",&obj0,&arg2,&obj2,&obj3,&obj4,&arg6,&obj6)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_depth_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
if (obj6) {
/* Verify that the user supplied a valid pool */
if (obj6 != Py_None && obj6 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
SWIG_arg_fail(svn_argnum_obj6);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_set_path3(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_set_path2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
char *arg2 = (char *) 0 ;
svn_revnum_t arg3 ;
svn_boolean_t arg4 ;
char *arg5 = (char *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOOz|O:svn_repos_set_path2",&obj0,&arg2,&obj2,&obj3,&arg5,&obj5)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_boolean_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_set_path2(arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_set_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
char *arg2 = (char *) 0 ;
svn_revnum_t arg3 ;
svn_boolean_t arg4 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_repos_set_path",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_boolean_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_set_path(arg1,(char const *)arg2,arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_link_path3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
svn_revnum_t arg4 ;
svn_depth_t arg5 ;
svn_boolean_t arg6 ;
char *arg7 = (char *) 0 ;
apr_pool_t *arg8 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg8 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OssOOOz|O:svn_repos_link_path3",&obj0,&arg2,&arg3,&obj3,&obj4,&obj5,&arg7,&obj7)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_depth_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_link_path3(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,(char const *)arg7,arg8);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_link_path2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
svn_revnum_t arg4 ;
svn_boolean_t arg5 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj6 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OssOOz|O:svn_repos_link_path2",&obj0,&arg2,&arg3,&obj3,&obj4,&arg6,&obj6)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
if (obj6) {
/* Verify that the user supplied a valid pool */
if (obj6 != Py_None && obj6 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
SWIG_arg_fail(svn_argnum_obj6);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_link_path2(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_link_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
svn_revnum_t arg4 ;
svn_boolean_t arg5 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OssOO|O:svn_repos_link_path",&obj0,&arg2,&arg3,&obj3,&obj4,&obj5)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_link_path(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_delete_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
char *arg2 = (char *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_delete_path",&obj0,&arg2,&obj2)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_delete_path(arg1,(char const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_finish_report(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_finish_report",&obj0,&obj1)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_finish_report(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_abort_report(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_repos_abort_report",&obj0,&obj1)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_abort_report(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_dir_delta2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
char *arg5 = (char *) 0 ;
svn_delta_editor_t *arg6 = (svn_delta_editor_t *) 0 ;
void *arg7 = (void *) 0 ;
svn_repos_authz_func_t arg8 = (svn_repos_authz_func_t) 0 ;
void *arg9 = (void *) 0 ;
svn_boolean_t arg10 ;
svn_depth_t arg11 ;
svn_boolean_t arg12 ;
svn_boolean_t arg13 ;
apr_pool_t *arg14 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
PyObject * obj12 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg14 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OszOzOOOOOOO|O:svn_repos_dir_delta2",&obj0,&arg2,&arg3,&obj3,&arg5,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
{
arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj3);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg6 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj5, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj5);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj6 == Py_None) {
arg7 = NULL;
} else if (SWIG_ConvertPtr(obj6, (void **) &arg7, 0, 0) == -1) {
arg7 = (void *) obj6;
PyErr_Clear();
}
}
{
/* FIXME: Handle the NULL case. */
arg8 = svn_swig_py_repos_authz_func;
arg9 = obj7;
}
{
arg10 = (svn_boolean_t)SWIG_As_long (obj8);
if (SWIG_arg_fail(svn_argnum_obj8)) {
SWIG_fail;
}
}
{
arg11 = (svn_depth_t)SWIG_As_long (obj9);
if (SWIG_arg_fail(svn_argnum_obj9)) {
SWIG_fail;
}
}
{
arg12 = (svn_boolean_t)SWIG_As_long (obj10);
if (SWIG_arg_fail(svn_argnum_obj10)) {
SWIG_fail;
}
}
{
arg13 = (svn_boolean_t)SWIG_As_long (obj11);
if (SWIG_arg_fail(svn_argnum_obj11)) {
SWIG_fail;
}
}
if (obj12) {
/* Verify that the user supplied a valid pool */
if (obj12 != Py_None && obj12 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj12);
SWIG_arg_fail(svn_argnum_obj12);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_dir_delta2(arg1,(char const *)arg2,(char const *)arg3,arg4,(char const *)arg5,(struct svn_delta_editor_t const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_dir_delta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
char *arg5 = (char *) 0 ;
svn_delta_editor_t *arg6 = (svn_delta_editor_t *) 0 ;
void *arg7 = (void *) 0 ;
svn_repos_authz_func_t arg8 = (svn_repos_authz_func_t) 0 ;
void *arg9 = (void *) 0 ;
svn_boolean_t arg10 ;
svn_boolean_t arg11 ;
svn_boolean_t arg12 ;
svn_boolean_t arg13 ;
apr_pool_t *arg14 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
PyObject * obj12 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg14 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OszOzOOOOOOO|O:svn_repos_dir_delta",&obj0,&arg2,&arg3,&obj3,&arg5,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
{
arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj3);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg6 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj5, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj5);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj6 == Py_None) {
arg7 = NULL;
} else if (SWIG_ConvertPtr(obj6, (void **) &arg7, 0, 0) == -1) {
arg7 = (void *) obj6;
PyErr_Clear();
}
}
{
/* FIXME: Handle the NULL case. */
arg8 = svn_swig_py_repos_authz_func;
arg9 = obj7;
}
{
arg10 = (svn_boolean_t)SWIG_As_long (obj8);
if (SWIG_arg_fail(svn_argnum_obj8)) {
SWIG_fail;
}
}
{
arg11 = (svn_boolean_t)SWIG_As_long (obj9);
if (SWIG_arg_fail(svn_argnum_obj9)) {
SWIG_fail;
}
}
{
arg12 = (svn_boolean_t)SWIG_As_long (obj10);
if (SWIG_arg_fail(svn_argnum_obj10)) {
SWIG_fail;
}
}
{
arg13 = (svn_boolean_t)SWIG_As_long (obj11);
if (SWIG_arg_fail(svn_argnum_obj11)) {
SWIG_fail;
}
}
if (obj12) {
/* Verify that the user supplied a valid pool */
if (obj12 != Py_None && obj12 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj12);
SWIG_arg_fail(svn_argnum_obj12);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_dir_delta(arg1,(char const *)arg2,(char const *)arg3,arg4,(char const *)arg5,(struct svn_delta_editor_t const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_replay2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
char *arg2 = (char *) 0 ;
svn_revnum_t arg3 ;
svn_boolean_t arg4 ;
svn_delta_editor_t *arg5 = (svn_delta_editor_t *) 0 ;
void *arg6 = (void *) 0 ;
svn_repos_authz_func_t arg7 = (svn_repos_authz_func_t) 0 ;
void *arg8 = (void *) 0 ;
apr_pool_t *arg9 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg9 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOOOOO|O:svn_repos_replay2",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_boolean_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj4);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj5 == Py_None) {
arg6 = NULL;
} else if (SWIG_ConvertPtr(obj5, (void **) &arg6, 0, 0) == -1) {
arg6 = (void *) obj5;
PyErr_Clear();
}
}
{
/* FIXME: Handle the NULL case. */
arg7 = svn_swig_py_repos_authz_func;
arg8 = obj6;
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_replay2(arg1,(char const *)arg2,arg3,arg4,(struct svn_delta_editor_t const *)arg5,arg6,arg7,arg8,arg9);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_replay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
svn_delta_editor_t *arg2 = (svn_delta_editor_t *) 0 ;
void *arg3 = (void *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_replay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_delta_editor_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_delta_editor_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj2 == Py_None) {
arg3 = NULL;
} else if (SWIG_ConvertPtr(obj2, (void **) &arg3, 0, 0) == -1) {
arg3 = (void *) obj2;
PyErr_Clear();
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_replay(arg1,(struct svn_delta_editor_t const *)arg2,arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_commit_editor5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_delta_editor_t **arg1 = (svn_delta_editor_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
svn_fs_txn_t *arg4 = (svn_fs_txn_t *) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
apr_hash_t *arg7 = (apr_hash_t *) 0 ;
svn_commit_callback2_t arg8 = (svn_commit_callback2_t) 0 ;
void *arg9 = (void *) 0 ;
svn_repos_authz_callback_t arg10 = (svn_repos_authz_callback_t) 0 ;
void *arg11 = (void *) 0 ;
apr_pool_t *arg12 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_delta_editor_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg12 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOssOOOO|O:svn_repos_get_commit_editor5",&obj0,&obj1,&arg5,&arg6,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (_global_pool == NULL)
{
if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
}
arg7 = svn_swig_py_prophash_from_dict(obj4, _global_pool);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg8 = svn_swig_py_commit_callback2;
arg9 = (void *)obj5;
}
{
svn_repos_authz_callback_t * tmp =
svn_swig_MustGetPtr(obj6, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj6);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg10 = *tmp;
}
{
if (obj7 == Py_None) {
arg11 = NULL;
} else if (SWIG_ConvertPtr(obj7, (void **) &arg11, 0, 0) == -1) {
arg11 = (void *) obj7;
PyErr_Clear();
}
}
if (obj8) {
/* Verify that the user supplied a valid pool */
if (obj8 != Py_None && obj8 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
SWIG_arg_fail(svn_argnum_obj8);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_commit_editor5((struct svn_delta_editor_t const **)arg1,arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_commit_editor4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_delta_editor_t **arg1 = (svn_delta_editor_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
svn_fs_txn_t *arg4 = (svn_fs_txn_t *) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
char *arg7 = (char *) 0 ;
char *arg8 = (char *) 0 ;
svn_commit_callback2_t arg9 = (svn_commit_callback2_t) 0 ;
void *arg10 = (void *) 0 ;
svn_repos_authz_callback_t arg11 = (svn_repos_authz_callback_t) 0 ;
void *arg12 = (void *) 0 ;
apr_pool_t *arg13 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_delta_editor_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg13 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOsszzOOO|O:svn_repos_get_commit_editor4",&obj0,&obj1,&arg5,&arg6,&arg7,&arg8,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg9 = svn_swig_py_commit_callback2;
arg10 = (void *)obj6;
}
{
svn_repos_authz_callback_t * tmp =
svn_swig_MustGetPtr(obj7, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj7);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg11 = *tmp;
}
{
if (obj8 == Py_None) {
arg12 = NULL;
} else if (SWIG_ConvertPtr(obj8, (void **) &arg12, 0, 0) == -1) {
arg12 = (void *) obj8;
PyErr_Clear();
}
}
if (obj9) {
/* Verify that the user supplied a valid pool */
if (obj9 != Py_None && obj9 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj9);
SWIG_arg_fail(svn_argnum_obj9);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_commit_editor4((struct svn_delta_editor_t const **)arg1,arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,arg9,arg10,arg11,arg12,arg13);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_commit_editor3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_delta_editor_t **arg1 = (svn_delta_editor_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
svn_fs_txn_t *arg4 = (svn_fs_txn_t *) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
char *arg7 = (char *) 0 ;
char *arg8 = (char *) 0 ;
svn_commit_callback_t arg9 = (svn_commit_callback_t) 0 ;
void *arg10 = (void *) 0 ;
svn_repos_authz_callback_t arg11 = (svn_repos_authz_callback_t) 0 ;
void *arg12 = (void *) 0 ;
apr_pool_t *arg13 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_delta_editor_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg13 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOsszzOOO|O:svn_repos_get_commit_editor3",&obj0,&obj1,&arg5,&arg6,&arg7,&arg8,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg9 = svn_swig_py_commit_callback;
arg10 = (void *)obj6;
}
{
svn_repos_authz_callback_t * tmp =
svn_swig_MustGetPtr(obj7, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj7);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg11 = *tmp;
}
{
if (obj8 == Py_None) {
arg12 = NULL;
} else if (SWIG_ConvertPtr(obj8, (void **) &arg12, 0, 0) == -1) {
arg12 = (void *) obj8;
PyErr_Clear();
}
}
if (obj9) {
/* Verify that the user supplied a valid pool */
if (obj9 != Py_None && obj9 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj9);
SWIG_arg_fail(svn_argnum_obj9);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_commit_editor3((struct svn_delta_editor_t const **)arg1,arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,arg9,arg10,arg11,arg12,arg13);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_commit_editor2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_delta_editor_t **arg1 = (svn_delta_editor_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
svn_fs_txn_t *arg4 = (svn_fs_txn_t *) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
char *arg7 = (char *) 0 ;
char *arg8 = (char *) 0 ;
svn_commit_callback_t arg9 = (svn_commit_callback_t) 0 ;
void *arg10 = (void *) 0 ;
apr_pool_t *arg11 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_delta_editor_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg11 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOsszzO|O:svn_repos_get_commit_editor2",&obj0,&obj1,&arg5,&arg6,&arg7,&arg8,&obj6,&obj7)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg9 = svn_swig_py_commit_callback;
arg10 = (void *)obj6;
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_commit_editor2((struct svn_delta_editor_t const **)arg1,arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,arg9,arg10,arg11);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_commit_editor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_delta_editor_t **arg1 = (svn_delta_editor_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
char *arg7 = (char *) 0 ;
svn_commit_callback_t arg8 = (svn_commit_callback_t) 0 ;
void *arg9 = (void *) 0 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_delta_editor_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OsszzO|O:svn_repos_get_commit_editor",&obj0,&arg4,&arg5,&arg6,&arg7,&obj5,&obj6)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg8 = svn_swig_py_commit_callback;
arg9 = (void *)obj5;
}
if (obj6) {
/* Verify that the user supplied a valid pool */
if (obj6 != Py_None && obj6 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
SWIG_arg_fail(svn_argnum_obj6);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_commit_editor((struct svn_delta_editor_t const **)arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_dated_revision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_revnum_t *arg1 = (svn_revnum_t *) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
apr_time_t arg3 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_revnum_t temp1 ;
int res1 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_repos_dated_revision",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
arg3 = (apr_time_t) PyLong_AsLongLong(obj1);
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_dated_revision(arg1,arg2,arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
if (SWIG_IsTmpObj(res1)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg1)));
} else {
int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_long, new_flags));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_committed_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_revnum_t *arg1 = (svn_revnum_t *) 0 ;
char **arg2 = (char **) 0 ;
char **arg3 = (char **) 0 ;
svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
char *arg5 = (char *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_revnum_t temp1 ;
int res1 = SWIG_TMPOBJ ;
char *temp2 ;
char *temp3 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
arg3 = &temp3;
if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_get_committed_info",&obj0,&arg5,&obj2)) SWIG_fail;
{
arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_committed_info(arg1,(char const **)arg2,(char const **)arg3,arg4,(char const *)arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
if (SWIG_IsTmpObj(res1)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg1)));
} else {
int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_long, new_flags));
}
{
PyObject *s;
if (*arg2 == NULL) {
Py_INCREF(Py_None);
s = Py_None;
}
else {
s = PyString_FromString(*arg2);
if (s == NULL)
SWIG_fail;
}
resultobj = SWIG_Python_AppendOutput(resultobj, s);
}
{
PyObject *s;
if (*arg3 == NULL) {
Py_INCREF(Py_None);
s = Py_None;
}
else {
s = PyString_FromString(*arg3);
if (s == NULL)
SWIG_fail;
}
resultobj = SWIG_Python_AppendOutput(resultobj, s);
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_stat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_dirent_t **arg1 = (svn_dirent_t **) 0 ;
svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_dirent_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_repos_stat",&obj0,&arg3,&obj2)) SWIG_fail;
{
arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_stat(arg1,arg2,(char const *)arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_dirent_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_deleted_rev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_t *arg1 = (svn_fs_t *) 0 ;
char *arg2 = (char *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
svn_revnum_t *arg5 = (svn_revnum_t *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_revnum_t temp5 ;
int res5 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
arg5 = &temp5;
if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_repos_deleted_rev",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_deleted_rev(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
if (SWIG_IsTmpObj(res5)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
} else {
int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_history2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_t *arg1 = (svn_fs_t *) 0 ;
char *arg2 = (char *) 0 ;
svn_repos_history_func_t arg3 = (svn_repos_history_func_t) 0 ;
void *arg4 = (void *) 0 ;
svn_repos_authz_func_t arg5 = (svn_repos_authz_func_t) 0 ;
void *arg6 = (void *) 0 ;
svn_revnum_t arg7 ;
svn_revnum_t arg8 ;
svn_boolean_t arg9 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOOOOO|O:svn_repos_history2",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = svn_swig_py_repos_history_func;
arg4 = obj2;
}
{
/* FIXME: Handle the NULL case. */
arg5 = svn_swig_py_repos_authz_func;
arg6 = obj3;
}
{
arg7 = (svn_revnum_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg8 = (svn_revnum_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg9 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_history2(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_t *arg1 = (svn_fs_t *) 0 ;
char *arg2 = (char *) 0 ;
svn_repos_history_func_t arg3 = (svn_repos_history_func_t) 0 ;
void *arg4 = (void *) 0 ;
svn_revnum_t arg5 ;
svn_revnum_t arg6 ;
svn_boolean_t arg7 ;
apr_pool_t *arg8 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg8 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOOOO|O:svn_repos_history",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = svn_swig_py_repos_history_func;
arg4 = obj2;
}
{
arg5 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg6 = (svn_revnum_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
if (obj6) {
/* Verify that the user supplied a valid pool */
if (obj6 != Py_None && obj6 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
SWIG_arg_fail(svn_argnum_obj6);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_history(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_trace_node_locations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_t *arg1 = (svn_fs_t *) 0 ;
apr_hash_t **arg2 = (apr_hash_t **) 0 ;
char *arg3 = (char *) 0 ;
svn_revnum_t arg4 ;
apr_array_header_t *arg5 = (apr_array_header_t *) 0 ;
svn_repos_authz_func_t arg6 = (svn_repos_authz_func_t) 0 ;
void *arg7 = (void *) 0 ;
apr_pool_t *arg8 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
apr_hash_t *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg8 = _global_pool;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OsOOO|O:svn_repos_trace_node_locations",&obj0,&arg3,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg5 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj3,
sizeof(svn_revnum_t),
svn_swig_py_unwrap_revnum,
NULL,
_global_pool);
if (PyErr_Occurred())
SWIG_fail;
}
{
/* FIXME: Handle the NULL case. */
arg6 = svn_swig_py_repos_authz_func;
arg7 = obj4;
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_trace_node_locations(arg1,arg2,(char const *)arg3,arg4,(apr_array_header_t const *)arg5,arg6,arg7,arg8);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_locationhash_to_dict(*arg2));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_location_segments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
char *arg2 = (char *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
svn_revnum_t arg5 ;
svn_location_segment_receiver_t arg6 = (svn_location_segment_receiver_t) 0 ;
void *arg7 = (void *) 0 ;
svn_repos_authz_func_t arg8 = (svn_repos_authz_func_t) 0 ;
void *arg9 = (void *) 0 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOOOOO|O:svn_repos_node_location_segments",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_revnum_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = svn_swig_py_location_segment_receiver_func;
arg7 = obj5;
}
{
/* FIXME: Handle the NULL case. */
arg8 = svn_swig_py_repos_authz_func;
arg9 = obj6;
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_node_location_segments(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_logs4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
int arg5 ;
svn_boolean_t arg6 ;
svn_boolean_t arg7 ;
svn_boolean_t arg8 ;
apr_array_header_t *arg9 = (apr_array_header_t *) 0 ;
svn_repos_authz_func_t arg10 = (svn_repos_authz_func_t) 0 ;
void *arg11 = (void *) 0 ;
svn_log_entry_receiver_t arg12 = (svn_log_entry_receiver_t) 0 ;
void *arg13 = (void *) 0 ;
apr_pool_t *arg14 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg14 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO|O:svn_repos_get_logs4",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
sizeof(const char *),
svn_swig_py_unwrap_string,
NULL,
_global_pool);
if (PyErr_Occurred())
SWIG_fail;
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (int)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
arg8 = (svn_boolean_t)SWIG_As_long (obj7);
if (SWIG_arg_fail(svn_argnum_obj7)) {
SWIG_fail;
}
}
{
arg9 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj8,
sizeof(const char *),
svn_swig_py_unwrap_string,
NULL,
_global_pool);
if (PyErr_Occurred())
SWIG_fail;
}
{
/* FIXME: Handle the NULL case. */
arg10 = svn_swig_py_repos_authz_func;
arg11 = obj9;
}
{
arg12 = svn_swig_py_log_entry_receiver;
arg13 = (void *)obj10;
}
if (obj11) {
/* Verify that the user supplied a valid pool */
if (obj11 != Py_None && obj11 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj11);
SWIG_arg_fail(svn_argnum_obj11);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_logs4(arg1,(apr_array_header_t const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,(apr_array_header_t const *)arg9,arg10,arg11,arg12,arg13,arg14);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_logs3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
int arg5 ;
svn_boolean_t arg6 ;
svn_boolean_t arg7 ;
svn_repos_authz_func_t arg8 = (svn_repos_authz_func_t) 0 ;
void *arg9 = (void *) 0 ;
svn_log_message_receiver_t arg10 = (svn_log_message_receiver_t) 0 ;
void *arg11 = (void *) 0 ;
apr_pool_t *arg12 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg12 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|O:svn_repos_get_logs3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
sizeof(const char *),
svn_swig_py_unwrap_string,
NULL,
_global_pool);
if (PyErr_Occurred())
SWIG_fail;
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (int)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg8 = svn_swig_py_repos_authz_func;
arg9 = obj7;
}
{
arg10 = svn_swig_py_log_receiver;
arg11 = (void *)obj8;
}
if (obj9) {
/* Verify that the user supplied a valid pool */
if (obj9 != Py_None && obj9 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj9);
SWIG_arg_fail(svn_argnum_obj9);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_logs3(arg1,(apr_array_header_t const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_logs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
svn_boolean_t arg5 ;
svn_boolean_t arg6 ;
svn_repos_authz_func_t arg7 = (svn_repos_authz_func_t) 0 ;
void *arg8 = (void *) 0 ;
svn_log_message_receiver_t arg9 = (svn_log_message_receiver_t) 0 ;
void *arg10 = (void *) 0 ;
apr_pool_t *arg11 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg11 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO|O:svn_repos_get_logs2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
sizeof(const char *),
svn_swig_py_unwrap_string,
NULL,
_global_pool);
if (PyErr_Occurred())
SWIG_fail;
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg7 = svn_swig_py_repos_authz_func;
arg8 = obj6;
}
{
arg9 = svn_swig_py_log_receiver;
arg10 = (void *)obj7;
}
if (obj8) {
/* Verify that the user supplied a valid pool */
if (obj8 != Py_None && obj8 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
SWIG_arg_fail(svn_argnum_obj8);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_logs2(arg1,(apr_array_header_t const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_logs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
svn_boolean_t arg5 ;
svn_boolean_t arg6 ;
svn_log_message_receiver_t arg7 = (svn_log_message_receiver_t) 0 ;
void *arg8 = (void *) 0 ;
apr_pool_t *arg9 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg9 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO|O:svn_repos_get_logs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
sizeof(const char *),
svn_swig_py_unwrap_string,
NULL,
_global_pool);
if (PyErr_Occurred())
SWIG_fail;
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg7 = svn_swig_py_log_receiver;
arg8 = (void *)obj6;
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_logs(arg1,(apr_array_header_t const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_get_mergeinfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_mergeinfo_catalog_t *arg1 = (svn_mergeinfo_catalog_t *) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
apr_array_header_t *arg3 = (apr_array_header_t *) 0 ;
svn_revnum_t arg4 ;
svn_mergeinfo_inheritance_t arg5 ;
svn_boolean_t arg6 ;
svn_repos_authz_func_t arg7 = (svn_repos_authz_func_t) 0 ;
void *arg8 = (void *) 0 ;
apr_pool_t *arg9 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_mergeinfo_catalog_t temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg9 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO|O:svn_repos_fs_get_mergeinfo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (apr_array_header_t *) svn_swig_py_seq_to_array(obj1,
sizeof(const char *),
svn_swig_py_unwrap_string,
NULL,
_global_pool);
if (PyErr_Occurred())
SWIG_fail;
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg5 = (svn_mergeinfo_inheritance_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg7 = svn_swig_py_repos_authz_func;
arg8 = obj5;
}
if (obj6) {
/* Verify that the user supplied a valid pool */
if (obj6 != Py_None && obj6 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
SWIG_arg_fail(svn_argnum_obj6);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_get_mergeinfo(arg1,arg2,(apr_array_header_t const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_mergeinfo_catalog_to_dict(*arg1,
SWIGTYPE_p_svn_merge_range_t,
_global_py_pool))
;
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_file_revs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
char *arg2 = (char *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
svn_boolean_t arg5 ;
svn_repos_authz_func_t arg6 = (svn_repos_authz_func_t) 0 ;
void *arg7 = (void *) 0 ;
svn_file_rev_handler_t arg8 = (svn_file_rev_handler_t) 0 ;
void *arg9 = (void *) 0 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOOOOOO|O:svn_repos_get_file_revs2",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg6 = svn_swig_py_repos_authz_func;
arg7 = obj5;
}
{
svn_file_rev_handler_t * tmp =
svn_swig_MustGetPtr(obj6, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj6);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg8 = *tmp;
}
{
if (obj7 == Py_None) {
arg9 = NULL;
} else if (SWIG_ConvertPtr(obj7, (void **) &arg9, 0, 0) == -1) {
arg9 = (void *) obj7;
PyErr_Clear();
}
}
if (obj8) {
/* Verify that the user supplied a valid pool */
if (obj8 != Py_None && obj8 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
SWIG_arg_fail(svn_argnum_obj8);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_file_revs2(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_file_revs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
char *arg2 = (char *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
svn_repos_authz_func_t arg5 = (svn_repos_authz_func_t) 0 ;
void *arg6 = (void *) 0 ;
svn_repos_file_rev_handler_t arg7 = (svn_repos_file_rev_handler_t) 0 ;
void *arg8 = (void *) 0 ;
apr_pool_t *arg9 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg9 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsOOOOO|O:svn_repos_get_file_revs",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg5 = svn_swig_py_repos_authz_func;
arg6 = obj4;
}
{
svn_repos_file_rev_handler_t * tmp =
svn_swig_MustGetPtr(obj5, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj5);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg7 = *tmp;
}
{
if (obj6 == Py_None) {
arg8 = NULL;
} else if (SWIG_ConvertPtr(obj6, (void **) &arg8, 0, 0) == -1) {
arg8 = (void *) obj6;
PyErr_Clear();
}
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_file_revs(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_commit_txn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
svn_revnum_t *arg3 = (svn_revnum_t *) 0 ;
svn_fs_txn_t *arg4 = (svn_fs_txn_t *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
char *temp1 ;
svn_revnum_t temp3 ;
int res3 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
arg1 = &temp1;
arg3 = &temp3;
if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_repos_fs_commit_txn",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_commit_txn((char const **)arg1,arg2,arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
PyObject *s;
if (*arg1 == NULL) {
Py_INCREF(Py_None);
s = Py_None;
}
else {
s = PyString_FromString(*arg1);
if (s == NULL)
SWIG_fail;
}
resultobj = SWIG_Python_AppendOutput(resultobj, s);
}
if (SWIG_IsTmpObj(res3)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
} else {
int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_begin_txn_for_commit2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_txn_t **arg1 = (svn_fs_txn_t **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
svn_revnum_t arg3 ;
apr_hash_t *arg4 = (apr_hash_t *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_fs_txn_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_fs_begin_txn_for_commit2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
if (_global_pool == NULL)
{
if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
}
arg4 = svn_swig_py_prophash_from_dict(obj2, _global_pool);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_begin_txn_for_commit2(arg1,arg2,arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_begin_txn_for_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_txn_t **arg1 = (svn_fs_txn_t **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
svn_revnum_t arg3 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_fs_txn_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OOsz|O:svn_repos_fs_begin_txn_for_commit",&obj0,&obj1,&arg4,&arg5,&obj4)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_begin_txn_for_commit(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_begin_txn_for_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_txn_t **arg1 = (svn_fs_txn_t **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
svn_revnum_t arg3 ;
char *arg4 = (char *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_fs_txn_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OOs|O:svn_repos_fs_begin_txn_for_update",&obj0,&obj1,&arg4,&obj3)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_begin_txn_for_update(arg1,arg2,arg3,(char const *)arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_lock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_lock_t **arg1 = (svn_lock_t **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
svn_boolean_t arg6 ;
apr_time_t arg7 ;
svn_revnum_t arg8 ;
svn_boolean_t arg9 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_lock_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OszzOOOO|O:svn_repos_fs_lock",&obj0,&arg3,&arg4,&arg5,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
arg7 = (apr_time_t) PyLong_AsLongLong(obj5);
{
arg8 = (svn_revnum_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
arg9 = (svn_boolean_t)SWIG_As_long (obj7);
if (SWIG_arg_fail(svn_argnum_obj7)) {
SWIG_fail;
}
}
if (obj8) {
/* Verify that the user supplied a valid pool */
if (obj8 != Py_None && obj8 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
SWIG_arg_fail(svn_argnum_obj8);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_lock(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,arg6,arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_lock_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
svn_boolean_t arg4 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OszO|O:svn_repos_fs_unlock",&obj0,&arg2,&arg3,&obj3,&obj4)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_boolean_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_unlock(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_get_locks2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
apr_hash_t **arg1 = (apr_hash_t **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
char *arg3 = (char *) 0 ;
svn_depth_t arg4 ;
svn_repos_authz_func_t arg5 = (svn_repos_authz_func_t) 0 ;
void *arg6 = (void *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
apr_hash_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_repos_fs_get_locks2",&obj0,&arg3,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_depth_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg5 = svn_swig_py_repos_authz_func;
arg6 = obj3;
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_get_locks2(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_convert_hash(*arg1,
SWIGTYPE_p_svn_lock_t,
_global_py_pool))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_get_locks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
apr_hash_t **arg1 = (apr_hash_t **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
char *arg3 = (char *) 0 ;
svn_repos_authz_func_t arg4 = (svn_repos_authz_func_t) 0 ;
void *arg5 = (void *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
apr_hash_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_repos_fs_get_locks",&obj0,&arg3,&obj2,&obj3)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg4 = svn_swig_py_repos_authz_func;
arg5 = obj2;
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_get_locks(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_convert_hash(*arg1,
SWIGTYPE_p_svn_lock_t,
_global_py_pool))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_change_rev_prop4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_revnum_t arg2 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
svn_string_t **arg5 = (svn_string_t **) 0 ;
svn_string_t *arg6 = (svn_string_t *) 0 ;
svn_boolean_t arg7 ;
svn_boolean_t arg8 ;
svn_repos_authz_func_t arg9 = (svn_repos_authz_func_t) 0 ;
void *arg10 = (void *) 0 ;
apr_pool_t *arg11 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t value6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg11 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOssOOOOO|O:svn_repos_fs_change_rev_prop4",&obj0,&obj1,&arg3,&arg4,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
arg5 = (svn_string_t **)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_p_svn_string_t, svn_argnum_obj4);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj5 == Py_None)
arg6 = NULL;
else {
if (!PyString_Check(obj5)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value6.data = PyString_AS_STRING(obj5);
value6.len = PyString_GET_SIZE(obj5);
arg6 = &value6;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
arg8 = (svn_boolean_t)SWIG_As_long (obj7);
if (SWIG_arg_fail(svn_argnum_obj7)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg9 = svn_swig_py_repos_authz_func;
arg10 = obj8;
}
if (obj9) {
/* Verify that the user supplied a valid pool */
if (obj9 != Py_None && obj9 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj9);
SWIG_arg_fail(svn_argnum_obj9);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_change_rev_prop4(arg1,arg2,(char const *)arg3,(char const *)arg4,(struct svn_string_t const *const *)arg5,(struct svn_string_t const *)arg6,arg7,arg8,arg9,arg10,arg11);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
PyObject *s;
if (*arg5 == NULL) {
Py_INCREF(Py_None);
s = Py_None;
}
else {
s = PyString_FromStringAndSize((*arg5)->data, (*arg5)->len);
if (s == NULL)
SWIG_fail;
}
resultobj = SWIG_Python_AppendOutput(resultobj, s);
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_change_rev_prop3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_revnum_t arg2 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
svn_string_t *arg5 = (svn_string_t *) 0 ;
svn_boolean_t arg6 ;
svn_boolean_t arg7 ;
svn_repos_authz_func_t arg8 = (svn_repos_authz_func_t) 0 ;
void *arg9 = (void *) 0 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t value5 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOssOOOO|O:svn_repos_fs_change_rev_prop3",&obj0,&obj1,&arg3,&arg4,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
if (obj4 == Py_None)
arg5 = NULL;
else {
if (!PyString_Check(obj4)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value5.data = PyString_AS_STRING(obj4);
value5.len = PyString_GET_SIZE(obj4);
arg5 = &value5;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg8 = svn_swig_py_repos_authz_func;
arg9 = obj7;
}
if (obj8) {
/* Verify that the user supplied a valid pool */
if (obj8 != Py_None && obj8 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
SWIG_arg_fail(svn_argnum_obj8);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_change_rev_prop3(arg1,arg2,(char const *)arg3,(char const *)arg4,(struct svn_string_t const *)arg5,arg6,arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_change_rev_prop2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_revnum_t arg2 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
svn_string_t *arg5 = (svn_string_t *) 0 ;
svn_repos_authz_func_t arg6 = (svn_repos_authz_func_t) 0 ;
void *arg7 = (void *) 0 ;
apr_pool_t *arg8 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t value5 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg8 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOssOO|O:svn_repos_fs_change_rev_prop2",&obj0,&obj1,&arg3,&arg4,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
if (obj4 == Py_None)
arg5 = NULL;
else {
if (!PyString_Check(obj4)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value5.data = PyString_AS_STRING(obj4);
value5.len = PyString_GET_SIZE(obj4);
arg5 = &value5;
}
}
{
/* FIXME: Handle the NULL case. */
arg6 = svn_swig_py_repos_authz_func;
arg7 = obj5;
}
if (obj6) {
/* Verify that the user supplied a valid pool */
if (obj6 != Py_None && obj6 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
SWIG_arg_fail(svn_argnum_obj6);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_change_rev_prop2(arg1,arg2,(char const *)arg3,(char const *)arg4,(struct svn_string_t const *)arg5,arg6,arg7,arg8);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_change_rev_prop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_revnum_t arg2 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
svn_string_t *arg5 = (svn_string_t *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t value5 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOssO|O:svn_repos_fs_change_rev_prop",&obj0,&obj1,&arg3,&arg4,&obj4,&obj5)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
if (obj4 == Py_None)
arg5 = NULL;
else {
if (!PyString_Check(obj4)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value5.data = PyString_AS_STRING(obj4);
value5.len = PyString_GET_SIZE(obj4);
arg5 = &value5;
}
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_change_rev_prop(arg1,arg2,(char const *)arg3,(char const *)arg4,(struct svn_string_t const *)arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_revision_prop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_string_t **arg1 = (svn_string_t **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
svn_revnum_t arg3 ;
char *arg4 = (char *) 0 ;
svn_repos_authz_func_t arg5 = (svn_repos_authz_func_t) 0 ;
void *arg6 = (void *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_repos_fs_revision_prop",&obj0,&obj1,&arg4,&obj3,&obj4)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg5 = svn_swig_py_repos_authz_func;
arg6 = obj3;
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_revision_prop(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
PyObject *s;
if (*arg1 == NULL) {
Py_INCREF(Py_None);
s = Py_None;
}
else {
s = PyString_FromStringAndSize((*arg1)->data, (*arg1)->len);
if (s == NULL)
SWIG_fail;
}
resultobj = SWIG_Python_AppendOutput(resultobj, s);
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_revision_proplist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
apr_hash_t **arg1 = (apr_hash_t **) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
svn_revnum_t arg3 ;
svn_repos_authz_func_t arg4 = (svn_repos_authz_func_t) 0 ;
void *arg5 = (void *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
apr_hash_t *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_fs_revision_proplist",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg4 = svn_swig_py_repos_authz_func;
arg5 = obj2;
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_revision_proplist(arg1,arg2,arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_prophash_to_dict(*arg1));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_change_node_prop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
svn_string_t *arg4 = (svn_string_t *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t value4 ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OssO|O:svn_repos_fs_change_node_prop",&obj0,&arg2,&arg3,&obj3,&obj4)) SWIG_fail;
{
arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj3 == Py_None)
arg4 = NULL;
else {
if (!PyString_Check(obj3)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value4.data = PyString_AS_STRING(obj3);
value4.len = PyString_GET_SIZE(obj3);
arg4 = &value4;
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_change_node_prop(arg1,(char const *)arg2,(char const *)arg3,(struct svn_string_t const *)arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_change_txn_prop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_txn_t *arg1 = (svn_fs_txn_t *) 0 ;
char *arg2 = (char *) 0 ;
svn_string_t *arg3 = (svn_string_t *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_string_t value3 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_repos_fs_change_txn_prop",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
{
arg1 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj2 == Py_None)
arg3 = NULL;
else {
if (!PyString_Check(obj2)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value3.data = PyString_AS_STRING(obj2);
value3.len = PyString_GET_SIZE(obj2);
arg3 = &value3;
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_change_txn_prop(arg1,(char const *)arg2,(struct svn_string_t const *)arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_fs_change_txn_props(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_fs_txn_t *arg1 = (svn_fs_txn_t *) 0 ;
apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_repos_fs_change_txn_props",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (apr_array_header_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_fs_change_txn_props(arg1,(apr_array_header_t const *)arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_kind_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
svn_node_kind_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_kind_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_node_kind_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->kind = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_kind_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
svn_node_kind_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_kind_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_node_kind_t) ((arg1)->kind);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_action_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
char arg2 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"Oc:svn_repos_node_t_action_set",&obj0,&arg2)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (arg1) (arg1)->action = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_action_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
char result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_action_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (char) ((arg1)->action);
resultobj = SWIG_From_char((char)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_text_mod_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
svn_boolean_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_text_mod_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->text_mod = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_text_mod_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
svn_boolean_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_text_mod_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_boolean_t) ((arg1)->text_mod);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_prop_mod_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
svn_boolean_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_prop_mod_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->prop_mod = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_prop_mod_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
svn_boolean_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_prop_mod_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_boolean_t) ((arg1)->prop_mod);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
char *arg2 = (char *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"Os:svn_repos_node_t_name_set",&obj0,&arg2)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
apr_size_t len = strlen(arg2) + 1;
char *copied;
if (arg1->name) free((char *)arg1->name);
copied = malloc(len);
memcpy(copied, arg2, len);
arg1->name = copied;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_name_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (char *) ((arg1)->name);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_copyfrom_rev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
svn_revnum_t arg2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_copyfrom_rev_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (arg1) (arg1)->copyfrom_rev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_copyfrom_rev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
svn_revnum_t result;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_copyfrom_rev_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_revnum_t) ((arg1)->copyfrom_rev);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_copyfrom_path_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
char *arg2 = (char *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"Oz:svn_repos_node_t_copyfrom_path_set",&obj0,&arg2)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
apr_size_t len = strlen(arg2) + 1;
char *copied;
if (arg1->copyfrom_path) free((char *)arg1->copyfrom_path);
copied = malloc(len);
memcpy(copied, arg2, len);
arg1->copyfrom_path = copied;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_copyfrom_path_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_copyfrom_path_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (char *) ((arg1)->copyfrom_path);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_sibling_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
struct svn_repos_node_t *arg2 = (struct svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_sibling_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (arg1) (arg1)->sibling = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_sibling_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
struct svn_repos_node_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_sibling_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (struct svn_repos_node_t *) ((arg1)->sibling);
resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
_global_py_pool, args);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_child_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
struct svn_repos_node_t *arg2 = (struct svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_child_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (arg1) (arg1)->child = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_child_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
struct svn_repos_node_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_child_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (struct svn_repos_node_t *) ((arg1)->child);
resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
_global_py_pool, args);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_parent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
struct svn_repos_node_t *arg2 = (struct svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_node_t_parent_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (struct svn_repos_node_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (arg1) (arg1)->parent = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_t_parent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_node_t *arg1 = (svn_repos_node_t *) 0 ;
PyObject * obj0 = 0 ;
struct svn_repos_node_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_t_parent_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_node_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_node_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (struct svn_repos_node_t *) ((arg1)->parent);
resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
_global_py_pool, args);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *svn_repos_node_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_svn_repos_node_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_svn_repos_node_editor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_delta_editor_t **arg1 = (svn_delta_editor_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
svn_fs_root_t *arg5 = (svn_fs_root_t *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_delta_editor_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:svn_repos_node_editor",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg5 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_node_editor((struct svn_delta_editor_t const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_node_from_baton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
PyObject * obj0 = 0 ;
svn_repos_node_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_node_from_baton",&obj0)) SWIG_fail;
{
if (obj0 == Py_None) {
arg1 = NULL;
} else if (SWIG_ConvertPtr(obj0, (void **) &arg1, 0, 0) == -1) {
arg1 = (void *) obj0;
PyErr_Clear();
}
}
{
svn_swig_py_release_py_lock();
result = (svn_repos_node_t *)svn_repos_node_from_baton(arg1);
svn_swig_py_acquire_py_lock();
}
resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_repos_node_t,
_global_py_pool, args);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_verify_fs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_revnum_t arg2 ;
svn_revnum_t arg3 ;
svn_repos_notify_func_t arg4 = (svn_repos_notify_func_t) 0 ;
void *arg5 = (void *) 0 ;
svn_cancel_func_t arg6 = (svn_cancel_func_t) 0 ;
void *arg7 = (void *) 0 ;
apr_pool_t *arg8 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg8 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO|O:svn_repos_verify_fs2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_revnum_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
svn_repos_notify_func_t * tmp =
svn_swig_MustGetPtr(obj3, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj3);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg4 = *tmp;
}
{
if (obj4 == Py_None) {
arg5 = NULL;
} else if (SWIG_ConvertPtr(obj4, (void **) &arg5, 0, 0) == -1) {
arg5 = (void *) obj4;
PyErr_Clear();
}
}
{
svn_cancel_func_t * tmp =
svn_swig_MustGetPtr(obj5, SWIGTYPE_p_p_f_p_void__p_svn_error_t, svn_argnum_obj5);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg6 = *tmp;
}
{
if (obj6 == Py_None) {
arg7 = NULL;
} else if (SWIG_ConvertPtr(obj6, (void **) &arg7, 0, 0) == -1) {
arg7 = (void *) obj6;
PyErr_Clear();
}
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_verify_fs2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_verify_fs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_stream_t *arg2 = (svn_stream_t *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
svn_cancel_func_t arg5 = (svn_cancel_func_t) 0 ;
void *arg6 = (void *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:svn_repos_verify_fs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = svn_swig_py_make_stream (obj1, _global_pool);
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = svn_swig_py_cancel_func;
arg6 = obj4; /* our function is the baton. */
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_verify_fs(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_dump_fs3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_stream_t *arg2 = (svn_stream_t *) 0 ;
svn_revnum_t arg3 ;
svn_revnum_t arg4 ;
svn_boolean_t arg5 ;
svn_boolean_t arg6 ;
svn_repos_notify_func_t arg7 = (svn_repos_notify_func_t) 0 ;
void *arg8 = (void *) 0 ;
svn_cancel_func_t arg9 = (svn_cancel_func_t) 0 ;
void *arg10 = (void *) 0 ;
apr_pool_t *arg11 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg11 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|O:svn_repos_dump_fs3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = svn_swig_py_make_stream (obj1, _global_pool);
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
svn_repos_notify_func_t * tmp =
svn_swig_MustGetPtr(obj6, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj6);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg7 = *tmp;
}
{
if (obj7 == Py_None) {
arg8 = NULL;
} else if (SWIG_ConvertPtr(obj7, (void **) &arg8, 0, 0) == -1) {
arg8 = (void *) obj7;
PyErr_Clear();
}
}
{
arg9 = svn_swig_py_cancel_func;
arg10 = obj8; /* our function is the baton. */
}
if (obj9) {
/* Verify that the user supplied a valid pool */
if (obj9 != Py_None && obj9 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj9);
SWIG_arg_fail(svn_argnum_obj9);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_dump_fs3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_dump_fs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_stream_t *arg2 = (svn_stream_t *) 0 ;
svn_stream_t *arg3 = (svn_stream_t *) 0 ;
svn_revnum_t arg4 ;
svn_revnum_t arg5 ;
svn_boolean_t arg6 ;
svn_boolean_t arg7 ;
svn_cancel_func_t arg8 = (svn_cancel_func_t) 0 ;
void *arg9 = (void *) 0 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO|O:svn_repos_dump_fs2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = svn_swig_py_make_stream (obj1, _global_pool);
}
{
arg3 = svn_swig_py_make_stream (obj2, _global_pool);
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_revnum_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
arg8 = svn_swig_py_cancel_func;
arg9 = obj7; /* our function is the baton. */
}
if (obj8) {
/* Verify that the user supplied a valid pool */
if (obj8 != Py_None && obj8 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
SWIG_arg_fail(svn_argnum_obj8);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_dump_fs2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_dump_fs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_stream_t *arg2 = (svn_stream_t *) 0 ;
svn_stream_t *arg3 = (svn_stream_t *) 0 ;
svn_revnum_t arg4 ;
svn_revnum_t arg5 ;
svn_boolean_t arg6 ;
svn_cancel_func_t arg7 = (svn_cancel_func_t) 0 ;
void *arg8 = (void *) 0 ;
apr_pool_t *arg9 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg9 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO|O:svn_repos_dump_fs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = svn_swig_py_make_stream (obj1, _global_pool);
}
{
arg3 = svn_swig_py_make_stream (obj2, _global_pool);
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (svn_revnum_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg7 = svn_swig_py_cancel_func;
arg8 = obj6; /* our function is the baton. */
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_dump_fs(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_load_fs3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_stream_t *arg2 = (svn_stream_t *) 0 ;
enum svn_repos_load_uuid arg3 ;
char *arg4 = (char *) 0 ;
svn_boolean_t arg5 ;
svn_boolean_t arg6 ;
svn_boolean_t arg7 ;
svn_repos_notify_func_t arg8 = (svn_repos_notify_func_t) 0 ;
void *arg9 = (void *) 0 ;
svn_cancel_func_t arg10 = (svn_cancel_func_t) 0 ;
void *arg11 = (void *) 0 ;
apr_pool_t *arg12 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg12 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOzOOOOOO|O:svn_repos_load_fs3",&obj0,&obj1,&obj2,&arg4,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = svn_swig_py_make_stream (obj1, _global_pool);
}
{
arg3 = (enum svn_repos_load_uuid)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
svn_repos_notify_func_t * tmp =
svn_swig_MustGetPtr(obj7, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj7);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg8 = *tmp;
}
{
if (obj8 == Py_None) {
arg9 = NULL;
} else if (SWIG_ConvertPtr(obj8, (void **) &arg9, 0, 0) == -1) {
arg9 = (void *) obj8;
PyErr_Clear();
}
}
{
arg10 = svn_swig_py_cancel_func;
arg11 = obj9; /* our function is the baton. */
}
if (obj10) {
/* Verify that the user supplied a valid pool */
if (obj10 != Py_None && obj10 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj10);
SWIG_arg_fail(svn_argnum_obj10);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_load_fs3(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_load_fs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_stream_t *arg2 = (svn_stream_t *) 0 ;
svn_stream_t *arg3 = (svn_stream_t *) 0 ;
enum svn_repos_load_uuid arg4 ;
char *arg5 = (char *) 0 ;
svn_boolean_t arg6 ;
svn_boolean_t arg7 ;
svn_cancel_func_t arg8 = (svn_cancel_func_t) 0 ;
void *arg9 = (void *) 0 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOzOOO|O:svn_repos_load_fs2",&obj0,&obj1,&obj2,&obj3,&arg5,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = svn_swig_py_make_stream (obj1, _global_pool);
}
{
arg3 = svn_swig_py_make_stream (obj2, _global_pool);
}
{
arg4 = (enum svn_repos_load_uuid)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg6 = (svn_boolean_t)SWIG_As_long (obj5);
if (SWIG_arg_fail(svn_argnum_obj5)) {
SWIG_fail;
}
}
{
arg7 = (svn_boolean_t)SWIG_As_long (obj6);
if (SWIG_arg_fail(svn_argnum_obj6)) {
SWIG_fail;
}
}
{
arg8 = svn_swig_py_cancel_func;
arg9 = obj7; /* our function is the baton. */
}
if (obj8) {
/* Verify that the user supplied a valid pool */
if (obj8 != Py_None && obj8 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
SWIG_arg_fail(svn_argnum_obj8);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_load_fs2(arg1,arg2,arg3,arg4,(char const *)arg5,arg6,arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_load_fs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
svn_stream_t *arg2 = (svn_stream_t *) 0 ;
svn_stream_t *arg3 = (svn_stream_t *) 0 ;
enum svn_repos_load_uuid arg4 ;
char *arg5 = (char *) 0 ;
svn_cancel_func_t arg6 = (svn_cancel_func_t) 0 ;
void *arg7 = (void *) 0 ;
apr_pool_t *arg8 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg8 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOOzO|O:svn_repos_load_fs",&obj0,&obj1,&obj2,&obj3,&arg5,&obj5,&obj6)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = svn_swig_py_make_stream (obj1, _global_pool);
}
{
arg3 = svn_swig_py_make_stream (obj2, _global_pool);
}
{
arg4 = (enum svn_repos_load_uuid)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg6 = svn_swig_py_cancel_func;
arg7 = obj5; /* our function is the baton. */
}
if (obj6) {
/* Verify that the user supplied a valid pool */
if (obj6 != Py_None && obj6 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
SWIG_arg_fail(svn_argnum_obj6);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_load_fs(arg1,arg2,arg3,arg4,(char const *)arg5,arg6,arg7,arg8);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_new_revision_record_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(void **,apr_hash_t *,void *,apr_pool_t *) = (svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_new_revision_record_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_new_revision_record_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->new_revision_record = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_new_revision_record_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void **,apr_hash_t *,void *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_new_revision_record_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)) ((arg1)->new_revision_record);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_uuid_record_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(char const *,void *,apr_pool_t *) = (svn_error_t *(*)(char const *,void *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_uuid_record_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_uuid_record_set" "', argument " "2"" of type '" "svn_error_t *(*)(char const *,void *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->uuid_record = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_uuid_record_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(char const *,void *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_uuid_record_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(char const *,void *,apr_pool_t *)) ((arg1)->uuid_record);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_new_node_record_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(void **,apr_hash_t *,void *,apr_pool_t *) = (svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_new_node_record_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_new_node_record_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->new_node_record = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_new_node_record_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void **,apr_hash_t *,void *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_new_node_record_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)) ((arg1)->new_node_record);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_set_revision_property_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(void *,char const *,svn_string_t const *) = (svn_error_t *(*)(void *,char const *,svn_string_t const *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_set_revision_property_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_set_revision_property_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,char const *,svn_string_t const *)""'");
}
}
if (arg1) (arg1)->set_revision_property = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_set_revision_property_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *,char const *,svn_string_t const *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_set_revision_property_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *,char const *,svn_string_t const *)) ((arg1)->set_revision_property);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_set_node_property_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(void *,char const *,svn_string_t const *) = (svn_error_t *(*)(void *,char const *,svn_string_t const *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_set_node_property_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_set_node_property_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,char const *,svn_string_t const *)""'");
}
}
if (arg1) (arg1)->set_node_property = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_set_node_property_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *,char const *,svn_string_t const *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_set_node_property_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *,char const *,svn_string_t const *)) ((arg1)->set_node_property);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_delete_node_property_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(void *,char const *) = (svn_error_t *(*)(void *,char const *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_delete_node_property_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_delete_node_property_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,char const *)""'");
}
}
if (arg1) (arg1)->delete_node_property = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_delete_node_property_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *,char const *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_delete_node_property_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *,char const *)) ((arg1)->delete_node_property);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_remove_node_props_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(void *) = (svn_error_t *(*)(void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_remove_node_props_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_remove_node_props_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *)""'");
}
}
if (arg1) (arg1)->remove_node_props = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_remove_node_props_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_remove_node_props_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *)) ((arg1)->remove_node_props);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_set_fulltext_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(svn_stream_t **,void *) = (svn_error_t *(*)(svn_stream_t **,void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_set_fulltext_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_svn_stream_t_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_set_fulltext_set" "', argument " "2"" of type '" "svn_error_t *(*)(svn_stream_t **,void *)""'");
}
}
if (arg1) (arg1)->set_fulltext = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_set_fulltext_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(svn_stream_t **,void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_set_fulltext_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(svn_stream_t **,void *)) ((arg1)->set_fulltext);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_svn_stream_t_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_apply_textdelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(svn_txdelta_window_handler_t *,void **,void *) = (svn_error_t *(*)(svn_txdelta_window_handler_t *,void **,void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_apply_textdelta_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_apply_textdelta_set" "', argument " "2"" of type '" "svn_error_t *(*)(svn_txdelta_window_handler_t *,void **,void *)""'");
}
}
if (arg1) (arg1)->apply_textdelta = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_apply_textdelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(svn_txdelta_window_handler_t *,void **,void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_apply_textdelta_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(svn_txdelta_window_handler_t *,void **,void *)) ((arg1)->apply_textdelta);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_close_node_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(void *) = (svn_error_t *(*)(void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_close_node_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_close_node_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *)""'");
}
}
if (arg1) (arg1)->close_node = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_close_node_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_close_node_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *)) ((arg1)->close_node);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_close_revision_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_error_t *(*arg2)(void *) = (svn_error_t *(*)(void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_t_close_revision_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parse_fns2_t_close_revision_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *)""'");
}
}
if (arg1) (arg1)->close_revision = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_t_close_revision_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parse_fns2_t_close_revision_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *)) ((arg1)->close_revision);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *svn_repos_parse_fns2_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_svn_repos_parse_fns2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_dumpstream2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_stream_t *arg1 = (svn_stream_t *) 0 ;
svn_repos_parse_fns2_t *arg2 = (svn_repos_parse_fns2_t *) 0 ;
void *arg3 = (void *) 0 ;
svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
void *arg5 = (void *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_parse_dumpstream2",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = svn_swig_py_make_stream (obj0, _global_pool);
}
{
arg2 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj2 == Py_None) {
arg3 = NULL;
} else if (SWIG_ConvertPtr(obj2, (void **) &arg3, 0, 0) == -1) {
arg3 = (void *) obj2;
PyErr_Clear();
}
}
{
arg4 = svn_swig_py_cancel_func;
arg5 = obj3; /* our function is the baton. */
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_dumpstream2(arg1,(struct svn_repos_parse_fns2_t const *)arg2,arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_fs_build_parser3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t **arg1 = (svn_repos_parse_fns2_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
svn_boolean_t arg4 ;
svn_boolean_t arg5 ;
enum svn_repos_load_uuid arg6 ;
char *arg7 = (char *) 0 ;
svn_repos_notify_func_t arg8 = (svn_repos_notify_func_t) 0 ;
void *arg9 = (void *) 0 ;
apr_pool_t *arg10 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_repos_parse_fns2_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg10 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOOOzOO|O:svn_repos_get_fs_build_parser3",&obj0,&obj1,&obj2,&obj3,&arg7,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
arg5 = (svn_boolean_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg6 = (enum svn_repos_load_uuid)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
svn_repos_notify_func_t * tmp =
svn_swig_MustGetPtr(obj5, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj5);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg8 = *tmp;
}
{
if (obj6 == Py_None) {
arg9 = NULL;
} else if (SWIG_ConvertPtr(obj6, (void **) &arg9, 0, 0) == -1) {
arg9 = (void *) obj6;
PyErr_Clear();
}
}
if (obj7) {
/* Verify that the user supplied a valid pool */
if (obj7 != Py_None && obj7 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
SWIG_arg_fail(svn_argnum_obj7);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_fs_build_parser3((struct svn_repos_parse_fns2_t const **)arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7,arg8,arg9,arg10);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns2_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_fs_build_parser2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t **arg1 = (svn_repos_parse_fns2_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
svn_boolean_t arg4 ;
enum svn_repos_load_uuid arg5 ;
svn_stream_t *arg6 = (svn_stream_t *) 0 ;
char *arg7 = (char *) 0 ;
apr_pool_t *arg8 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_repos_parse_fns2_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg8 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOOOz|O:svn_repos_get_fs_build_parser2",&obj0,&obj1,&obj2,&obj3,&arg7,&obj5)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
arg5 = (enum svn_repos_load_uuid)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg6 = svn_swig_py_make_stream (obj3, _global_pool);
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_fs_build_parser2((struct svn_repos_parse_fns2_t const **)arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7,arg8);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns2_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_new_revision_record_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(void **,apr_hash_t *,void *,apr_pool_t *) = (svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_new_revision_record_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_new_revision_record_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->new_revision_record = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_new_revision_record_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void **,apr_hash_t *,void *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_new_revision_record_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)) ((arg1)->new_revision_record);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_uuid_record_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(char const *,void *,apr_pool_t *) = (svn_error_t *(*)(char const *,void *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_uuid_record_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_uuid_record_set" "', argument " "2"" of type '" "svn_error_t *(*)(char const *,void *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->uuid_record = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_uuid_record_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(char const *,void *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_uuid_record_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(char const *,void *,apr_pool_t *)) ((arg1)->uuid_record);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_new_node_record_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(void **,apr_hash_t *,void *,apr_pool_t *) = (svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_new_node_record_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_new_node_record_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->new_node_record = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_new_node_record_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void **,apr_hash_t *,void *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_new_node_record_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)) ((arg1)->new_node_record);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_set_revision_property_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(void *,char const *,svn_string_t const *) = (svn_error_t *(*)(void *,char const *,svn_string_t const *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_set_revision_property_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_set_revision_property_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,char const *,svn_string_t const *)""'");
}
}
if (arg1) (arg1)->set_revision_property = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_set_revision_property_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *,char const *,svn_string_t const *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_set_revision_property_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *,char const *,svn_string_t const *)) ((arg1)->set_revision_property);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_set_node_property_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(void *,char const *,svn_string_t const *) = (svn_error_t *(*)(void *,char const *,svn_string_t const *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_set_node_property_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_set_node_property_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *,char const *,svn_string_t const *)""'");
}
}
if (arg1) (arg1)->set_node_property = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_set_node_property_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *,char const *,svn_string_t const *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_set_node_property_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *,char const *,svn_string_t const *)) ((arg1)->set_node_property);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_remove_node_props_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(void *) = (svn_error_t *(*)(void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_remove_node_props_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_remove_node_props_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *)""'");
}
}
if (arg1) (arg1)->remove_node_props = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_remove_node_props_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_remove_node_props_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *)) ((arg1)->remove_node_props);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_set_fulltext_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(svn_stream_t **,void *) = (svn_error_t *(*)(svn_stream_t **,void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_set_fulltext_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_svn_stream_t_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_set_fulltext_set" "', argument " "2"" of type '" "svn_error_t *(*)(svn_stream_t **,void *)""'");
}
}
if (arg1) (arg1)->set_fulltext = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_set_fulltext_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(svn_stream_t **,void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_set_fulltext_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(svn_stream_t **,void *)) ((arg1)->set_fulltext);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_svn_stream_t_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_close_node_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(void *) = (svn_error_t *(*)(void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_close_node_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_close_node_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *)""'");
}
}
if (arg1) (arg1)->close_node = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_close_node_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_close_node_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *)) ((arg1)->close_node);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_close_revision_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
svn_error_t *(*arg2)(void *) = (svn_error_t *(*)(void *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parser_fns_t_close_revision_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_repos_parser_fns_t_close_revision_set" "', argument " "2"" of type '" "svn_error_t *(*)(void *)""'");
}
}
if (arg1) (arg1)->close_revision = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parser_fns_t_close_revision_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t *arg1 = (svn_repos_parser_fns_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_repos_parser_fns_t_close_revision_get",&obj0)) SWIG_fail;
{
arg1 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void *)) ((arg1)->close_revision);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *svn_repos_parser_fns_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_svn_repos_parse_fns_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_dumpstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_stream_t *arg1 = (svn_stream_t *) 0 ;
svn_repos_parser_fns_t *arg2 = (svn_repos_parser_fns_t *) 0 ;
void *arg3 = (void *) 0 ;
svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
void *arg5 = (void *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_parse_dumpstream",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = svn_swig_py_make_stream (obj0, _global_pool);
}
{
arg2 = (svn_repos_parser_fns_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_parse_fns_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj2 == Py_None) {
arg3 = NULL;
} else if (SWIG_ConvertPtr(obj2, (void **) &arg3, 0, 0) == -1) {
arg3 = (void *) obj2;
PyErr_Clear();
}
}
{
arg4 = svn_swig_py_cancel_func;
arg5 = obj3; /* our function is the baton. */
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_dumpstream(arg1,(struct svn_repos_parse_fns_t const *)arg2,arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_get_fs_build_parser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parser_fns_t **arg1 = (svn_repos_parser_fns_t **) 0 ;
void **arg2 = (void **) 0 ;
svn_repos_t *arg3 = (svn_repos_t *) 0 ;
svn_boolean_t arg4 ;
enum svn_repos_load_uuid arg5 ;
svn_stream_t *arg6 = (svn_stream_t *) 0 ;
char *arg7 = (char *) 0 ;
apr_pool_t *arg8 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_repos_parser_fns_t *temp1 ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg8 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOOOz|O:svn_repos_get_fs_build_parser",&obj0,&obj1,&obj2,&obj3,&arg7,&obj5)) SWIG_fail;
{
arg3 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg4 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
arg5 = (enum svn_repos_load_uuid)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
arg6 = svn_swig_py_make_stream (obj3, _global_pool);
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_get_fs_build_parser((struct svn_repos_parse_fns_t const **)arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7,arg8);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_repos_parse_fns_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_authz_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_authz_t **arg1 = (svn_authz_t **) 0 ;
char *arg2 = (char *) 0 ;
svn_boolean_t arg3 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_authz_t *temp1 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"sO|O:svn_repos_authz_read",&arg2,&obj1,&obj2)) SWIG_fail;
{
arg3 = (svn_boolean_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
if (obj2) {
/* Verify that the user supplied a valid pool */
if (obj2 != Py_None && obj2 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
SWIG_arg_fail(svn_argnum_obj2);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_authz_read(arg1,(char const *)arg2,arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_authz_t,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_authz_check_access(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_authz_t *arg1 = (svn_authz_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
svn_repos_authz_access_t arg5 ;
svn_boolean_t *arg6 = (svn_boolean_t *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_boolean_t temp6 ;
int res6 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg6 = &temp6;
if (!PyArg_ParseTuple(args,(char *)"OsszO|O:svn_repos_authz_check_access",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) SWIG_fail;
{
arg1 = (svn_authz_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_authz_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg5 = (svn_repos_authz_access_t)SWIG_As_long (obj4);
if (SWIG_arg_fail(svn_argnum_obj4)) {
SWIG_fail;
}
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_authz_check_access(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
if (SWIG_IsTmpObj(res6)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
} else {
int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_check_revision_access(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_revision_access_level_t *arg1 = (svn_repos_revision_access_level_t *) 0 ;
svn_repos_t *arg2 = (svn_repos_t *) 0 ;
svn_revnum_t arg3 ;
svn_repos_authz_func_t arg4 = (svn_repos_authz_func_t) 0 ;
void *arg5 = (void *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_repos_check_revision_access",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = (svn_repos_revision_access_level_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_revision_access_level_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (svn_repos_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_repos_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (svn_revnum_t)SWIG_As_long (obj2);
if (SWIG_arg_fail(svn_argnum_obj2)) {
SWIG_fail;
}
}
{
/* FIXME: Handle the NULL case. */
arg4 = svn_swig_py_repos_authz_func;
arg5 = obj3;
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_check_revision_access(arg1,arg2,arg3,arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_remember_client_capabilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_t *arg1 = (svn_repos_t *) 0 ;
apr_array_header_t *arg2 = (apr_array_header_t *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_remember_client_capabilities",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg2 = (apr_array_header_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_remember_client_capabilities(arg1,(apr_array_header_t const *)arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *svn_repos_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_svn_repos_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *svn_authz_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_svn_authz_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_new_revision_record(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
void **arg2 = (void **) 0 ;
apr_hash_t *arg3 = (apr_hash_t *) 0 ;
void *arg4 = (void *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_parse_fns2_invoke_new_revision_record",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (apr_hash_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj2 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj2, (void **) &arg4, 0, 0) == -1) {
arg4 = (void *) obj2;
PyErr_Clear();
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_new_revision_record(arg1,arg2,arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_uuid_record(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
char *arg2 = (char *) 0 ;
void *arg3 = (void *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OzO|O:svn_repos_parse_fns2_invoke_uuid_record",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj2 == Py_None) {
arg3 = NULL;
} else if (SWIG_ConvertPtr(obj2, (void **) &arg3, 0, 0) == -1) {
arg3 = (void *) obj2;
PyErr_Clear();
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_uuid_record(arg1,(char const *)arg2,arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_new_node_record(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
void **arg2 = (void **) 0 ;
apr_hash_t *arg3 = (apr_hash_t *) 0 ;
void *arg4 = (void *) 0 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
void *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_parse_fns2_invoke_new_node_record",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (apr_hash_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj2 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj2, (void **) &arg4, 0, 0) == -1) {
arg4 = (void *) obj2;
PyErr_Clear();
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_new_node_record(arg1,arg2,arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_set_revision_property(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
void *arg2 = (void *) 0 ;
char *arg3 = (char *) 0 ;
svn_string_t *arg4 = (svn_string_t *) 0 ;
svn_string_t value4 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOsO:svn_repos_parse_fns2_invoke_set_revision_property",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
if (obj3 == Py_None)
arg4 = NULL;
else {
if (!PyString_Check(obj3)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value4.data = PyString_AS_STRING(obj3);
value4.len = PyString_GET_SIZE(obj3);
arg4 = &value4;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_set_revision_property(arg1,arg2,(char const *)arg3,(struct svn_string_t const *)arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_set_node_property(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
void *arg2 = (void *) 0 ;
char *arg3 = (char *) 0 ;
svn_string_t *arg4 = (svn_string_t *) 0 ;
svn_string_t value4 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOsO:svn_repos_parse_fns2_invoke_set_node_property",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
if (obj3 == Py_None)
arg4 = NULL;
else {
if (!PyString_Check(obj3)) {
PyErr_SetString(PyExc_TypeError, "not a string");
SWIG_fail;
}
value4.data = PyString_AS_STRING(obj3);
value4.len = PyString_GET_SIZE(obj3);
arg4 = &value4;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_set_node_property(arg1,arg2,(char const *)arg3,(struct svn_string_t const *)arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_delete_node_property(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
void *arg2 = (void *) 0 ;
char *arg3 = (char *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOs:svn_repos_parse_fns2_invoke_delete_node_property",&obj0,&obj1,&arg3)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_delete_node_property(arg1,arg2,(char const *)arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_remove_node_props(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
void *arg2 = (void *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_remove_node_props",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_remove_node_props(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_set_fulltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_stream_t **arg2 = (svn_stream_t **) 0 ;
void *arg3 = (void *) 0 ;
svn_stream_t *temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_set_fulltext",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg3 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg3, 0, 0) == -1) {
arg3 = (void *) obj1;
PyErr_Clear();
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_set_fulltext(arg1,arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_stream_t,
_global_py_pool, args))
;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_apply_textdelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
svn_txdelta_window_handler_t *arg2 = (svn_txdelta_window_handler_t *) 0 ;
void **arg3 = (void **) 0 ;
void *arg4 = (void *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
void *temp3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
{
if (_global_pool == NULL)
{
if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
}
arg2 = (svn_txdelta_window_handler_t *) apr_pcalloc(_global_pool, sizeof(svn_txdelta_window_handler_t));
if (arg2 == NULL) SWIG_fail;
}
arg3 = &temp3;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_apply_textdelta",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg4, 0, 0) == -1) {
arg4 = (void *) obj1;
PyErr_Clear();
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_apply_textdelta(arg1,arg2,arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg2, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_close_node(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
void *arg2 = (void *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_close_node",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_close_node(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_parse_fns2_invoke_close_revision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_parse_fns2_t *arg1 = (svn_repos_parse_fns2_t *) 0 ;
void *arg2 = (void *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_repos_parse_fns2_invoke_close_revision",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_repos_parse_fns2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_repos_parse_fns2_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_parse_fns2_invoke_close_revision(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_invoke_authz_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_authz_func_t arg1 = (svn_repos_authz_func_t) 0 ;
svn_boolean_t *arg2 = (svn_boolean_t *) 0 ;
svn_fs_root_t *arg3 = (svn_fs_root_t *) 0 ;
char *arg4 = (char *) 0 ;
void *arg5 = (void *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_boolean_t temp2 ;
int res2 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_repos_invoke_authz_func",&obj0,&obj1,&arg4,&obj3,&obj4)) SWIG_fail;
{
svn_repos_authz_func_t * tmp =
svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg1 = *tmp;
}
{
arg3 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj3 == Py_None) {
arg5 = NULL;
} else if (SWIG_ConvertPtr(obj3, (void **) &arg5, 0, 0) == -1) {
arg5 = (void *) obj3;
PyErr_Clear();
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_invoke_authz_func(arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
if (SWIG_IsTmpObj(res2)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
} else {
int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_invoke_authz_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_authz_callback_t arg1 = (svn_repos_authz_callback_t) 0 ;
svn_repos_authz_access_t arg2 ;
svn_boolean_t *arg3 = (svn_boolean_t *) 0 ;
svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
char *arg5 = (char *) 0 ;
void *arg6 = (void *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
svn_boolean_t temp3 ;
int res3 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg3 = &temp3;
if (!PyArg_ParseTuple(args,(char *)"OOOsO|O:svn_repos_invoke_authz_callback",&obj0,&obj1,&obj2,&arg5,&obj4,&obj5)) SWIG_fail;
{
svn_repos_authz_callback_t * tmp =
svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg1 = *tmp;
}
{
arg2 = (svn_repos_authz_access_t)SWIG_As_long (obj1);
if (SWIG_arg_fail(svn_argnum_obj1)) {
SWIG_fail;
}
}
{
arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj4 == Py_None) {
arg6 = NULL;
} else if (SWIG_ConvertPtr(obj4, (void **) &arg6, 0, 0) == -1) {
arg6 = (void *) obj4;
PyErr_Clear();
}
}
if (obj5) {
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_invoke_authz_callback(arg1,arg2,arg3,arg4,(char const *)arg5,arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
if (SWIG_IsTmpObj(res3)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
} else {
int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_invoke_file_rev_handler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_file_rev_handler_t arg1 = (svn_repos_file_rev_handler_t) 0 ;
void *arg2 = (void *) 0 ;
char *arg3 = (char *) 0 ;
svn_revnum_t arg4 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
svn_txdelta_window_handler_t *arg6 = (svn_txdelta_window_handler_t *) 0 ;
void **arg7 = (void **) 0 ;
apr_array_header_t *arg8 = (apr_array_header_t *) 0 ;
apr_pool_t *arg9 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
void *temp7 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg9 = _global_pool;
{
if (_global_pool == NULL)
{
if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
}
arg6 = (svn_txdelta_window_handler_t *) apr_pcalloc(_global_pool, sizeof(svn_txdelta_window_handler_t));
if (arg6 == NULL) SWIG_fail;
}
arg7 = &temp7;
if (!PyArg_ParseTuple(args,(char *)"OOsOOO|O:svn_repos_invoke_file_rev_handler",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
svn_repos_file_rev_handler_t * tmp =
svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg1 = *tmp;
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
{
arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_apr_hash_t, svn_argnum_obj4);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg8 = (apr_array_header_t *)svn_swig_MustGetPtr(obj5, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj5);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj6) {
/* Verify that the user supplied a valid pool */
if (obj6 != Py_None && obj6 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj6);
SWIG_arg_fail(svn_argnum_obj6);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_invoke_file_rev_handler(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg6, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
_global_py_pool, args))
;
}
{
resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg7, SWIGTYPE_p_void,
_global_py_pool, args))
;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_invoke_notify_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_notify_func_t arg1 = (svn_repos_notify_func_t) 0 ;
void *arg2 = (void *) 0 ;
svn_repos_notify_t *arg3 = (svn_repos_notify_t *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_repos_invoke_notify_func",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
svn_repos_notify_func_t * tmp =
svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, svn_argnum_obj0);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg1 = *tmp;
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
arg3 = (svn_repos_notify_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_repos_notify_t, svn_argnum_obj2);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
svn_repos_invoke_notify_func(arg1,arg2,(struct svn_repos_notify_t const *)arg3,arg4);
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_Py_Void();
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_repos_invoke_history_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_repos_history_func_t arg1 = (svn_repos_history_func_t) 0 ;
void *arg2 = (void *) 0 ;
char *arg3 = (char *) 0 ;
svn_revnum_t arg4 ;
apr_pool_t *arg5 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg5 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_repos_invoke_history_func",&obj0,&obj1,&arg3,&obj3,&obj4)) SWIG_fail;
{
svn_repos_history_func_t * tmp =
svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
if (tmp == NULL || PyErr_Occurred()) {
SWIG_fail;
}
arg1 = *tmp;
}
{
if (obj1 == Py_None) {
arg2 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
arg2 = (void *) obj1;
PyErr_Clear();
}
}
{
arg4 = (svn_revnum_t)SWIG_As_long (obj3);
if (SWIG_arg_fail(svn_argnum_obj3)) {
SWIG_fail;
}
}
if (obj4) {
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_repos_invoke_history_func(arg1,arg2,(char const *)arg3,arg4,arg5);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
SWIG_fail;
}
Py_INCREF(Py_None);
resultobj = Py_None;
}
{
Py_XDECREF(_global_py_pool);
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *svn_repos_authz_func_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *svn_repos_authz_callback_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *svn_repos_file_rev_handler_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *svn_repos_notify_func_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *svn_repos_history_func_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
static PyMethodDef SwigMethods[] = {
{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
{ (char *)"svn_repos_version", _wrap_svn_repos_version, METH_VARARGS, (char *)"svn_repos_version() -> svn_version_t"},
{ (char *)"svn_repos_notify_t_action_set", _wrap_svn_repos_notify_t_action_set, METH_VARARGS, (char *)"svn_repos_notify_t_action_set(svn_repos_notify_t self, svn_repos_notify_action_t action)"},
{ (char *)"svn_repos_notify_t_action_get", _wrap_svn_repos_notify_t_action_get, METH_VARARGS, (char *)"svn_repos_notify_t_action_get(svn_repos_notify_t self) -> svn_repos_notify_action_t"},
{ (char *)"svn_repos_notify_t_revision_set", _wrap_svn_repos_notify_t_revision_set, METH_VARARGS, (char *)"svn_repos_notify_t_revision_set(svn_repos_notify_t self, svn_revnum_t revision)"},
{ (char *)"svn_repos_notify_t_revision_get", _wrap_svn_repos_notify_t_revision_get, METH_VARARGS, (char *)"svn_repos_notify_t_revision_get(svn_repos_notify_t self) -> svn_revnum_t"},
{ (char *)"svn_repos_notify_t_warning_str_set", _wrap_svn_repos_notify_t_warning_str_set, METH_VARARGS, (char *)"svn_repos_notify_t_warning_str_set(svn_repos_notify_t self, char warning_str)"},
{ (char *)"svn_repos_notify_t_warning_str_get", _wrap_svn_repos_notify_t_warning_str_get, METH_VARARGS, (char *)"svn_repos_notify_t_warning_str_get(svn_repos_notify_t self) -> char"},
{ (char *)"svn_repos_notify_t_warning_set", _wrap_svn_repos_notify_t_warning_set, METH_VARARGS, (char *)"svn_repos_notify_t_warning_set(svn_repos_notify_t self, svn_repos_notify_warning_t warning)"},
{ (char *)"svn_repos_notify_t_warning_get", _wrap_svn_repos_notify_t_warning_get, METH_VARARGS, (char *)"svn_repos_notify_t_warning_get(svn_repos_notify_t self) -> svn_repos_notify_warning_t"},
{ (char *)"svn_repos_notify_t_shard_set", _wrap_svn_repos_notify_t_shard_set, METH_VARARGS, (char *)"svn_repos_notify_t_shard_set(svn_repos_notify_t self, apr_int64_t shard)"},
{ (char *)"svn_repos_notify_t_shard_get", _wrap_svn_repos_notify_t_shard_get, METH_VARARGS, (char *)"svn_repos_notify_t_shard_get(svn_repos_notify_t self) -> apr_int64_t"},
{ (char *)"svn_repos_notify_t_new_revision_set", _wrap_svn_repos_notify_t_new_revision_set, METH_VARARGS, (char *)"svn_repos_notify_t_new_revision_set(svn_repos_notify_t self, svn_revnum_t new_revision)"},
{ (char *)"svn_repos_notify_t_new_revision_get", _wrap_svn_repos_notify_t_new_revision_get, METH_VARARGS, (char *)"svn_repos_notify_t_new_revision_get(svn_repos_notify_t self) -> svn_revnum_t"},
{ (char *)"svn_repos_notify_t_old_revision_set", _wrap_svn_repos_notify_t_old_revision_set, METH_VARARGS, (char *)"svn_repos_notify_t_old_revision_set(svn_repos_notify_t self, svn_revnum_t old_revision)"},
{ (char *)"svn_repos_notify_t_old_revision_get", _wrap_svn_repos_notify_t_old_revision_get, METH_VARARGS, (char *)"svn_repos_notify_t_old_revision_get(svn_repos_notify_t self) -> svn_revnum_t"},
{ (char *)"svn_repos_notify_t_node_action_set", _wrap_svn_repos_notify_t_node_action_set, METH_VARARGS, (char *)"svn_repos_notify_t_node_action_set(svn_repos_notify_t self, enum svn_node_action node_action)"},
{ (char *)"svn_repos_notify_t_node_action_get", _wrap_svn_repos_notify_t_node_action_get, METH_VARARGS, (char *)"svn_repos_notify_t_node_action_get(svn_repos_notify_t self) -> enum svn_node_action"},
{ (char *)"svn_repos_notify_t_path_set", _wrap_svn_repos_notify_t_path_set, METH_VARARGS, (char *)"svn_repos_notify_t_path_set(svn_repos_notify_t self, char path)"},
{ (char *)"svn_repos_notify_t_path_get", _wrap_svn_repos_notify_t_path_get, METH_VARARGS, (char *)"svn_repos_notify_t_path_get(svn_repos_notify_t self) -> char"},
{ (char *)"svn_repos_notify_t_swigregister", svn_repos_notify_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_notify_create", _wrap_svn_repos_notify_create, METH_VARARGS, (char *)"svn_repos_notify_create(svn_repos_notify_action_t action, apr_pool_t result_pool) -> svn_repos_notify_t"},
{ (char *)"svn_repos_find_root_path", _wrap_svn_repos_find_root_path, METH_VARARGS, (char *)"svn_repos_find_root_path(char path, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_open2", _wrap_svn_repos_open2, METH_VARARGS, (char *)"svn_repos_open2(char path, apr_hash_t fs_config, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_open", _wrap_svn_repos_open, METH_VARARGS, (char *)"svn_repos_open(char path, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_create", _wrap_svn_repos_create, METH_VARARGS, (char *)"\n"
"svn_repos_create(char path, char unused_1, char unused_2, apr_hash_t config, \n"
" apr_hash_t fs_config, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_upgrade2", _wrap_svn_repos_upgrade2, METH_VARARGS, (char *)"\n"
"svn_repos_upgrade2(char path, svn_boolean_t nonblocking, svn_repos_notify_func_t notify_func, \n"
" void notify_baton, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_upgrade", _wrap_svn_repos_upgrade, METH_VARARGS, (char *)"\n"
"svn_repos_upgrade(char path, svn_boolean_t nonblocking, svn_error_t start_callback, \n"
" void start_callback_baton, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_delete", _wrap_svn_repos_delete, METH_VARARGS, (char *)"svn_repos_delete(char path, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_has_capability", _wrap_svn_repos_has_capability, METH_VARARGS, (char *)"svn_repos_has_capability(svn_repos_t repos, char capability, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_fs", _wrap_svn_repos_fs, METH_VARARGS, (char *)"svn_repos_fs(svn_repos_t repos) -> svn_fs_t"},
{ (char *)"svn_repos_hotcopy", _wrap_svn_repos_hotcopy, METH_VARARGS, (char *)"\n"
"svn_repos_hotcopy(char src_path, char dst_path, svn_boolean_t clean_logs, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_pack2", _wrap_svn_repos_fs_pack2, METH_VARARGS, (char *)"\n"
"svn_repos_fs_pack2(svn_repos_t repos, svn_repos_notify_func_t notify_func, \n"
" void notify_baton, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_pack", _wrap_svn_repos_fs_pack, METH_VARARGS, (char *)"\n"
"svn_repos_fs_pack(svn_repos_t repos, svn_fs_pack_notify_t notify_func, \n"
" void notify_baton, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_recover4", _wrap_svn_repos_recover4, METH_VARARGS, (char *)"\n"
"svn_repos_recover4(char path, svn_boolean_t nonblocking, svn_repos_notify_func_t notify_func, \n"
" void notify_baton, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_recover3", _wrap_svn_repos_recover3, METH_VARARGS, (char *)"\n"
"svn_repos_recover3(char path, svn_boolean_t nonblocking, svn_error_t start_callback, \n"
" void start_callback_baton, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_recover2", _wrap_svn_repos_recover2, METH_VARARGS, (char *)"\n"
"svn_repos_recover2(char path, svn_boolean_t nonblocking, svn_error_t start_callback, \n"
" void start_callback_baton, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_recover", _wrap_svn_repos_recover, METH_VARARGS, (char *)"svn_repos_recover(char path, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_db_logfiles", _wrap_svn_repos_db_logfiles, METH_VARARGS, (char *)"svn_repos_db_logfiles(char path, svn_boolean_t only_unused, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_path", _wrap_svn_repos_path, METH_VARARGS, (char *)"svn_repos_path(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_db_env", _wrap_svn_repos_db_env, METH_VARARGS, (char *)"svn_repos_db_env(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_conf_dir", _wrap_svn_repos_conf_dir, METH_VARARGS, (char *)"svn_repos_conf_dir(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_svnserve_conf", _wrap_svn_repos_svnserve_conf, METH_VARARGS, (char *)"svn_repos_svnserve_conf(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_lock_dir", _wrap_svn_repos_lock_dir, METH_VARARGS, (char *)"svn_repos_lock_dir(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_db_lockfile", _wrap_svn_repos_db_lockfile, METH_VARARGS, (char *)"svn_repos_db_lockfile(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_db_logs_lockfile", _wrap_svn_repos_db_logs_lockfile, METH_VARARGS, (char *)"svn_repos_db_logs_lockfile(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_hook_dir", _wrap_svn_repos_hook_dir, METH_VARARGS, (char *)"svn_repos_hook_dir(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_start_commit_hook", _wrap_svn_repos_start_commit_hook, METH_VARARGS, (char *)"svn_repos_start_commit_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_pre_commit_hook", _wrap_svn_repos_pre_commit_hook, METH_VARARGS, (char *)"svn_repos_pre_commit_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_post_commit_hook", _wrap_svn_repos_post_commit_hook, METH_VARARGS, (char *)"svn_repos_post_commit_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_pre_revprop_change_hook", _wrap_svn_repos_pre_revprop_change_hook, METH_VARARGS, (char *)"svn_repos_pre_revprop_change_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_post_revprop_change_hook", _wrap_svn_repos_post_revprop_change_hook, METH_VARARGS, (char *)"svn_repos_post_revprop_change_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_pre_lock_hook", _wrap_svn_repos_pre_lock_hook, METH_VARARGS, (char *)"svn_repos_pre_lock_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_post_lock_hook", _wrap_svn_repos_post_lock_hook, METH_VARARGS, (char *)"svn_repos_post_lock_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_pre_unlock_hook", _wrap_svn_repos_pre_unlock_hook, METH_VARARGS, (char *)"svn_repos_pre_unlock_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_post_unlock_hook", _wrap_svn_repos_post_unlock_hook, METH_VARARGS, (char *)"svn_repos_post_unlock_hook(svn_repos_t repos, apr_pool_t pool) -> char"},
{ (char *)"svn_repos_begin_report2", _wrap_svn_repos_begin_report2, METH_VARARGS, (char *)"\n"
"svn_repos_begin_report2(svn_revnum_t revnum, svn_repos_t repos, char fs_base, \n"
" char target, char tgt_path, svn_boolean_t text_deltas, \n"
" svn_depth_t depth, svn_boolean_t ignore_ancestry, \n"
" svn_boolean_t send_copyfrom_args, \n"
" svn_delta_editor_t editor, void edit_baton, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_begin_report", _wrap_svn_repos_begin_report, METH_VARARGS, (char *)"\n"
"svn_repos_begin_report(svn_revnum_t revnum, char username, svn_repos_t repos, \n"
" char fs_base, char target, char tgt_path, \n"
" svn_boolean_t text_deltas, svn_boolean_t recurse, \n"
" svn_boolean_t ignore_ancestry, svn_delta_editor_t editor, \n"
" void edit_baton, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_set_path3", _wrap_svn_repos_set_path3, METH_VARARGS, (char *)"\n"
"svn_repos_set_path3(void report_baton, char path, svn_revnum_t revision, \n"
" svn_depth_t depth, svn_boolean_t start_empty, \n"
" char lock_token, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_set_path2", _wrap_svn_repos_set_path2, METH_VARARGS, (char *)"\n"
"svn_repos_set_path2(void report_baton, char path, svn_revnum_t revision, \n"
" svn_boolean_t start_empty, char lock_token, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_set_path", _wrap_svn_repos_set_path, METH_VARARGS, (char *)"\n"
"svn_repos_set_path(void report_baton, char path, svn_revnum_t revision, \n"
" svn_boolean_t start_empty, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_link_path3", _wrap_svn_repos_link_path3, METH_VARARGS, (char *)"\n"
"svn_repos_link_path3(void report_baton, char path, char link_path, svn_revnum_t revision, \n"
" svn_depth_t depth, svn_boolean_t start_empty, \n"
" char lock_token, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_link_path2", _wrap_svn_repos_link_path2, METH_VARARGS, (char *)"\n"
"svn_repos_link_path2(void report_baton, char path, char link_path, svn_revnum_t revision, \n"
" svn_boolean_t start_empty, \n"
" char lock_token, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_link_path", _wrap_svn_repos_link_path, METH_VARARGS, (char *)"\n"
"svn_repos_link_path(void report_baton, char path, char link_path, svn_revnum_t revision, \n"
" svn_boolean_t start_empty, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_delete_path", _wrap_svn_repos_delete_path, METH_VARARGS, (char *)"svn_repos_delete_path(void report_baton, char path, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_finish_report", _wrap_svn_repos_finish_report, METH_VARARGS, (char *)"svn_repos_finish_report(void report_baton, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_abort_report", _wrap_svn_repos_abort_report, METH_VARARGS, (char *)"svn_repos_abort_report(void report_baton, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_dir_delta2", _wrap_svn_repos_dir_delta2, METH_VARARGS, (char *)"\n"
"svn_repos_dir_delta2(svn_fs_root_t src_root, char src_parent_dir, char src_entry, \n"
" svn_fs_root_t tgt_root, char tgt_path, \n"
" svn_delta_editor_t editor, void edit_baton, \n"
" svn_repos_authz_func_t authz_read_func, svn_boolean_t text_deltas, \n"
" svn_depth_t depth, svn_boolean_t entry_props, \n"
" svn_boolean_t ignore_ancestry, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_dir_delta", _wrap_svn_repos_dir_delta, METH_VARARGS, (char *)"\n"
"svn_repos_dir_delta(svn_fs_root_t src_root, char src_parent_dir, char src_entry, \n"
" svn_fs_root_t tgt_root, char tgt_path, \n"
" svn_delta_editor_t editor, void edit_baton, \n"
" svn_repos_authz_func_t authz_read_func, svn_boolean_t text_deltas, \n"
" svn_boolean_t recurse, \n"
" svn_boolean_t entry_props, svn_boolean_t ignore_ancestry, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_replay2", _wrap_svn_repos_replay2, METH_VARARGS, (char *)"\n"
"svn_repos_replay2(svn_fs_root_t root, char base_dir, svn_revnum_t low_water_mark, \n"
" svn_boolean_t send_deltas, svn_delta_editor_t editor, \n"
" void edit_baton, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_replay", _wrap_svn_repos_replay, METH_VARARGS, (char *)"\n"
"svn_repos_replay(svn_fs_root_t root, svn_delta_editor_t editor, void edit_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_commit_editor5", _wrap_svn_repos_get_commit_editor5, METH_VARARGS, (char *)"\n"
"svn_repos_get_commit_editor5(svn_repos_t repos, svn_fs_txn_t txn, char repos_url, \n"
" char base_path, apr_hash_t revprop_table, svn_commit_callback2_t callback, \n"
" svn_repos_authz_callback_t authz_callback, \n"
" void authz_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_commit_editor4", _wrap_svn_repos_get_commit_editor4, METH_VARARGS, (char *)"\n"
"svn_repos_get_commit_editor4(svn_repos_t repos, svn_fs_txn_t txn, char repos_url, \n"
" char base_path, char user, char log_msg, svn_commit_callback2_t callback, \n"
" svn_repos_authz_callback_t authz_callback, \n"
" void authz_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_commit_editor3", _wrap_svn_repos_get_commit_editor3, METH_VARARGS, (char *)"\n"
"svn_repos_get_commit_editor3(svn_repos_t repos, svn_fs_txn_t txn, char repos_url, \n"
" char base_path, char user, char log_msg, svn_commit_callback_t callback, \n"
" svn_repos_authz_callback_t authz_callback, \n"
" void authz_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_commit_editor2", _wrap_svn_repos_get_commit_editor2, METH_VARARGS, (char *)"\n"
"svn_repos_get_commit_editor2(svn_repos_t repos, svn_fs_txn_t txn, char repos_url, \n"
" char base_path, char user, char log_msg, svn_commit_callback_t callback, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_commit_editor", _wrap_svn_repos_get_commit_editor, METH_VARARGS, (char *)"\n"
"svn_repos_get_commit_editor(svn_repos_t repos, char repos_url, char base_path, \n"
" char user, char log_msg, svn_commit_callback_t callback, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_dated_revision", _wrap_svn_repos_dated_revision, METH_VARARGS, (char *)"svn_repos_dated_revision(svn_repos_t repos, apr_time_t tm, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_get_committed_info", _wrap_svn_repos_get_committed_info, METH_VARARGS, (char *)"svn_repos_get_committed_info(svn_fs_root_t root, char path, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_stat", _wrap_svn_repos_stat, METH_VARARGS, (char *)"svn_repos_stat(svn_fs_root_t root, char path, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_deleted_rev", _wrap_svn_repos_deleted_rev, METH_VARARGS, (char *)"\n"
"svn_repos_deleted_rev(svn_fs_t fs, char path, svn_revnum_t start, svn_revnum_t end, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_history2", _wrap_svn_repos_history2, METH_VARARGS, (char *)"\n"
"svn_repos_history2(svn_fs_t fs, char path, svn_repos_history_func_t history_func, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" svn_revnum_t start, svn_revnum_t end, \n"
" svn_boolean_t cross_copies, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_history", _wrap_svn_repos_history, METH_VARARGS, (char *)"\n"
"svn_repos_history(svn_fs_t fs, char path, svn_repos_history_func_t history_func, \n"
" svn_revnum_t start, svn_revnum_t end, \n"
" svn_boolean_t cross_copies, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_trace_node_locations", _wrap_svn_repos_trace_node_locations, METH_VARARGS, (char *)"\n"
"svn_repos_trace_node_locations(svn_fs_t fs, char fs_path, svn_revnum_t peg_revision, \n"
" apr_array_header_t location_revisions, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_node_location_segments", _wrap_svn_repos_node_location_segments, METH_VARARGS, (char *)"\n"
"svn_repos_node_location_segments(svn_repos_t repos, char path, svn_revnum_t peg_revision, \n"
" svn_revnum_t start_rev, svn_revnum_t end_rev, \n"
" svn_location_segment_receiver_t receiver, \n"
" svn_repos_authz_func_t authz_read_func, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_logs4", _wrap_svn_repos_get_logs4, METH_VARARGS, (char *)"\n"
"svn_repos_get_logs4(svn_repos_t repos, apr_array_header_t paths, svn_revnum_t start, \n"
" svn_revnum_t end, int limit, svn_boolean_t discover_changed_paths, \n"
" svn_boolean_t strict_node_history, \n"
" svn_boolean_t include_merged_revisions, \n"
" apr_array_header_t revprops, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" svn_log_entry_receiver_t receiver, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_logs3", _wrap_svn_repos_get_logs3, METH_VARARGS, (char *)"\n"
"svn_repos_get_logs3(svn_repos_t repos, apr_array_header_t paths, svn_revnum_t start, \n"
" svn_revnum_t end, int limit, svn_boolean_t discover_changed_paths, \n"
" svn_boolean_t strict_node_history, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" svn_log_message_receiver_t receiver, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_logs2", _wrap_svn_repos_get_logs2, METH_VARARGS, (char *)"\n"
"svn_repos_get_logs2(svn_repos_t repos, apr_array_header_t paths, svn_revnum_t start, \n"
" svn_revnum_t end, svn_boolean_t discover_changed_paths, \n"
" svn_boolean_t strict_node_history, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" svn_log_message_receiver_t receiver, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_logs", _wrap_svn_repos_get_logs, METH_VARARGS, (char *)"\n"
"svn_repos_get_logs(svn_repos_t repos, apr_array_header_t paths, svn_revnum_t start, \n"
" svn_revnum_t end, svn_boolean_t discover_changed_paths, \n"
" svn_boolean_t strict_node_history, \n"
" svn_log_message_receiver_t receiver, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_get_mergeinfo", _wrap_svn_repos_fs_get_mergeinfo, METH_VARARGS, (char *)"\n"
"svn_repos_fs_get_mergeinfo(svn_repos_t repos, apr_array_header_t paths, svn_revnum_t revision, \n"
" svn_mergeinfo_inheritance_t inherit, \n"
" svn_boolean_t include_descendants, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_file_revs2", _wrap_svn_repos_get_file_revs2, METH_VARARGS, (char *)"\n"
"svn_repos_get_file_revs2(svn_repos_t repos, char path, svn_revnum_t start, svn_revnum_t end, \n"
" svn_boolean_t include_merged_revisions, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" svn_file_rev_handler_t handler, void handler_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_file_revs", _wrap_svn_repos_get_file_revs, METH_VARARGS, (char *)"\n"
"svn_repos_get_file_revs(svn_repos_t repos, char path, svn_revnum_t start, svn_revnum_t end, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" svn_repos_file_rev_handler_t handler, \n"
" void handler_baton, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_commit_txn", _wrap_svn_repos_fs_commit_txn, METH_VARARGS, (char *)"svn_repos_fs_commit_txn(svn_repos_t repos, svn_fs_txn_t txn, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_fs_begin_txn_for_commit2", _wrap_svn_repos_fs_begin_txn_for_commit2, METH_VARARGS, (char *)"\n"
"svn_repos_fs_begin_txn_for_commit2(svn_repos_t repos, svn_revnum_t rev, apr_hash_t revprop_table, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_begin_txn_for_commit", _wrap_svn_repos_fs_begin_txn_for_commit, METH_VARARGS, (char *)"\n"
"svn_repos_fs_begin_txn_for_commit(svn_repos_t repos, svn_revnum_t rev, char author, char log_msg, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_begin_txn_for_update", _wrap_svn_repos_fs_begin_txn_for_update, METH_VARARGS, (char *)"svn_repos_fs_begin_txn_for_update(svn_repos_t repos, svn_revnum_t rev, char author, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_fs_lock", _wrap_svn_repos_fs_lock, METH_VARARGS, (char *)"\n"
"svn_repos_fs_lock(svn_repos_t repos, char path, char token, char comment, \n"
" svn_boolean_t is_dav_comment, apr_time_t expiration_date, \n"
" svn_revnum_t current_rev, svn_boolean_t steal_lock, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_unlock", _wrap_svn_repos_fs_unlock, METH_VARARGS, (char *)"\n"
"svn_repos_fs_unlock(svn_repos_t repos, char path, char token, svn_boolean_t break_lock, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_get_locks2", _wrap_svn_repos_fs_get_locks2, METH_VARARGS, (char *)"\n"
"svn_repos_fs_get_locks2(svn_repos_t repos, char path, svn_depth_t depth, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_get_locks", _wrap_svn_repos_fs_get_locks, METH_VARARGS, (char *)"\n"
"svn_repos_fs_get_locks(svn_repos_t repos, char path, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_change_rev_prop4", _wrap_svn_repos_fs_change_rev_prop4, METH_VARARGS, (char *)"\n"
"svn_repos_fs_change_rev_prop4(svn_repos_t repos, svn_revnum_t rev, char author, char name, \n"
" svn_string_t old_value_p, svn_string_t new_value, \n"
" svn_boolean_t use_pre_revprop_change_hook, \n"
" svn_boolean_t use_post_revprop_change_hook, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_change_rev_prop3", _wrap_svn_repos_fs_change_rev_prop3, METH_VARARGS, (char *)"\n"
"svn_repos_fs_change_rev_prop3(svn_repos_t repos, svn_revnum_t rev, char author, char name, \n"
" svn_string_t new_value, svn_boolean_t use_pre_revprop_change_hook, \n"
" svn_boolean_t use_post_revprop_change_hook, \n"
" svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_change_rev_prop2", _wrap_svn_repos_fs_change_rev_prop2, METH_VARARGS, (char *)"\n"
"svn_repos_fs_change_rev_prop2(svn_repos_t repos, svn_revnum_t rev, char author, char name, \n"
" svn_string_t new_value, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_change_rev_prop", _wrap_svn_repos_fs_change_rev_prop, METH_VARARGS, (char *)"\n"
"svn_repos_fs_change_rev_prop(svn_repos_t repos, svn_revnum_t rev, char author, char name, \n"
" svn_string_t new_value, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_revision_prop", _wrap_svn_repos_fs_revision_prop, METH_VARARGS, (char *)"\n"
"svn_repos_fs_revision_prop(svn_repos_t repos, svn_revnum_t rev, char propname, \n"
" svn_repos_authz_func_t authz_read_func, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_revision_proplist", _wrap_svn_repos_fs_revision_proplist, METH_VARARGS, (char *)"\n"
"svn_repos_fs_revision_proplist(svn_repos_t repos, svn_revnum_t rev, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_change_node_prop", _wrap_svn_repos_fs_change_node_prop, METH_VARARGS, (char *)"\n"
"svn_repos_fs_change_node_prop(svn_fs_root_t root, char path, char name, svn_string_t value, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_fs_change_txn_prop", _wrap_svn_repos_fs_change_txn_prop, METH_VARARGS, (char *)"svn_repos_fs_change_txn_prop(svn_fs_txn_t txn, char name, svn_string_t value, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_fs_change_txn_props", _wrap_svn_repos_fs_change_txn_props, METH_VARARGS, (char *)"svn_repos_fs_change_txn_props(svn_fs_txn_t txn, apr_array_header_t props, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_node_t_kind_set", _wrap_svn_repos_node_t_kind_set, METH_VARARGS, (char *)"svn_repos_node_t_kind_set(svn_repos_node_t self, svn_node_kind_t kind)"},
{ (char *)"svn_repos_node_t_kind_get", _wrap_svn_repos_node_t_kind_get, METH_VARARGS, (char *)"svn_repos_node_t_kind_get(svn_repos_node_t self) -> svn_node_kind_t"},
{ (char *)"svn_repos_node_t_action_set", _wrap_svn_repos_node_t_action_set, METH_VARARGS, (char *)"svn_repos_node_t_action_set(svn_repos_node_t self, char action)"},
{ (char *)"svn_repos_node_t_action_get", _wrap_svn_repos_node_t_action_get, METH_VARARGS, (char *)"svn_repos_node_t_action_get(svn_repos_node_t self) -> char"},
{ (char *)"svn_repos_node_t_text_mod_set", _wrap_svn_repos_node_t_text_mod_set, METH_VARARGS, (char *)"svn_repos_node_t_text_mod_set(svn_repos_node_t self, svn_boolean_t text_mod)"},
{ (char *)"svn_repos_node_t_text_mod_get", _wrap_svn_repos_node_t_text_mod_get, METH_VARARGS, (char *)"svn_repos_node_t_text_mod_get(svn_repos_node_t self) -> svn_boolean_t"},
{ (char *)"svn_repos_node_t_prop_mod_set", _wrap_svn_repos_node_t_prop_mod_set, METH_VARARGS, (char *)"svn_repos_node_t_prop_mod_set(svn_repos_node_t self, svn_boolean_t prop_mod)"},
{ (char *)"svn_repos_node_t_prop_mod_get", _wrap_svn_repos_node_t_prop_mod_get, METH_VARARGS, (char *)"svn_repos_node_t_prop_mod_get(svn_repos_node_t self) -> svn_boolean_t"},
{ (char *)"svn_repos_node_t_name_set", _wrap_svn_repos_node_t_name_set, METH_VARARGS, (char *)"svn_repos_node_t_name_set(svn_repos_node_t self, char name)"},
{ (char *)"svn_repos_node_t_name_get", _wrap_svn_repos_node_t_name_get, METH_VARARGS, (char *)"svn_repos_node_t_name_get(svn_repos_node_t self) -> char"},
{ (char *)"svn_repos_node_t_copyfrom_rev_set", _wrap_svn_repos_node_t_copyfrom_rev_set, METH_VARARGS, (char *)"svn_repos_node_t_copyfrom_rev_set(svn_repos_node_t self, svn_revnum_t copyfrom_rev)"},
{ (char *)"svn_repos_node_t_copyfrom_rev_get", _wrap_svn_repos_node_t_copyfrom_rev_get, METH_VARARGS, (char *)"svn_repos_node_t_copyfrom_rev_get(svn_repos_node_t self) -> svn_revnum_t"},
{ (char *)"svn_repos_node_t_copyfrom_path_set", _wrap_svn_repos_node_t_copyfrom_path_set, METH_VARARGS, (char *)"svn_repos_node_t_copyfrom_path_set(svn_repos_node_t self, char copyfrom_path)"},
{ (char *)"svn_repos_node_t_copyfrom_path_get", _wrap_svn_repos_node_t_copyfrom_path_get, METH_VARARGS, (char *)"svn_repos_node_t_copyfrom_path_get(svn_repos_node_t self) -> char"},
{ (char *)"svn_repos_node_t_sibling_set", _wrap_svn_repos_node_t_sibling_set, METH_VARARGS, (char *)"svn_repos_node_t_sibling_set(svn_repos_node_t self, struct svn_repos_node_t sibling)"},
{ (char *)"svn_repos_node_t_sibling_get", _wrap_svn_repos_node_t_sibling_get, METH_VARARGS, (char *)"svn_repos_node_t_sibling_get(svn_repos_node_t self) -> struct svn_repos_node_t"},
{ (char *)"svn_repos_node_t_child_set", _wrap_svn_repos_node_t_child_set, METH_VARARGS, (char *)"svn_repos_node_t_child_set(svn_repos_node_t self, struct svn_repos_node_t child)"},
{ (char *)"svn_repos_node_t_child_get", _wrap_svn_repos_node_t_child_get, METH_VARARGS, (char *)"svn_repos_node_t_child_get(svn_repos_node_t self) -> struct svn_repos_node_t"},
{ (char *)"svn_repos_node_t_parent_set", _wrap_svn_repos_node_t_parent_set, METH_VARARGS, (char *)"svn_repos_node_t_parent_set(svn_repos_node_t self, struct svn_repos_node_t parent)"},
{ (char *)"svn_repos_node_t_parent_get", _wrap_svn_repos_node_t_parent_get, METH_VARARGS, (char *)"svn_repos_node_t_parent_get(svn_repos_node_t self) -> struct svn_repos_node_t"},
{ (char *)"svn_repos_node_t_swigregister", svn_repos_node_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_node_editor", _wrap_svn_repos_node_editor, METH_VARARGS, (char *)"\n"
"svn_repos_node_editor(svn_repos_t repos, svn_fs_root_t base_root, svn_fs_root_t root, \n"
" apr_pool_t node_pool, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_node_from_baton", _wrap_svn_repos_node_from_baton, METH_VARARGS, (char *)"svn_repos_node_from_baton(void edit_baton) -> svn_repos_node_t"},
{ (char *)"svn_repos_verify_fs2", _wrap_svn_repos_verify_fs2, METH_VARARGS, (char *)"\n"
"svn_repos_verify_fs2(svn_repos_t repos, svn_revnum_t start_rev, svn_revnum_t end_rev, \n"
" svn_repos_notify_func_t notify_func, \n"
" void notify_baton, svn_cancel_func_t cancel, \n"
" void cancel_baton, apr_pool_t scratch_pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_verify_fs", _wrap_svn_repos_verify_fs, METH_VARARGS, (char *)"\n"
"svn_repos_verify_fs(svn_repos_t repos, svn_stream_t feedback_stream, svn_revnum_t start_rev, \n"
" svn_revnum_t end_rev, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_dump_fs3", _wrap_svn_repos_dump_fs3, METH_VARARGS, (char *)"\n"
"svn_repos_dump_fs3(svn_repos_t repos, svn_stream_t dumpstream, svn_revnum_t start_rev, \n"
" svn_revnum_t end_rev, svn_boolean_t incremental, \n"
" svn_boolean_t use_deltas, \n"
" svn_repos_notify_func_t notify_func, void notify_baton, \n"
" svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_dump_fs2", _wrap_svn_repos_dump_fs2, METH_VARARGS, (char *)"\n"
"svn_repos_dump_fs2(svn_repos_t repos, svn_stream_t dumpstream, svn_stream_t feedback_stream, \n"
" svn_revnum_t start_rev, \n"
" svn_revnum_t end_rev, svn_boolean_t incremental, \n"
" svn_boolean_t use_deltas, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_dump_fs", _wrap_svn_repos_dump_fs, METH_VARARGS, (char *)"\n"
"svn_repos_dump_fs(svn_repos_t repos, svn_stream_t dumpstream, svn_stream_t feedback_stream, \n"
" svn_revnum_t start_rev, \n"
" svn_revnum_t end_rev, svn_boolean_t incremental, \n"
" svn_cancel_func_t cancel_func, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_load_fs3", _wrap_svn_repos_load_fs3, METH_VARARGS, (char *)"\n"
"svn_repos_load_fs3(svn_repos_t repos, svn_stream_t dumpstream, enum svn_repos_load_uuid uuid_action, \n"
" char parent_dir, \n"
" svn_boolean_t use_pre_commit_hook, svn_boolean_t use_post_commit_hook, \n"
" svn_boolean_t validate_props, \n"
" svn_repos_notify_func_t notify_func, \n"
" void notify_baton, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_load_fs2", _wrap_svn_repos_load_fs2, METH_VARARGS, (char *)"\n"
"svn_repos_load_fs2(svn_repos_t repos, svn_stream_t dumpstream, svn_stream_t feedback_stream, \n"
" enum svn_repos_load_uuid uuid_action, \n"
" char parent_dir, svn_boolean_t use_pre_commit_hook, \n"
" svn_boolean_t use_post_commit_hook, \n"
" svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_load_fs", _wrap_svn_repos_load_fs, METH_VARARGS, (char *)"\n"
"svn_repos_load_fs(svn_repos_t repos, svn_stream_t dumpstream, svn_stream_t feedback_stream, \n"
" enum svn_repos_load_uuid uuid_action, \n"
" char parent_dir, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_parse_fns2_t_new_revision_record_set", _wrap_svn_repos_parse_fns2_t_new_revision_record_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_new_revision_record_set(svn_repos_parse_fns2_t self, svn_error_t new_revision_record)"},
{ (char *)"svn_repos_parse_fns2_t_new_revision_record_get", _wrap_svn_repos_parse_fns2_t_new_revision_record_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_new_revision_record_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_uuid_record_set", _wrap_svn_repos_parse_fns2_t_uuid_record_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_uuid_record_set(svn_repos_parse_fns2_t self, svn_error_t uuid_record)"},
{ (char *)"svn_repos_parse_fns2_t_uuid_record_get", _wrap_svn_repos_parse_fns2_t_uuid_record_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_uuid_record_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_new_node_record_set", _wrap_svn_repos_parse_fns2_t_new_node_record_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_new_node_record_set(svn_repos_parse_fns2_t self, svn_error_t new_node_record)"},
{ (char *)"svn_repos_parse_fns2_t_new_node_record_get", _wrap_svn_repos_parse_fns2_t_new_node_record_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_new_node_record_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_set_revision_property_set", _wrap_svn_repos_parse_fns2_t_set_revision_property_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_set_revision_property_set(svn_repos_parse_fns2_t self, svn_error_t set_revision_property)"},
{ (char *)"svn_repos_parse_fns2_t_set_revision_property_get", _wrap_svn_repos_parse_fns2_t_set_revision_property_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_set_revision_property_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_set_node_property_set", _wrap_svn_repos_parse_fns2_t_set_node_property_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_set_node_property_set(svn_repos_parse_fns2_t self, svn_error_t set_node_property)"},
{ (char *)"svn_repos_parse_fns2_t_set_node_property_get", _wrap_svn_repos_parse_fns2_t_set_node_property_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_set_node_property_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_delete_node_property_set", _wrap_svn_repos_parse_fns2_t_delete_node_property_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_delete_node_property_set(svn_repos_parse_fns2_t self, svn_error_t delete_node_property)"},
{ (char *)"svn_repos_parse_fns2_t_delete_node_property_get", _wrap_svn_repos_parse_fns2_t_delete_node_property_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_delete_node_property_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_remove_node_props_set", _wrap_svn_repos_parse_fns2_t_remove_node_props_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_remove_node_props_set(svn_repos_parse_fns2_t self, svn_error_t remove_node_props)"},
{ (char *)"svn_repos_parse_fns2_t_remove_node_props_get", _wrap_svn_repos_parse_fns2_t_remove_node_props_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_remove_node_props_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_set_fulltext_set", _wrap_svn_repos_parse_fns2_t_set_fulltext_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_set_fulltext_set(svn_repos_parse_fns2_t self, svn_error_t set_fulltext)"},
{ (char *)"svn_repos_parse_fns2_t_set_fulltext_get", _wrap_svn_repos_parse_fns2_t_set_fulltext_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_set_fulltext_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_apply_textdelta_set", _wrap_svn_repos_parse_fns2_t_apply_textdelta_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_apply_textdelta_set(svn_repos_parse_fns2_t self, svn_error_t apply_textdelta)"},
{ (char *)"svn_repos_parse_fns2_t_apply_textdelta_get", _wrap_svn_repos_parse_fns2_t_apply_textdelta_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_apply_textdelta_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_close_node_set", _wrap_svn_repos_parse_fns2_t_close_node_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_close_node_set(svn_repos_parse_fns2_t self, svn_error_t close_node)"},
{ (char *)"svn_repos_parse_fns2_t_close_node_get", _wrap_svn_repos_parse_fns2_t_close_node_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_close_node_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_close_revision_set", _wrap_svn_repos_parse_fns2_t_close_revision_set, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_close_revision_set(svn_repos_parse_fns2_t self, svn_error_t close_revision)"},
{ (char *)"svn_repos_parse_fns2_t_close_revision_get", _wrap_svn_repos_parse_fns2_t_close_revision_get, METH_VARARGS, (char *)"svn_repos_parse_fns2_t_close_revision_get(svn_repos_parse_fns2_t self) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_t_swigregister", svn_repos_parse_fns2_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_parse_dumpstream2", _wrap_svn_repos_parse_dumpstream2, METH_VARARGS, (char *)"\n"
"svn_repos_parse_dumpstream2(svn_stream_t stream, svn_repos_parse_fns2_t parse_fns, \n"
" void parse_baton, svn_cancel_func_t cancel_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_fs_build_parser3", _wrap_svn_repos_get_fs_build_parser3, METH_VARARGS, (char *)"\n"
"svn_repos_get_fs_build_parser3(svn_repos_t repos, svn_boolean_t use_history, svn_boolean_t validate_props, \n"
" enum svn_repos_load_uuid uuid_action, \n"
" char parent_dir, svn_repos_notify_func_t notify_func, \n"
" void notify_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_fs_build_parser2", _wrap_svn_repos_get_fs_build_parser2, METH_VARARGS, (char *)"\n"
"svn_repos_get_fs_build_parser2(svn_repos_t repos, svn_boolean_t use_history, enum svn_repos_load_uuid uuid_action, \n"
" svn_stream_t outstream, \n"
" char parent_dir, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_parser_fns_t_new_revision_record_set", _wrap_svn_repos_parser_fns_t_new_revision_record_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_new_revision_record_set( self, svn_error_t new_revision_record)"},
{ (char *)"svn_repos_parser_fns_t_new_revision_record_get", _wrap_svn_repos_parser_fns_t_new_revision_record_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_new_revision_record_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_uuid_record_set", _wrap_svn_repos_parser_fns_t_uuid_record_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_uuid_record_set( self, svn_error_t uuid_record)"},
{ (char *)"svn_repos_parser_fns_t_uuid_record_get", _wrap_svn_repos_parser_fns_t_uuid_record_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_uuid_record_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_new_node_record_set", _wrap_svn_repos_parser_fns_t_new_node_record_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_new_node_record_set( self, svn_error_t new_node_record)"},
{ (char *)"svn_repos_parser_fns_t_new_node_record_get", _wrap_svn_repos_parser_fns_t_new_node_record_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_new_node_record_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_set_revision_property_set", _wrap_svn_repos_parser_fns_t_set_revision_property_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_set_revision_property_set( self, svn_error_t set_revision_property)"},
{ (char *)"svn_repos_parser_fns_t_set_revision_property_get", _wrap_svn_repos_parser_fns_t_set_revision_property_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_set_revision_property_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_set_node_property_set", _wrap_svn_repos_parser_fns_t_set_node_property_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_set_node_property_set( self, svn_error_t set_node_property)"},
{ (char *)"svn_repos_parser_fns_t_set_node_property_get", _wrap_svn_repos_parser_fns_t_set_node_property_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_set_node_property_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_remove_node_props_set", _wrap_svn_repos_parser_fns_t_remove_node_props_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_remove_node_props_set( self, svn_error_t remove_node_props)"},
{ (char *)"svn_repos_parser_fns_t_remove_node_props_get", _wrap_svn_repos_parser_fns_t_remove_node_props_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_remove_node_props_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_set_fulltext_set", _wrap_svn_repos_parser_fns_t_set_fulltext_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_set_fulltext_set( self, svn_error_t set_fulltext)"},
{ (char *)"svn_repos_parser_fns_t_set_fulltext_get", _wrap_svn_repos_parser_fns_t_set_fulltext_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_set_fulltext_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_close_node_set", _wrap_svn_repos_parser_fns_t_close_node_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_close_node_set( self, svn_error_t close_node)"},
{ (char *)"svn_repos_parser_fns_t_close_node_get", _wrap_svn_repos_parser_fns_t_close_node_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_close_node_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_close_revision_set", _wrap_svn_repos_parser_fns_t_close_revision_set, METH_VARARGS, (char *)"svn_repos_parser_fns_t_close_revision_set( self, svn_error_t close_revision)"},
{ (char *)"svn_repos_parser_fns_t_close_revision_get", _wrap_svn_repos_parser_fns_t_close_revision_get, METH_VARARGS, (char *)"svn_repos_parser_fns_t_close_revision_get( self) -> svn_error_t"},
{ (char *)"svn_repos_parser_fns_t_swigregister", svn_repos_parser_fns_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_parse_dumpstream", _wrap_svn_repos_parse_dumpstream, METH_VARARGS, (char *)"\n"
"svn_repos_parse_dumpstream(svn_stream_t stream, parse_fns, void parse_baton, \n"
" svn_cancel_func_t cancel_func, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_get_fs_build_parser", _wrap_svn_repos_get_fs_build_parser, METH_VARARGS, (char *)"\n"
"svn_repos_get_fs_build_parser(svn_repos_t repos, svn_boolean_t use_history, enum svn_repos_load_uuid uuid_action, \n"
" svn_stream_t outstream, \n"
" char parent_dir, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_authz_read", _wrap_svn_repos_authz_read, METH_VARARGS, (char *)"svn_repos_authz_read(char file, svn_boolean_t must_exist, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_repos_authz_check_access", _wrap_svn_repos_authz_check_access, METH_VARARGS, (char *)"\n"
"svn_repos_authz_check_access(svn_authz_t authz, char repos_name, char path, char user, \n"
" svn_repos_authz_access_t required_access, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_check_revision_access", _wrap_svn_repos_check_revision_access, METH_VARARGS, (char *)"\n"
"svn_repos_check_revision_access(svn_repos_revision_access_level_t access_level, svn_repos_t repos, \n"
" svn_revnum_t revision, svn_repos_authz_func_t authz_read_func, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_remember_client_capabilities", _wrap_svn_repos_remember_client_capabilities, METH_VARARGS, (char *)"svn_repos_remember_client_capabilities(svn_repos_t repos, apr_array_header_t capabilities) -> svn_error_t"},
{ (char *)"svn_repos_t_swigregister", svn_repos_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_authz_t_swigregister", svn_authz_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_parse_fns2_invoke_new_revision_record", _wrap_svn_repos_parse_fns2_invoke_new_revision_record, METH_VARARGS, (char *)"\n"
"svn_repos_parse_fns2_invoke_new_revision_record(svn_repos_parse_fns2_t _obj, apr_hash_t headers, void parse_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_parse_fns2_invoke_uuid_record", _wrap_svn_repos_parse_fns2_invoke_uuid_record, METH_VARARGS, (char *)"\n"
"svn_repos_parse_fns2_invoke_uuid_record(svn_repos_parse_fns2_t _obj, char uuid, void parse_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_parse_fns2_invoke_new_node_record", _wrap_svn_repos_parse_fns2_invoke_new_node_record, METH_VARARGS, (char *)"\n"
"svn_repos_parse_fns2_invoke_new_node_record(svn_repos_parse_fns2_t _obj, apr_hash_t headers, void revision_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_parse_fns2_invoke_set_revision_property", _wrap_svn_repos_parse_fns2_invoke_set_revision_property, METH_VARARGS, (char *)"\n"
"svn_repos_parse_fns2_invoke_set_revision_property(svn_repos_parse_fns2_t _obj, void revision_baton, char name, \n"
" svn_string_t value) -> svn_error_t\n"
""},
{ (char *)"svn_repos_parse_fns2_invoke_set_node_property", _wrap_svn_repos_parse_fns2_invoke_set_node_property, METH_VARARGS, (char *)"\n"
"svn_repos_parse_fns2_invoke_set_node_property(svn_repos_parse_fns2_t _obj, void node_baton, char name, \n"
" svn_string_t value) -> svn_error_t\n"
""},
{ (char *)"svn_repos_parse_fns2_invoke_delete_node_property", _wrap_svn_repos_parse_fns2_invoke_delete_node_property, METH_VARARGS, (char *)"svn_repos_parse_fns2_invoke_delete_node_property(svn_repos_parse_fns2_t _obj, void node_baton, char name) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_invoke_remove_node_props", _wrap_svn_repos_parse_fns2_invoke_remove_node_props, METH_VARARGS, (char *)"svn_repos_parse_fns2_invoke_remove_node_props(svn_repos_parse_fns2_t _obj, void node_baton) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_invoke_set_fulltext", _wrap_svn_repos_parse_fns2_invoke_set_fulltext, METH_VARARGS, (char *)"svn_repos_parse_fns2_invoke_set_fulltext(svn_repos_parse_fns2_t _obj, void node_baton) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_invoke_apply_textdelta", _wrap_svn_repos_parse_fns2_invoke_apply_textdelta, METH_VARARGS, (char *)"svn_repos_parse_fns2_invoke_apply_textdelta(svn_repos_parse_fns2_t _obj, void node_baton) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_invoke_close_node", _wrap_svn_repos_parse_fns2_invoke_close_node, METH_VARARGS, (char *)"svn_repos_parse_fns2_invoke_close_node(svn_repos_parse_fns2_t _obj, void node_baton) -> svn_error_t"},
{ (char *)"svn_repos_parse_fns2_invoke_close_revision", _wrap_svn_repos_parse_fns2_invoke_close_revision, METH_VARARGS, (char *)"svn_repos_parse_fns2_invoke_close_revision(svn_repos_parse_fns2_t _obj, void revision_baton) -> svn_error_t"},
{ (char *)"svn_repos_invoke_authz_func", _wrap_svn_repos_invoke_authz_func, METH_VARARGS, (char *)"\n"
"svn_repos_invoke_authz_func(svn_repos_authz_func_t _obj, svn_fs_root_t root, char path, \n"
" void baton, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_invoke_authz_callback", _wrap_svn_repos_invoke_authz_callback, METH_VARARGS, (char *)"\n"
"svn_repos_invoke_authz_callback(svn_repos_authz_callback_t _obj, svn_repos_authz_access_t required, \n"
" svn_fs_root_t root, char path, \n"
" void baton, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_invoke_file_rev_handler", _wrap_svn_repos_invoke_file_rev_handler, METH_VARARGS, (char *)"\n"
"svn_repos_invoke_file_rev_handler(svn_repos_file_rev_handler_t _obj, void baton, char path, \n"
" svn_revnum_t rev, apr_hash_t rev_props, \n"
" apr_array_header_t prop_diffs, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_invoke_notify_func", _wrap_svn_repos_invoke_notify_func, METH_VARARGS, (char *)"\n"
"svn_repos_invoke_notify_func(svn_repos_notify_func_t _obj, void baton, svn_repos_notify_t notify, \n"
" apr_pool_t scratch_pool)\n"
""},
{ (char *)"svn_repos_invoke_history_func", _wrap_svn_repos_invoke_history_func, METH_VARARGS, (char *)"\n"
"svn_repos_invoke_history_func(svn_repos_history_func_t _obj, void baton, char path, \n"
" svn_revnum_t revision, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_repos_authz_func_t_swigregister", svn_repos_authz_func_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_authz_callback_t_swigregister", svn_repos_authz_callback_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_file_rev_handler_t_swigregister", svn_repos_file_rev_handler_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_notify_func_t_swigregister", svn_repos_notify_func_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_repos_history_func_t_swigregister", svn_repos_history_func_t_swigregister, METH_VARARGS, NULL},
{ NULL, NULL, 0, NULL }
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_apr_array_header_t = {"_p_apr_array_header_t", "apr_array_header_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_apr_hash_t = {"_p_apr_hash_t", "apr_hash_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_apr_int32_t = {"_p_apr_int32_t", "apr_int32_t *|time_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_apr_int64_t = {"_p_apr_int64_t", "apr_int64_t *|svn_filesize_t *|apr_time_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_apr_pool_t = {"_p_apr_pool_t", "apr_pool_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_opt_subcommand_t *|struct svn_error_t *(*)(apr_getopt_t *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_p_svn_stream_t_p_void__p_svn_error_t = {"_p_f_p_p_svn_stream_t_p_void__p_svn_error_t", "struct svn_error_t *(*)(svn_stream_t **,void *)|svn_error_t *(*)(svn_stream_t **,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)|svn_error_t *(*)(void **,apr_hash_t *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(char const *,void *,apr_pool_t *)|struct svn_error_t *(*)(char const *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__svn_commit_info_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_q_const__svn_commit_info_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_commit_callback2_t|struct svn_error_t *(*)(svn_commit_info_t const *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t", "svn_repos_authz_func_t|struct svn_error_t *(*)(svn_boolean_t *,svn_fs_root_t *,char const *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_svn_location_segment_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_svn_location_segment_t_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(svn_location_segment_t *,void *,apr_pool_t *)|svn_location_segment_receiver_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t = {"_p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t", "struct svn_error_t *(*)(svn_txdelta_window_handler_t *,void **,void *)|svn_error_t *(*)(svn_txdelta_window_handler_t *,void **,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__p_svn_error_t = {"_p_f_p_void__p_svn_error_t", "svn_cancel_func_t|struct svn_error_t *(*)(void *)|svn_error_t *(*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_int64_t,svn_fs_pack_notify_action_t,apr_pool_t *)|svn_fs_pack_notify_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_hash_t *,svn_revnum_t,char const *,char const *,char const *,apr_pool_t *)|svn_log_message_receiver_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__char__p_svn_error_t = {"_p_f_p_void_p_q_const__char__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *)|svn_error_t *(*)(void *,char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_string_t const *)|svn_error_t *(*)(void *,char const *,svn_string_t const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)|svn_repos_file_rev_handler_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_boolean_t,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)|svn_file_rev_handler_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_revnum_t,apr_pool_t *)|svn_repos_history_func_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void = {"_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void", "svn_repos_notify_func_t|void (*)(void *,struct svn_repos_notify_t const *,apr_pool_t *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,svn_log_entry_t *,apr_pool_t *)|svn_log_entry_receiver_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(svn_repos_authz_access_t,svn_boolean_t *,svn_fs_root_t *,char const *,void *,apr_pool_t *)|svn_repos_authz_callback_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t = {"_p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t", "struct svn_error_t *(*)(svn_revnum_t,char const *,char const *,void *)|svn_commit_callback_t", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *|svn_boolean_t *|apr_status_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "long *|svn_revnum_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_apr_array_header_t = {"_p_p_apr_array_header_t", "apr_array_header_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_apr_hash_t = {"_p_p_apr_hash_t", "apr_hash_t **|svn_mergeinfo_catalog_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t", "svn_repos_authz_func_t *|struct svn_error_t *(**)(svn_boolean_t *,svn_fs_root_t *,char const *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t = {"_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t", "svn_txdelta_window_handler_t *|struct svn_error_t *(**)(svn_txdelta_window_t *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void__p_svn_error_t = {"_p_p_f_p_void__p_svn_error_t", "svn_cancel_func_t *|struct svn_error_t *(**)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(void *,apr_int64_t,svn_fs_pack_notify_action_t,apr_pool_t *)|svn_fs_pack_notify_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)|svn_repos_file_rev_handler_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_boolean_t,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)|svn_file_rev_handler_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(void *,char const *,svn_revnum_t,apr_pool_t *)|svn_repos_history_func_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void = {"_p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void", "void (**)(void *,struct svn_repos_notify_t const *,apr_pool_t *)|svn_repos_notify_func_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t = {"_p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t", "svn_repos_authz_callback_t *|struct svn_error_t *(**)(svn_repos_authz_access_t,svn_boolean_t *,svn_fs_root_t *,char const *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_authz_t = {"_p_p_svn_authz_t", "struct svn_authz_t **|svn_authz_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_delta_editor_t = {"_p_p_svn_delta_editor_t", "struct svn_delta_editor_t **|svn_delta_editor_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_dirent_t = {"_p_p_svn_dirent_t", "struct svn_dirent_t **|svn_dirent_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_fs_txn_t = {"_p_p_svn_fs_txn_t", "struct svn_fs_txn_t **|svn_fs_txn_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_lock_t = {"_p_p_svn_lock_t", "struct svn_lock_t **|svn_lock_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_repos_parse_fns2_t = {"_p_p_svn_repos_parse_fns2_t", "struct svn_repos_parse_fns2_t **|svn_repos_parse_fns2_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_repos_parse_fns_t = {"_p_p_svn_repos_parse_fns_t", "struct svn_repos_parse_fns_t **|svn_repos_parser_fns_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_repos_t = {"_p_p_svn_repos_t", "struct svn_repos_t **|svn_repos_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_stream_t = {"_p_p_svn_stream_t", "struct svn_stream_t **|svn_stream_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_svn_string_t = {"_p_p_svn_string_t", "struct svn_string_t **|svn_string_t **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_baton_t = {"_p_svn_auth_baton_t", "struct svn_auth_baton_t *|svn_auth_baton_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_cred_simple_t = {"_p_svn_auth_cred_simple_t", "struct svn_auth_cred_simple_t *|svn_auth_cred_simple_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_cred_ssl_client_cert_pw_t = {"_p_svn_auth_cred_ssl_client_cert_pw_t", "struct svn_auth_cred_ssl_client_cert_pw_t *|svn_auth_cred_ssl_client_cert_pw_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_cred_ssl_client_cert_t = {"_p_svn_auth_cred_ssl_client_cert_t", "struct svn_auth_cred_ssl_client_cert_t *|svn_auth_cred_ssl_client_cert_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_cred_ssl_server_trust_t = {"_p_svn_auth_cred_ssl_server_trust_t", "struct svn_auth_cred_ssl_server_trust_t *|svn_auth_cred_ssl_server_trust_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_cred_username_t = {"_p_svn_auth_cred_username_t", "struct svn_auth_cred_username_t *|svn_auth_cred_username_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_iterstate_t = {"_p_svn_auth_iterstate_t", "struct svn_auth_iterstate_t *|svn_auth_iterstate_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_provider_object_t = {"_p_svn_auth_provider_object_t", "struct svn_auth_provider_object_t *|svn_auth_provider_object_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_provider_t = {"_p_svn_auth_provider_t", "struct svn_auth_provider_t *|svn_auth_provider_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_auth_ssl_server_cert_info_t = {"_p_svn_auth_ssl_server_cert_info_t", "struct svn_auth_ssl_server_cert_info_t *|svn_auth_ssl_server_cert_info_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_authz_t = {"_p_svn_authz_t", "struct svn_authz_t *|svn_authz_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_commit_info_t = {"_p_svn_commit_info_t", "struct svn_commit_info_t *|svn_commit_info_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_config_t = {"_p_svn_config_t", "struct svn_config_t *|svn_config_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_delta_editor_t = {"_p_svn_delta_editor_t", "struct svn_delta_editor_t *|svn_delta_editor_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_depth_t = {"_p_svn_depth_t", "enum svn_depth_t *|svn_depth_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_dirent_t = {"_p_svn_dirent_t", "struct svn_dirent_t *|svn_dirent_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_errno_t = {"_p_svn_errno_t", "enum svn_errno_t *|svn_errno_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_error_t = {"_p_svn_error_t", "struct svn_error_t *|svn_error_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_access_t = {"_p_svn_fs_access_t", "struct svn_fs_access_t *|svn_fs_access_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_dirent_t = {"_p_svn_fs_dirent_t", "struct svn_fs_dirent_t *|svn_fs_dirent_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_history_t = {"_p_svn_fs_history_t", "struct svn_fs_history_t *|svn_fs_history_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_id_t = {"_p_svn_fs_id_t", "struct svn_fs_id_t *|svn_fs_id_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_pack_notify_action_t = {"_p_svn_fs_pack_notify_action_t", "enum svn_fs_pack_notify_action_t *|svn_fs_pack_notify_action_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_path_change2_t = {"_p_svn_fs_path_change2_t", "struct svn_fs_path_change2_t *|svn_fs_path_change2_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_path_change_kind_t = {"_p_svn_fs_path_change_kind_t", "enum svn_fs_path_change_kind_t *|svn_fs_path_change_kind_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_path_change_t = {"_p_svn_fs_path_change_t", "struct svn_fs_path_change_t *|svn_fs_path_change_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_root_t = {"_p_svn_fs_root_t", "struct svn_fs_root_t *|svn_fs_root_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_t = {"_p_svn_fs_t", "struct svn_fs_t *|svn_fs_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_fs_txn_t = {"_p_svn_fs_txn_t", "struct svn_fs_txn_t *|svn_fs_txn_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_io_dirent2_t = {"_p_svn_io_dirent2_t", "struct svn_io_dirent2_t *|svn_io_dirent2_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_io_dirent_t = {"_p_svn_io_dirent_t", "struct svn_io_dirent_t *|svn_io_dirent_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_io_file_del_t = {"_p_svn_io_file_del_t", "enum svn_io_file_del_t *|svn_io_file_del_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_location_segment_t = {"_p_svn_location_segment_t", "struct svn_location_segment_t *|svn_location_segment_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_lock_t = {"_p_svn_lock_t", "struct svn_lock_t *|svn_lock_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_log_changed_path2_t = {"_p_svn_log_changed_path2_t", "struct svn_log_changed_path2_t *|svn_log_changed_path2_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_log_changed_path_t = {"_p_svn_log_changed_path_t", "struct svn_log_changed_path_t *|svn_log_changed_path_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_log_entry_t = {"_p_svn_log_entry_t", "struct svn_log_entry_t *|svn_log_entry_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_merge_range_t = {"_p_svn_merge_range_t", "struct svn_merge_range_t *|svn_merge_range_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_mergeinfo_inheritance_t = {"_p_svn_mergeinfo_inheritance_t", "enum svn_mergeinfo_inheritance_t *|svn_mergeinfo_inheritance_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_node_kind_t = {"_p_svn_node_kind_t", "enum svn_node_kind_t *|svn_node_kind_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_opt_revision_range_t = {"_p_svn_opt_revision_range_t", "struct svn_opt_revision_range_t *|svn_opt_revision_range_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_opt_revision_t = {"_p_svn_opt_revision_t", "struct svn_opt_revision_t *|svn_opt_revision_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_opt_revision_value_t = {"_p_svn_opt_revision_value_t", "union svn_opt_revision_value_t *|svn_opt_revision_value_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_opt_subcommand_desc2_t = {"_p_svn_opt_subcommand_desc2_t", "struct svn_opt_subcommand_desc2_t *|svn_opt_subcommand_desc2_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_opt_subcommand_desc_t = {"_p_svn_opt_subcommand_desc_t", "struct svn_opt_subcommand_desc_t *|svn_opt_subcommand_desc_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_prop_kind = {"_p_svn_prop_kind", "svn_prop_kind_t *|enum svn_prop_kind *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_authz_access_t = {"_p_svn_repos_authz_access_t", "enum svn_repos_authz_access_t *|svn_repos_authz_access_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_node_t = {"_p_svn_repos_node_t", "struct svn_repos_node_t *|svn_repos_node_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_notify_action_t = {"_p_svn_repos_notify_action_t", "enum svn_repos_notify_action_t *|svn_repos_notify_action_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_notify_t = {"_p_svn_repos_notify_t", "struct svn_repos_notify_t *|svn_repos_notify_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_notify_warning_t = {"_p_svn_repos_notify_warning_t", "enum svn_repos_notify_warning_t *|svn_repos_notify_warning_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_parse_fns2_t = {"_p_svn_repos_parse_fns2_t", "struct svn_repos_parse_fns2_t *|svn_repos_parse_fns2_t *|svn_repos_parser_fns2_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_parse_fns_t = {"_p_svn_repos_parse_fns_t", "struct svn_repos_parse_fns_t *|svn_repos_parser_fns_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_revision_access_level_t = {"_p_svn_repos_revision_access_level_t", "enum svn_repos_revision_access_level_t *|svn_repos_revision_access_level_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_repos_t = {"_p_svn_repos_t", "struct svn_repos_t *|svn_repos_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_stream_mark_t = {"_p_svn_stream_mark_t", "struct svn_stream_mark_t *|svn_stream_mark_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_stream_t = {"_p_svn_stream_t", "struct svn_stream_t *|svn_stream_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_string_t = {"_p_svn_string_t", "struct svn_string_t *|svn_string_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_stringbuf_t = {"_p_svn_stringbuf_t", "struct svn_stringbuf_t *|svn_stringbuf_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_tristate_t = {"_p_svn_tristate_t", "enum svn_tristate_t *|svn_tristate_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_txdelta_op_t = {"_p_svn_txdelta_op_t", "struct svn_txdelta_op_t *|svn_txdelta_op_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_txdelta_stream_t = {"_p_svn_txdelta_stream_t", "struct svn_txdelta_stream_t *|svn_txdelta_stream_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_txdelta_window_t = {"_p_svn_txdelta_window_t", "struct svn_txdelta_window_t *|svn_txdelta_window_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_version_checklist_t = {"_p_svn_version_checklist_t", "struct svn_version_checklist_t *|svn_version_checklist_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_svn_version_t = {"_p_svn_version_t", "struct svn_version_t *|svn_version_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|svn_linenum_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_apr_array_header_t,
&_swigt__p_apr_hash_t,
&_swigt__p_apr_int32_t,
&_swigt__p_apr_int64_t,
&_swigt__p_apr_pool_t,
&_swigt__p_char,
&_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_p_svn_stream_t_p_void__p_svn_error_t,
&_swigt__p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_q_const__svn_commit_info_t_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_svn_location_segment_t_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t,
&_swigt__p_f_p_void__p_svn_error_t,
&_swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_void_p_q_const__char__p_svn_error_t,
&_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t,
&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
&_swigt__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t,
&_swigt__p_int,
&_swigt__p_long,
&_swigt__p_p_apr_array_header_t,
&_swigt__p_p_apr_hash_t,
&_swigt__p_p_char,
&_swigt__p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
&_swigt__p_p_f_p_void__p_svn_error_t,
&_swigt__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
&_swigt__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
&_swigt__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
&_swigt__p_p_svn_authz_t,
&_swigt__p_p_svn_delta_editor_t,
&_swigt__p_p_svn_dirent_t,
&_swigt__p_p_svn_fs_txn_t,
&_swigt__p_p_svn_lock_t,
&_swigt__p_p_svn_repos_parse_fns2_t,
&_swigt__p_p_svn_repos_parse_fns_t,
&_swigt__p_p_svn_repos_t,
&_swigt__p_p_svn_stream_t,
&_swigt__p_p_svn_string_t,
&_swigt__p_p_void,
&_swigt__p_svn_auth_baton_t,
&_swigt__p_svn_auth_cred_simple_t,
&_swigt__p_svn_auth_cred_ssl_client_cert_pw_t,
&_swigt__p_svn_auth_cred_ssl_client_cert_t,
&_swigt__p_svn_auth_cred_ssl_server_trust_t,
&_swigt__p_svn_auth_cred_username_t,
&_swigt__p_svn_auth_iterstate_t,
&_swigt__p_svn_auth_provider_object_t,
&_swigt__p_svn_auth_provider_t,
&_swigt__p_svn_auth_ssl_server_cert_info_t,
&_swigt__p_svn_authz_t,
&_swigt__p_svn_commit_info_t,
&_swigt__p_svn_config_t,
&_swigt__p_svn_delta_editor_t,
&_swigt__p_svn_depth_t,
&_swigt__p_svn_dirent_t,
&_swigt__p_svn_errno_t,
&_swigt__p_svn_error_t,
&_swigt__p_svn_fs_access_t,
&_swigt__p_svn_fs_dirent_t,
&_swigt__p_svn_fs_history_t,
&_swigt__p_svn_fs_id_t,
&_swigt__p_svn_fs_pack_notify_action_t,
&_swigt__p_svn_fs_path_change2_t,
&_swigt__p_svn_fs_path_change_kind_t,
&_swigt__p_svn_fs_path_change_t,
&_swigt__p_svn_fs_root_t,
&_swigt__p_svn_fs_t,
&_swigt__p_svn_fs_txn_t,
&_swigt__p_svn_io_dirent2_t,
&_swigt__p_svn_io_dirent_t,
&_swigt__p_svn_io_file_del_t,
&_swigt__p_svn_location_segment_t,
&_swigt__p_svn_lock_t,
&_swigt__p_svn_log_changed_path2_t,
&_swigt__p_svn_log_changed_path_t,
&_swigt__p_svn_log_entry_t,
&_swigt__p_svn_merge_range_t,
&_swigt__p_svn_mergeinfo_inheritance_t,
&_swigt__p_svn_node_kind_t,
&_swigt__p_svn_opt_revision_range_t,
&_swigt__p_svn_opt_revision_t,
&_swigt__p_svn_opt_revision_value_t,
&_swigt__p_svn_opt_subcommand_desc2_t,
&_swigt__p_svn_opt_subcommand_desc_t,
&_swigt__p_svn_prop_kind,
&_swigt__p_svn_repos_authz_access_t,
&_swigt__p_svn_repos_node_t,
&_swigt__p_svn_repos_notify_action_t,
&_swigt__p_svn_repos_notify_t,
&_swigt__p_svn_repos_notify_warning_t,
&_swigt__p_svn_repos_parse_fns2_t,
&_swigt__p_svn_repos_parse_fns_t,
&_swigt__p_svn_repos_revision_access_level_t,
&_swigt__p_svn_repos_t,
&_swigt__p_svn_stream_mark_t,
&_swigt__p_svn_stream_t,
&_swigt__p_svn_string_t,
&_swigt__p_svn_stringbuf_t,
&_swigt__p_svn_tristate_t,
&_swigt__p_svn_txdelta_op_t,
&_swigt__p_svn_txdelta_stream_t,
&_swigt__p_svn_txdelta_window_t,
&_swigt__p_svn_version_checklist_t,
&_swigt__p_svn_version_t,
&_swigt__p_unsigned_long,
&_swigt__p_void,
};
static swig_cast_info _swigc__p_apr_array_header_t[] = { {&_swigt__p_apr_array_header_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_apr_hash_t[] = { {&_swigt__p_apr_hash_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_apr_int32_t[] = { {&_swigt__p_apr_int32_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_apr_int64_t[] = { {&_swigt__p_apr_int64_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_apr_pool_t[] = { {&_swigt__p_apr_pool_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_p_svn_stream_t_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_p_svn_stream_t_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__svn_commit_info_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_q_const__svn_commit_info_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_svn_location_segment_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_svn_location_segment_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__char__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void[] = { {&_swigt__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t[] = { {&_swigt__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_apr_array_header_t[] = { {&_swigt__p_p_apr_array_header_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_apr_hash_t[] = { {&_swigt__p_p_apr_hash_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t[] = { {&_swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void__p_svn_error_t[] = { {&_swigt__p_p_f_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void[] = { {&_swigt__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_authz_t[] = { {&_swigt__p_p_svn_authz_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_delta_editor_t[] = { {&_swigt__p_p_svn_delta_editor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_dirent_t[] = { {&_swigt__p_p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_fs_txn_t[] = { {&_swigt__p_p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_lock_t[] = { {&_swigt__p_p_svn_lock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_repos_parse_fns2_t[] = { {&_swigt__p_p_svn_repos_parse_fns2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_repos_parse_fns_t[] = { {&_swigt__p_p_svn_repos_parse_fns_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_repos_t[] = { {&_swigt__p_p_svn_repos_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_stream_t[] = { {&_swigt__p_p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_svn_string_t[] = { {&_swigt__p_p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_baton_t[] = { {&_swigt__p_svn_auth_baton_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_cred_simple_t[] = { {&_swigt__p_svn_auth_cred_simple_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_cred_ssl_client_cert_pw_t[] = { {&_swigt__p_svn_auth_cred_ssl_client_cert_pw_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_cred_ssl_client_cert_t[] = { {&_swigt__p_svn_auth_cred_ssl_client_cert_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_cred_ssl_server_trust_t[] = { {&_swigt__p_svn_auth_cred_ssl_server_trust_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_cred_username_t[] = { {&_swigt__p_svn_auth_cred_username_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_iterstate_t[] = { {&_swigt__p_svn_auth_iterstate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_provider_object_t[] = { {&_swigt__p_svn_auth_provider_object_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_provider_t[] = { {&_swigt__p_svn_auth_provider_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_auth_ssl_server_cert_info_t[] = { {&_swigt__p_svn_auth_ssl_server_cert_info_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_authz_t[] = { {&_swigt__p_svn_authz_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_commit_info_t[] = { {&_swigt__p_svn_commit_info_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_config_t[] = { {&_swigt__p_svn_config_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_delta_editor_t[] = { {&_swigt__p_svn_delta_editor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_depth_t[] = { {&_swigt__p_svn_depth_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_dirent_t[] = { {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_errno_t[] = { {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_error_t[] = { {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_access_t[] = { {&_swigt__p_svn_fs_access_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_dirent_t[] = { {&_swigt__p_svn_fs_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_history_t[] = { {&_swigt__p_svn_fs_history_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_id_t[] = { {&_swigt__p_svn_fs_id_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_pack_notify_action_t[] = { {&_swigt__p_svn_fs_pack_notify_action_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_path_change2_t[] = { {&_swigt__p_svn_fs_path_change2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_path_change_kind_t[] = { {&_swigt__p_svn_fs_path_change_kind_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_path_change_t[] = { {&_swigt__p_svn_fs_path_change_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_root_t[] = { {&_swigt__p_svn_fs_root_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_t[] = { {&_swigt__p_svn_fs_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_fs_txn_t[] = { {&_swigt__p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = { {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_io_dirent_t[] = { {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_io_file_del_t[] = { {&_swigt__p_svn_io_file_del_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_location_segment_t[] = { {&_swigt__p_svn_location_segment_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_lock_t[] = { {&_swigt__p_svn_lock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_log_changed_path2_t[] = { {&_swigt__p_svn_log_changed_path2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_log_changed_path_t[] = { {&_swigt__p_svn_log_changed_path_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_log_entry_t[] = { {&_swigt__p_svn_log_entry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_merge_range_t[] = { {&_swigt__p_svn_merge_range_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_mergeinfo_inheritance_t[] = { {&_swigt__p_svn_mergeinfo_inheritance_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_node_kind_t[] = { {&_swigt__p_svn_node_kind_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_opt_revision_range_t[] = { {&_swigt__p_svn_opt_revision_range_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_opt_revision_t[] = { {&_swigt__p_svn_opt_revision_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_opt_revision_value_t[] = { {&_swigt__p_svn_opt_revision_value_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_opt_subcommand_desc2_t[] = { {&_swigt__p_svn_opt_subcommand_desc2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_opt_subcommand_desc_t[] = { {&_swigt__p_svn_opt_subcommand_desc_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_prop_kind[] = { {&_swigt__p_svn_prop_kind, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_authz_access_t[] = { {&_swigt__p_svn_repos_authz_access_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_node_t[] = { {&_swigt__p_svn_repos_node_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_notify_action_t[] = { {&_swigt__p_svn_repos_notify_action_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_notify_t[] = { {&_swigt__p_svn_repos_notify_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_notify_warning_t[] = { {&_swigt__p_svn_repos_notify_warning_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_parse_fns2_t[] = { {&_swigt__p_svn_repos_parse_fns2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_parse_fns_t[] = { {&_swigt__p_svn_repos_parse_fns_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_revision_access_level_t[] = { {&_swigt__p_svn_repos_revision_access_level_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_repos_t[] = { {&_swigt__p_svn_repos_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_stream_mark_t[] = { {&_swigt__p_svn_stream_mark_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_stream_t[] = { {&_swigt__p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_string_t[] = { {&_swigt__p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_stringbuf_t[] = { {&_swigt__p_svn_stringbuf_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_tristate_t[] = { {&_swigt__p_svn_tristate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_txdelta_op_t[] = { {&_swigt__p_svn_txdelta_op_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_txdelta_stream_t[] = { {&_swigt__p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_txdelta_window_t[] = { {&_swigt__p_svn_txdelta_window_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_version_checklist_t[] = { {&_swigt__p_svn_version_checklist_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_svn_version_t[] = { {&_swigt__p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_apr_array_header_t,
_swigc__p_apr_hash_t,
_swigc__p_apr_int32_t,
_swigc__p_apr_int64_t,
_swigc__p_apr_pool_t,
_swigc__p_char,
_swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_p_svn_stream_t_p_void__p_svn_error_t,
_swigc__p_f_p_p_void_p_apr_hash_t_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_q_const__svn_commit_info_t_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_svn_location_segment_t_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_svn_txdelta_window_handler_t_p_p_void_p_void__p_svn_error_t,
_swigc__p_f_p_void__p_svn_error_t,
_swigc__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_void_p_apr_hash_t_svn_revnum_t_p_q_const__char_p_q_const__char_p_q_const__char_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_void_p_q_const__char__p_svn_error_t,
_swigc__p_f_p_void_p_q_const__char_p_q_const__svn_string_t__p_svn_error_t,
_swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
_swigc__p_f_p_void_p_svn_log_entry_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_f_svn_revnum_t_p_q_const__char_p_q_const__char_p_void__p_svn_error_t,
_swigc__p_int,
_swigc__p_long,
_swigc__p_p_apr_array_header_t,
_swigc__p_p_apr_hash_t,
_swigc__p_p_char,
_swigc__p_p_f_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
_swigc__p_p_f_p_void__p_svn_error_t,
_swigc__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
_swigc__p_p_f_p_void_p_q_const__struct_svn_repos_notify_t_p_apr_pool_t__void,
_swigc__p_p_f_svn_repos_authz_access_t_p_svn_boolean_t_p_svn_fs_root_t_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
_swigc__p_p_svn_authz_t,
_swigc__p_p_svn_delta_editor_t,
_swigc__p_p_svn_dirent_t,
_swigc__p_p_svn_fs_txn_t,
_swigc__p_p_svn_lock_t,
_swigc__p_p_svn_repos_parse_fns2_t,
_swigc__p_p_svn_repos_parse_fns_t,
_swigc__p_p_svn_repos_t,
_swigc__p_p_svn_stream_t,
_swigc__p_p_svn_string_t,
_swigc__p_p_void,
_swigc__p_svn_auth_baton_t,
_swigc__p_svn_auth_cred_simple_t,
_swigc__p_svn_auth_cred_ssl_client_cert_pw_t,
_swigc__p_svn_auth_cred_ssl_client_cert_t,
_swigc__p_svn_auth_cred_ssl_server_trust_t,
_swigc__p_svn_auth_cred_username_t,
_swigc__p_svn_auth_iterstate_t,
_swigc__p_svn_auth_provider_object_t,
_swigc__p_svn_auth_provider_t,
_swigc__p_svn_auth_ssl_server_cert_info_t,
_swigc__p_svn_authz_t,
_swigc__p_svn_commit_info_t,
_swigc__p_svn_config_t,
_swigc__p_svn_delta_editor_t,
_swigc__p_svn_depth_t,
_swigc__p_svn_dirent_t,
_swigc__p_svn_errno_t,
_swigc__p_svn_error_t,
_swigc__p_svn_fs_access_t,
_swigc__p_svn_fs_dirent_t,
_swigc__p_svn_fs_history_t,
_swigc__p_svn_fs_id_t,
_swigc__p_svn_fs_pack_notify_action_t,
_swigc__p_svn_fs_path_change2_t,
_swigc__p_svn_fs_path_change_kind_t,
_swigc__p_svn_fs_path_change_t,
_swigc__p_svn_fs_root_t,
_swigc__p_svn_fs_t,
_swigc__p_svn_fs_txn_t,
_swigc__p_svn_io_dirent2_t,
_swigc__p_svn_io_dirent_t,
_swigc__p_svn_io_file_del_t,
_swigc__p_svn_location_segment_t,
_swigc__p_svn_lock_t,
_swigc__p_svn_log_changed_path2_t,
_swigc__p_svn_log_changed_path_t,
_swigc__p_svn_log_entry_t,
_swigc__p_svn_merge_range_t,
_swigc__p_svn_mergeinfo_inheritance_t,
_swigc__p_svn_node_kind_t,
_swigc__p_svn_opt_revision_range_t,
_swigc__p_svn_opt_revision_t,
_swigc__p_svn_opt_revision_value_t,
_swigc__p_svn_opt_subcommand_desc2_t,
_swigc__p_svn_opt_subcommand_desc_t,
_swigc__p_svn_prop_kind,
_swigc__p_svn_repos_authz_access_t,
_swigc__p_svn_repos_node_t,
_swigc__p_svn_repos_notify_action_t,
_swigc__p_svn_repos_notify_t,
_swigc__p_svn_repos_notify_warning_t,
_swigc__p_svn_repos_parse_fns2_t,
_swigc__p_svn_repos_parse_fns_t,
_swigc__p_svn_repos_revision_access_level_t,
_swigc__p_svn_repos_t,
_swigc__p_svn_stream_mark_t,
_swigc__p_svn_stream_t,
_swigc__p_svn_string_t,
_swigc__p_svn_stringbuf_t,
_swigc__p_svn_tristate_t,
_swigc__p_svn_txdelta_op_t,
_swigc__p_svn_txdelta_stream_t,
_swigc__p_svn_txdelta_window_t,
_swigc__p_svn_version_checklist_t,
_swigc__p_svn_version_t,
_swigc__p_unsigned_long,
_swigc__p_void,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned staticly to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int found, init;
clientdata = clientdata;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
module_head = &swig_module;
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
found=0;
iter=module_head;
do {
if (iter==&swig_module) {
found=1;
break;
}
iter=iter->next;
} while (iter!= module_head);
/* if the is found in the list, then all is done and we may leave */
if (found) return;
/* otherwise we must add out module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpeters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("<Swig global variables>");
#else
return PyString_FromString("<Swig global variables>");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
char *tmp;
PyObject *str = swig_varlink_str(v);
fprintf(fp,"Swig global variables ");
fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
SWIG_Python_str_DelForPy3(tmp);
Py_DECREF(str);
return 0;
}
SWIGINTERN void
swig_varlink_dealloc(swig_varlinkobject *v) {
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
/* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
(char *)"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
(printfunc) swig_varlink_print, /* tp_print */
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
0, /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
0, /* tp_version */
#endif
#ifdef COUNT_ALLOCS
0,0,0,0 /* tp_alloc -> tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
#if PY_VERSION_HEX < 0x02020000
varlink_type.ob_type = &PyType_Type;
#else
if (PyType_Ready(&varlink_type) < 0)
return NULL;
#endif
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
strncpy(gv->name,name,size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
SWIGINTERN PyObject *
SWIG_globals(void) {
static PyObject *_SWIG_globals = 0;
if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
return _SWIG_globals;
}
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------*/
/* Fix SwigMethods to carry the callback ptrs when needed */
/* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods,
swig_const_info *const_table,
swig_type_info **types,
swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (c && (c = strstr(c, "swig_ptr: "))) {
int j;
swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
strncpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
strncpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
# if PY_VERSION_HEX >= 0x03020000
PyModuleDef_HEAD_INIT,
# else
{
PyObject_HEAD_INIT(NULL)
NULL, /* m_init */
0, /* m_index */
NULL, /* m_copy */
},
# endif
(char *) SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
(PyCFunction) SwigPyObject_own,
(PyCFunction) SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyObject *metatype_args;
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
/* metatype is used to implement static member variables. */
metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
assert(metatype_args);
metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
assert(metatype);
Py_DECREF(metatype_args);
metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
assert(PyType_Ready(metatype) >= 0);
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule((char *) SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
} else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
SWIG_Python_SetConstant(d, "svn_node_action_change",SWIG_From_long((long)(svn_node_action_change)));
SWIG_Python_SetConstant(d, "svn_node_action_add",SWIG_From_long((long)(svn_node_action_add)));
SWIG_Python_SetConstant(d, "svn_node_action_delete",SWIG_From_long((long)(svn_node_action_delete)));
SWIG_Python_SetConstant(d, "svn_node_action_replace",SWIG_From_long((long)(svn_node_action_replace)));
SWIG_Python_SetConstant(d, "svn_repos_load_uuid_default",SWIG_From_long((long)(svn_repos_load_uuid_default)));
SWIG_Python_SetConstant(d, "svn_repos_load_uuid_ignore",SWIG_From_long((long)(svn_repos_load_uuid_ignore)));
SWIG_Python_SetConstant(d, "svn_repos_load_uuid_force",SWIG_From_long((long)(svn_repos_load_uuid_force)));
SWIG_Python_SetConstant(d, "svn_authz_none",SWIG_From_long((long)(svn_authz_none)));
SWIG_Python_SetConstant(d, "svn_authz_read",SWIG_From_long((long)(svn_authz_read)));
SWIG_Python_SetConstant(d, "svn_authz_write",SWIG_From_long((long)(svn_authz_write)));
SWIG_Python_SetConstant(d, "svn_authz_recursive",SWIG_From_long((long)(svn_authz_recursive)));
SWIG_Python_SetConstant(d, "svn_repos_notify_warning",SWIG_From_long((long)(svn_repos_notify_warning)));
SWIG_Python_SetConstant(d, "svn_repos_notify_dump_rev_end",SWIG_From_long((long)(svn_repos_notify_dump_rev_end)));
SWIG_Python_SetConstant(d, "svn_repos_notify_verify_rev_end",SWIG_From_long((long)(svn_repos_notify_verify_rev_end)));
SWIG_Python_SetConstant(d, "svn_repos_notify_dump_end",SWIG_From_long((long)(svn_repos_notify_dump_end)));
SWIG_Python_SetConstant(d, "svn_repos_notify_verify_end",SWIG_From_long((long)(svn_repos_notify_verify_end)));
SWIG_Python_SetConstant(d, "svn_repos_notify_pack_shard_start",SWIG_From_long((long)(svn_repos_notify_pack_shard_start)));
SWIG_Python_SetConstant(d, "svn_repos_notify_pack_shard_end",SWIG_From_long((long)(svn_repos_notify_pack_shard_end)));
SWIG_Python_SetConstant(d, "svn_repos_notify_pack_shard_start_revprop",SWIG_From_long((long)(svn_repos_notify_pack_shard_start_revprop)));
SWIG_Python_SetConstant(d, "svn_repos_notify_pack_shard_end_revprop",SWIG_From_long((long)(svn_repos_notify_pack_shard_end_revprop)));
SWIG_Python_SetConstant(d, "svn_repos_notify_load_txn_start",SWIG_From_long((long)(svn_repos_notify_load_txn_start)));
SWIG_Python_SetConstant(d, "svn_repos_notify_load_txn_committed",SWIG_From_long((long)(svn_repos_notify_load_txn_committed)));
SWIG_Python_SetConstant(d, "svn_repos_notify_load_node_start",SWIG_From_long((long)(svn_repos_notify_load_node_start)));
SWIG_Python_SetConstant(d, "svn_repos_notify_load_node_done",SWIG_From_long((long)(svn_repos_notify_load_node_done)));
SWIG_Python_SetConstant(d, "svn_repos_notify_load_copied_node",SWIG_From_long((long)(svn_repos_notify_load_copied_node)));
SWIG_Python_SetConstant(d, "svn_repos_notify_load_normalized_mergeinfo",SWIG_From_long((long)(svn_repos_notify_load_normalized_mergeinfo)));
SWIG_Python_SetConstant(d, "svn_repos_notify_mutex_acquired",SWIG_From_long((long)(svn_repos_notify_mutex_acquired)));
SWIG_Python_SetConstant(d, "svn_repos_notify_recover_start",SWIG_From_long((long)(svn_repos_notify_recover_start)));
SWIG_Python_SetConstant(d, "svn_repos_notify_upgrade_start",SWIG_From_long((long)(svn_repos_notify_upgrade_start)));
SWIG_Python_SetConstant(d, "svn_repos_notify_warning_found_old_reference",SWIG_From_long((long)(svn_repos_notify_warning_found_old_reference)));
SWIG_Python_SetConstant(d, "svn_repos_notify_warning_found_old_mergeinfo",SWIG_From_long((long)(svn_repos_notify_warning_found_old_mergeinfo)));
SWIG_Python_SetConstant(d, "svn_repos_notify_warning_invalid_fspath",SWIG_From_long((long)(svn_repos_notify_warning_invalid_fspath)));
SWIG_Python_SetConstant(d, "SVN_REPOS_CAPABILITY_MERGEINFO",SWIG_FromCharPtr("mergeinfo"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_MAGIC_HEADER",SWIG_FromCharPtr("SVN-fs-dump-format-version"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_FORMAT_VERSION",SWIG_From_long((long)(3)));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_UUID",SWIG_FromCharPtr("UUID"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_CONTENT_LENGTH",SWIG_FromCharPtr("Content-length"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_REVISION_NUMBER",SWIG_FromCharPtr("Revision-number"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_NODE_PATH",SWIG_FromCharPtr("Node-path"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_NODE_KIND",SWIG_FromCharPtr("Node-kind"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_NODE_ACTION",SWIG_FromCharPtr("Node-action"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_NODE_COPYFROM_PATH",SWIG_FromCharPtr("Node-copyfrom-path"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_NODE_COPYFROM_REV",SWIG_FromCharPtr("Node-copyfrom-rev"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_MD5",SWIG_FromCharPtr("Text-copy-source-md5"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_SHA1",SWIG_FromCharPtr("Text-copy-source-sha1"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_CHECKSUM",SWIG_FromCharPtr("Text-copy-source-md5"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_CONTENT_MD5",SWIG_FromCharPtr("Text-content-md5"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_CONTENT_SHA1",SWIG_FromCharPtr("Text-content-sha1"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_CONTENT_CHECKSUM",SWIG_FromCharPtr("Text-content-md5"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH",SWIG_FromCharPtr("Prop-content-length"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_CONTENT_LENGTH",SWIG_FromCharPtr("Text-content-length"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_PROP_DELTA",SWIG_FromCharPtr("Prop-delta"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_DELTA",SWIG_FromCharPtr("Text-delta"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_MD5",SWIG_FromCharPtr("Text-delta-base-md5"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_SHA1",SWIG_FromCharPtr("Text-delta-base-sha1"));
SWIG_Python_SetConstant(d, "SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_CHECKSUM",SWIG_FromCharPtr("Text-delta-base-md5"));
SWIG_Python_SetConstant(d, "svn_repos_revision_access_none",SWIG_From_long((long)(svn_repos_revision_access_none)));
SWIG_Python_SetConstant(d, "svn_repos_revision_access_partial",SWIG_From_long((long)(svn_repos_revision_access_partial)));
SWIG_Python_SetConstant(d, "svn_repos_revision_access_full",SWIG_From_long((long)(svn_repos_revision_access_full)));
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
| 32.992847
| 559
| 0.689176
|
[
"object"
] |
b21c4640d1687cbc65a5bccd8946b9f686ad0a33
| 4,311
|
h
|
C
|
src/eptools/potentials/EPPotentialFactory.h
|
mseeger/apbsint
|
6acd73fb1d7b5168f3cee8584a8074d6617478a6
|
[
"BSD-3-Clause"
] | 9
|
2016-01-09T10:37:11.000Z
|
2021-11-21T08:41:02.000Z
|
src/eptools/potentials/EPPotentialFactory.h
|
mseeger/apbsint
|
6acd73fb1d7b5168f3cee8584a8074d6617478a6
|
[
"BSD-3-Clause"
] | null | null | null |
src/eptools/potentials/EPPotentialFactory.h
|
mseeger/apbsint
|
6acd73fb1d7b5168f3cee8584a8074d6617478a6
|
[
"BSD-3-Clause"
] | 4
|
2017-01-25T17:59:44.000Z
|
2020-10-26T17:48:18.000Z
|
/* -------------------------------------------------------------------
* LHOTSE: Toolbox for adaptive statistical models
* -------------------------------------------------------------------
* Project source file
* Module: eptools
* Desc.: Header class EPPotentialFactory
* ------------------------------------------------------------------- */
#ifndef EPTOOLS_EPPOTENTIALFACTORY_H
#define EPTOOLS_EPPOTENTIALFACTORY_H
#if HAVE_CONFIG_H
# include <config.h>
#endif
#include "src/eptools/potentials/EPScalarPotential.h"
//BEGINNS(eptools)
/**
* Provides factory method for supported 'EPScalarPotential'
* subclasses. All these have to be registered here with a unique
* ID.
* <p>
* Registration is static and compile-time, nothing fancy. The
* subclass 'EPPotentialNamedFactory' also maintains the
* association
* Name (string) -> ID (nonneg. int)
* Here, Name is exposed towards interface and must not change,
* while IDs may change internally.
* <p>
* NOTE: Can this be done better? The implementation has to modified
* for every new 'EPScalarPotential' subclass, and each static method
* here has to be modified.
* Would be better if subclasses registered themselves here, passing
* information and function pointers (would not work for constructors).
* ==> ???
*
* @author Matthias Seeger
* @version %I% %G%
*/
class EPPotentialFactory
{
protected:
// Internal constants (potential IDs)
static const int potGaussian =0;
static const int potLaplace =1;
static const int potProbit =2;
static const int potHeaviside =3;
static const int potExponential =4;
static const int potQuantRegress=5;
static const int potGaussMixture=6;
static const int potSpikeSlab =7;
static const int potLast =7;
#ifdef HAVE_WORKAROUND
#include "src/eptools/potentials/EPPotentialFactory_workaround.h"
#endif
public:
// Public static methods
static bool isValidID(int pid) {
#ifndef HAVE_WORKAROUND
return (pid>=0 && pid<=potLast);
#else
return (pid>=0 && pid<=potLast) || (pid>=potFirst_workaround &&
pid<=potLast_workaround);
#endif
}
/**
* See 'EPScalarPotential' comments.
*
* @param pid Potential ID
* @return Argument group ID ('EPScalarPotential::atypeXXX')
*/
static int getArgumentGroup(int pid);
/**
* Creates 'EPScalarPotential' object of correct type, given ID.
* In 'pv', a valid initial parameter vector has to be passed. Use
* 'createDefault' for default construction.
* <p>
* In 'annot', a void* to an annotation can be passed. This is ignored
* by types which do not have annotations, but is mandatory for types
* which do.
* NOTE: The validity of a non-zero 'annot' is not checked. Passing
* an invalid can lead to a crash.
*
* @param pid Potential ID
* @param pv Initial parameter vector
* @param annot S.a. Def.: 0
* @return New object
*/
static EPScalarPotential* create(int pid,const double* pv,void* annot=0);
/**
* Creates 'EPScalarPotential' object of correct type, given ID. The
* default constructor of the type is called. The type may require
* construction parameters (see 'EPScalarPotential' header comments),
* in which case 'pv' must point to these. Otherwise, 'pv' is ignored.
* <p>
* In 'annot', a void* to an annotation can be passed. This is ignored
* by types which do not have annotations, but is mandatory for types
* which do.
* NOTE: The validity of a non-zero 'annot' is not checked. Passing
* an invalid can lead to a crash.
*
* @param pid Potential ID
* @param pv Construction parameters. Def.: 0
* @param annot S.a. Def.: 0
* @return New object
*/
static EPScalarPotential* createDefault(int pid,const double* pv=0,
void* annot=0);
#ifdef HAVE_WORKAROUND
protected:
static int getArgumentGroup_workaround(int pid);
static EPScalarPotential* create_workaround(int pid,const double* pv,
void* annot);
static EPScalarPotential* createDefault_workaround(int pid,const double* pv,
void* annot);
public:
#endif
};
//ENDNS
#endif
| 32.659091
| 80
| 0.637207
|
[
"object",
"vector"
] |
b2226b71612560324a08c57bca02f7e2421114f7
| 317
|
h
|
C
|
wbs/src/Basic/CreateAnimation.h
|
RNCan/WeatherBasedSimulationFramework
|
19df207d11b1dddf414d78e52bece77f31d45df8
|
[
"MIT"
] | 6
|
2017-05-26T21:19:41.000Z
|
2021-09-03T14:17:29.000Z
|
wbs/src/Basic/CreateAnimation.h
|
RNCan/WeatherBasedSimulationFramework
|
19df207d11b1dddf414d78e52bece77f31d45df8
|
[
"MIT"
] | 5
|
2016-02-18T12:39:58.000Z
|
2016-03-13T12:57:45.000Z
|
wbs/src/Basic/CreateAnimation.h
|
RNCan/WeatherBasedSimulationFramework
|
19df207d11b1dddf414d78e52bece77f31d45df8
|
[
"MIT"
] | 1
|
2019-06-16T02:49:20.000Z
|
2019-06-16T02:49:20.000Z
|
#pragma once
//#include <windows.h>
//#include <commctrl.h>
//#include <stdio.h>
#include "ERMsg.h"
#include <string>
#include <vector>
namespace WBSF
{
ERMsg MakeGIF(std::string output_file_path, const std::vector<std::string>& file_list, unsigned short delay=20, bool bLoop=true);
}
| 14.409091
| 131
| 0.656151
|
[
"vector"
] |
b223d033f6f5d0731c6d199b441e4470aa181c5c
| 82,000
|
c
|
C
|
Library/ajsrc/sopwith2.c
|
denisjackman/Cee
|
2176e9dccc17ac93463bd5473f437f1c76ba9c3c
|
[
"CC-BY-4.0"
] | null | null | null |
Library/ajsrc/sopwith2.c
|
denisjackman/Cee
|
2176e9dccc17ac93463bd5473f437f1c76ba9c3c
|
[
"CC-BY-4.0"
] | 2
|
2016-06-30T14:31:43.000Z
|
2016-07-01T08:43:03.000Z
|
Library/ajsrc/sopwith2.c
|
denisjackman/game
|
2176e9dccc17ac93463bd5473f437f1c76ba9c3c
|
[
"CC-BY-4.0"
] | null | null | null |
/* Source code for Sopwith
Reverse-engineered by Andrew Jenner
Copyright (c) 1984-2000 David L Clark
Copyright (c) 1999-2001 Andrew Jenner
All rights reserved except as specified in the file license.txt.
Distribution of this file without the license.txt file accompanying is
prohibited.
*/
#include <ctype.h>
#include <stdio.h>
#include <setjmp.h>
#include <stdlib.h>
#include <dos.h>
#include <alloc.h>
#include <string.h>
#include <conio.h>
#include "def.h"
#include "sopasm.h"
struct snd
{
int t2v,deltat2v;
struct snd *next,*prev;
};
typedef struct snd snd;
struct object
{
int state;
int x,y,xv,yv,rotation;
bool inverted;
int kind;
int speed,deltav,deltarot;
bool firing;
int score,ammo;
int counter;
int fuel;
struct object *source;
int height,width;
bool bombing;
int bombs,colour;
unsigned int xfrac,yfrac,xvfrac,yvfrac;
struct object *next,*prev;
int index;
int oldx,oldy;
bool onscreen,oldonscreen;
unsigned char *oldsprite;
void (*soundfunc)(struct object *p);
bool (*updatefunc)(struct object *p);
struct object *nextx,*prevx;
int deaths;
unsigned char *sprite;
int bombtime;
bool homing;
int type;
bool ishome;
snd *sndp;
};
typedef struct object object;
typedef struct
{
int colour,x,y;
} mapobject;
typedef struct
{
int *planeposes;
bool *planeflip;
int *buildingpositions;
int *buildingtypes;
} landscape;
unsigned char writecharcol=3;
int regionleft[4]={0,1155,0,2089};
int regionright[4]={0,2088,1154,10000};
object *maxobjectp=NULL;
int latency=-1;
int sine[16]={0x000, 0x062, 0x0b5, 0x0ed, 0x100, 0x0ed, 0x0b5, 0x062,
0x000,-0x062,-0x0b5,-0x0ed,-0x100,-0x0ed,-0x0b5,-0x062};
int keysprev,keyspressed,keysnext,joykeysprev;
int joykeyspressed,joykeysnext;
bool keypressedflag;
int joykeys[9]={KEY_FLIP, KEY_DESCEND,KEY_FLIP,
KEY_BRAKE,0, KEY_ACCEL,
KEY_FLIP, KEY_CLIMB, KEY_FLIP};
unsigned char scrground[320];
char enginepower[16]={0,-1,-2,-3,-4,-3,-2,-1,0,1,2,3,4,3,2,1};
int soundtype=0x7fff,soundpitch=0x7fff;
object *soundobj=NULL;
unsigned int t2v=0;
object *sndobj=NULL;
void (*soundperiodicfunc)(void)=NULL;
char *tune1[7]={
"b4/d8/d2/r16/c8/b8/a8/b4./c4./c+4./d4./",
"e4/g8/g2/r16/>a8/<g8/e8/d2./",
"b4/d8/d2/r16/c8/b8/a8/b4./c4./c+4./d4./",
"e4/>a8/a2/r16/<g8/f+8/e8/d2./",
"d8/g2/r16/g8/g+2/r16/g+8/>a2/r16/a8/c2/r16/",
"b8/a8/<g8/>b4/<g8/>b4/<g8/>a4./<g1/",
""};
int enginestutter[50]={ /* No idea what the more significant bits are */
0x90b9,0xbcfb,0x6564,0x3313,0x3190,0xa980,0xbcf0,0x6f97,0x37f4,0x064b,
0x9fd8,0x595b,0x1eee,0x820c,0x4201,0x651e,0x848e,0x15d5,0x1de7,0x1585,
0xa850,0x213b,0x3953,0x1eb0,0x97a7,0x35dd,0xaf2f,0x1629,0xbe9b,0x243f,
0x847d,0x313a,0x3295,0xbc11,0x6e6d,0x3398,0xad43,0x51ce,0x8f95,0x507e,
0x499e,0x3bc1,0x5243,0x2017,0x9510,0x9865,0x65f6,0x6b56,0x36b9,0x5026};
int stutterp=0;
int majorscale[7]={0,2,3,5,7,8,10};
int notefreq[12]={440,466,494,523,554,587,622,659,698,740,784,831};
int singleplanes[2]={0,7};
int computerplanes[4]={0,7,1,6};
int multipleplanes[8]={0,7,3,4,2,5,1,6};
int flockx[4]={370,1370,1630,2630};
int flocky[4]={199,199,199,199};
int flockxv[4]={2,2,-2,-2};
int fscatterx[8]={8,3,0,6,7,14,10,12};
int fscattery[8]={16,1,8,3,12,10,7,14};
int fscatterxv[8]={-2,2,-3,3,-1,1,0,0};
int fscatteryv[8]={-1,-2,-1,-2,-1,-2,-1,-2};
int oxx[2]={1376,1608};
int oxy[2]={80,91};
int crater[8]={1,2,2,3,3,2,2,1};
#include "ground.c"
#include "sprites.c"
int worldplaneposes[8]={1270,588,1330,1360,1630,1660,2456,1720};
/* 2456 was 2464 */
bool worldplaneflip[8]={FALSE,FALSE,FALSE,FALSE,TRUE,TRUE,TRUE,TRUE};
int worldbuildingpositions[20]={
191,284,409,539,685,807,934,1210,1240,1440,
1550,1750,1780,2024,2159,2279,2390,2549,2678,2763};
int worldbuildingtypes[20]={
BUILDING_CHIM,BUILDING_TANK,BUILDING_CHIM,BUILDING_CHIM,BUILDING_TANK,
BUILDING_FLAG,BUILDING_CHIM,BUILDING_FUEL,BUILDING_FLAG,BUILDING_TANK,
BUILDING_TANK,BUILDING_FLAG,BUILDING_FUEL,BUILDING_CHIM,BUILDING_CHIM,
BUILDING_TANK,BUILDING_TANK,BUILDING_FLAG,BUILDING_FLAG,BUILDING_CHIM};
landscape worlds[1]={
worldplaneposes,worldplaneflip,worldbuildingpositions,worldbuildingtypes};
int autodeltarot[3]={0,-1,1};
int huge *historybuf;
long historyspace;
FILE *outputfile;
int huge *historyp;
int historykeys;
long historyfilelen;
bool recording;
int gamemode;
bool multiplayer;
landscape *world=NULL;
object *buildings[20];
int buildingc[2];
int timertick,frametick,speedtick;
int level,radarrange2;
unsigned char scrbuf[0x2000];
bool hiresflag;
bool notitlesflag;
bool soundflag,statsflag,joyrequested,ibmkeyboard,inplay=FALSE;
int scnleft,scnright,pixtoscroll;
unsigned int scrseg,scroff,interlacediff;
bool groundnotdrawn;
object *objects;
object homes[4];
object *lastobject,*firstobject,*nextobject,*firstdeleted,*lastdeleted;
object objleft,objright;
object *attackees[4];
int finaleflags[4],finaletime,playerindex=0,planeindex;
bool planeisplayer,planeisenemy;
mapobject mapobjects[100];
bool finaleflying,cratertobedrawn;
char *playbackfilename,*recordfilename;
int randno;
bool breakf;
int latencycount,finaleflag,maxlives;
jmp_buf startjbuf;
bool exiting=FALSE;
snd sndlist[100];
snd *lastsnd,*nextsnd;
int slidec,numshrapnelsnd,tuneptr2,tuneline2;
unsigned int t2v2;
int tunetime2,octavemul2;
bool tune3f;
int tuneptr3,tuneline3;
unsigned int t2v3;
int tunetime3,octavemul3;
char **tune;
int tuneline,tuneptr,t2v1,tunedur,octavemultiplier;
int ot2v;
bool deceased;
int score;
object *collobj1[200];
object *collobj2[200];
int collc;
int collxv[4],collyv[4];
object *collobjs[4];
int colln,collxvr,collyvr;
unsigned char workingground[MAX_X];
object tplane;
int autoheight;
int autod2[3];
bool autodoomed[3];
int autoalt[3];
int leftbuilding,rightbuilding;
void main(int argc,char *argv[]);
void keybint(void);
int inkeys(void);
void updatejoy(void);
int readjoychannel(int channel);
void flushbuf(void);
void setcolour(int c);
void updatescreen(void);
void updateground(void);
void drawground(unsigned char *scrground);
void clearscorearea(void);
void drawobject(int x,int y,object *obj);
void putpixel(int x,int y,int c);
int bitblt(int x,int y,object *obj);
int pixel(int x,int y,int c);
void putimage(int x,int y,unsigned char *p,object *obj);
void updateobjects(void);
bool updateplayerplane(object *plane);
void processkeys(object *p,int keys);
bool updateenemyplane(object *plane);
bool updateplane(object *plane);
void attackable(object *obj);
void refuel(object *plane);
bool increment(int *val,int max);
bool updatebullet(object *bullet);
bool updatebomb(object *bomb);
int direction(object *obj);
bool updatebuilding(object *building);
bool updateshrapnel(object *shrapnel);
bool updatesmoke(object *smoke);
bool updateflock(object *flock);
bool updatebird(object *bird);
bool updateox(object *ox);
void killplane(object *plane);
void catchfire(object *plane);
void gointospin(object *plane);
void insxlist(object *ins,object *list);
void delxlist(object *del);
void initsndlist(void);
void initsound(int type,int pitch,object *obj);
void updatesound(void);
void updatesoundint(void);
void soundslide(void);
void soundtoggle(void);
void updatetune2(void);
void setsound2(void);
void updatetune3(void);
void sound3(void);
void objectsound(object *obj,int sn);
snd *createsnd(void);
void destroysnd(snd *s);
void killsnd(object *o);
void ssound(unsigned int t2);
void snosound(void);
int getenginestutter(int f);
void updatetune(void);
void init(int argc,char *argv[]);
void initrand(void);
void restart(void);
void initdifficulty(void);
void clearwin(void);
void getcontrol(void);
int getgamemode(void);
int getgamenumber(void);
bool testbreak(void);
void copyground(void);
void initscreen(bool drawnground);
void writescores(void);
void livesbar(object *p);
void fuelbar(object *p);
void bombsbar(object *p);
void ammobar(object *p);
void statbar(int x,int h,int hmax,int col);
void drawmapground(void);
void drawmapbuildings(void);
void useoffscreenbuf(void);
void useonscreenbuf(void);
void copyoffscbuftoscn(void);
void clearscrbuf(void);
void initlists(void);
void createenemyplane(object *pl);
void createplayerplane(object *player);
object *createplane(object *pl);
void firebullet(object *obj,object *at);
int distance(int x0,int y0,int x1,int y1);
void dropbomb(object *plane);
void createbuildings(void);
void createexplosion(object *obj);
void createsmoke(object *plane);
void createflocks(void);
void createbird(object *flock,int birdno);
void createoxen(void);
void checkcollisions(void);
void checkcollision(object *obj1,object *obj2);
void checkcrash(object *obj);
void docollision(object *obj1,object *obj2);
bool collidescore(int type,object *obj,int score);
void addscore(object *destroyed,int score);
void score50(object *destroyed);
void writescore(object *p);
void digcrater(object *obj);
void titles(void);
void soundoff(void);
void timerint(void);
void soundbomb(object *bomb);
void soundshrapnel(object *shrapnel);
void soundbuilding(object *building);
void soundplane(object *plane);
void drawmapobject(object *obj);
void finish(char *msg,bool closef);
void declarewinner(int n);
void createsun(object *player);
void gameover(object *plane);
void eogstats(void);
object *newobject(void);
void deleteobject(object *obj);
void enemylogic(object *plane);
void enemyattack(object *plane,object *attackee);
void enemyflyhome(object *plane);
void flyhome(object *plane);
bool ontarget(object *target);
void autopilot(object *plane,int destx,int desty,object *destobj,bool recursing);
void initbuildingcheck(int x,int y);
bool doomed(int x,int y,int alt);
int distsqr(int x0,int y0,int x1,int y1);
int getmaxplayers(void);
bool updateremoteplane(object *plane);
int inithistory(int randno);
void freehistorybuf(void);
void freeandexit(char *errmsg);
int history(int key);
void flushhistory(void);
void initcomms(void);
char *finishcomms(bool closef);
char *finishserial(void);
int getasynchkeys(object *plane);
int getmultiplekeys(object *plane);
void setvel(object *obj,int v,int dir);
void printstr(char *str);
void moveobject(object *obj,int *x,int *y);
void getopt(int *argc,char **argv[],char *format,...);
void writenum(int n,int width);
void initasynch(void);
void createasynchremoteplane(void);
int inkey(void);
void main(int argc,char* argv[])
{
int nmodes,ncontrols,i;
bool modes=FALSE,modec=FALSE,modem=FALSE,modea=FALSE,keybflag=FALSE;
objects=(object *)malloc(100*sizeof(object));
if (objects==NULL) {
printf("Cannot allocate memory for object list.\n");
exit(1);
}
delay(0);
getopt(&argc,&argv,"w&y#q&e&g#s&c&m&a&j&k&i&h*v*:sopwith2*",
&hiresflag, /* -w */
&latency, /* -y[num] */
&soundflag, /* -q (quiet) */
&statsflag, /* -e (print end of game statistics) */
&level, /* -g[num] */
&modes, /* -s */
&modec, /* -c */
&modem, /* -m */
&modea, /* -a */
&joyrequested, /* -j */
&keybflag, /* -k */
&ibmkeyboard, /* -i */
&recordfilename, /* -h[string] (record) */
&playbackfilename /* -v[string] (playback) */
);
soundflag=!soundflag;
nmodes=(modes ? 1 : 0)+(modec ? 1 : 0)+(modem ? 1 : 0)+(modea ? 1 : 0);
if (nmodes>1) {
printstr("\r\nOnly one mode: -s -c -m -a may be specified\r\n");
exit(1);
}
ncontrols=(keybflag ? 1 : 0)+(joyrequested ? 1 : 0);
if (ncontrols>1) {
printstr("\r\nOnly one of -j and -k may be specified\r\n");
exit(1);
}
if (nmodes>0 && ncontrols>0)
notitlesflag=TRUE;
initrand();
randno=inithistory(randno);
getch();
initsndlist();
inittimer(timerint);
if (hiresflag)
setgmode(6);
else
setgmode(4);
if (!notitlesflag) {
initsound(SOUND_TUNE,0,NULL);
updatesound();
setcolour(3); poscurs(13,8); printstr("S O P W I T H");
setcolour(1); poscurs(12,11); printstr("BMB "); setcolour(3); printstr("Compuscience");
if (nmodes>0)
gamemode=(modes ? GAME_SINGLE : (modec ? GAME_COMPUTER :
(modem ? GAME_MULTIPLE : GAME_ASYNCH)));
else
gamemode=getgamemode();
if (ncontrols==0)
getcontrol();
}
multiplayer=(gamemode==GAME_MULTIPLE || gamemode==GAME_ASYNCH);
if (multiplayer) {
maxlives=10;
if (gamemode==GAME_MULTIPLE)
initcomms();
else
initasynch();
copyground();
initlists();
if (gamemode==GAME_ASYNCH)
createasynchremoteplane();
createbuildings();
initscreen(FALSE);
if (latency==-1)
latency=1;
}
else {
if (latency==-1)
latency=1;
maxlives=5;
world=&worlds[0];
clearwin();
copyground();
initlists();
createplayerplane(NULL);
for (i=0;i<3;i++)
createenemyplane(NULL);
createbuildings();
initscreen(FALSE);
}
createflocks();
createoxen();
initdifficulty();
initkeyboard(keybint);
inplay=TRUE;
setjmp(startjbuf);
while (TRUE) {
while (speedtick<2);
speedtick=0;
/* delay(10000); */
updateobjects();
updatejoy();
updatescreen();
updatejoy();
checkcollisions();
updatejoy();
updatesound();
}
}
void keybint(void)
{
int scancode,k;
keypressedflag=TRUE;
if (!ibmkeyboard)
return;
scancode=inportb(PORT_KEYB);
switch (scancode&0x7f) {
case SC_X: k=KEY_ACCEL; break;
case SC_Z: k=KEY_BRAKE; break;
case SC_COMMA: k=KEY_CLIMB; break;
case SC_SLASH: k=KEY_DESCEND; break;
case SC_DOT: k=KEY_FLIP; break;
case SC_SPACE: k=KEY_FIRE; break;
case SC_B: k=KEY_BOMB; break;
case SC_H: k=KEY_HOME; break;
case SC_S: k=KEY_SOUND; break;
case SC_BREAK: k=KEY_BREAK; breakf=TRUE; break;
case SC_V: k=KEY_MISSILE; break;
case SC_C: k=KEY_STARBURST; break;
case SC_P:
/* if (scancode&0x80) {
paused=TRUE;
if (soundflg) {
sound(0,0);
swsound();
soundflg=FALSE;
while(paused);
soundflg=TRUE;
}
else
while(paused);
} */
break;
default: k=0;
}
if (k!=0)
if (scancode&0x80) {
if (k&keysprev)
keysnext&=~k;
keyspressed&=~k;
}
else {
keyspressed|=k;
keysnext|=k;
}
}
int inkeys(void)
{
int k;
if (!inplay)
return history(inkey());
if (ibmkeyboard) {
k=keysprev=keysnext;
keysnext=keyspressed;
while (kbhit()) getkey();
}
else {
switch(inkey()) {
case 'X': case 'x': k=KEY_ACCEL; break;
case 'Z': case 'z': k=KEY_BRAKE; break;
case '<': case ',': k=KEY_CLIMB; break;
case '?': case '/': k=KEY_DESCEND; break;
case '>': case '.': k=KEY_FLIP; break;
case ' ': k=KEY_FIRE; break;
case 'B': case 'b': k=KEY_BOMB; break;
case 'H': case 'h': k=KEY_HOME; break;
case 'S': case 's': k=KEY_SOUND; break;
default: k=0;
}
if (testbreak())
k|=KEY_BREAK;
}
if (joyrequested) {
joykeysprev=joykeysnext;
joykeysnext=joykeyspressed;
k|=joykeysprev;
}
return history(k);
}
int inkey(void)
{
if (kbhit())
return getkey();
return 0;
}
void updatejoy(void)
{
int x,y,j,r;
if (joyrequested) {
x=readjoychannel(0);
y=readjoychannel(1);
j=joykeys[(x<=640 ? 0 : (x>=1920 ? 2 : 1))+
(y<=640 ? 0 : (y>=1920 ? 6 : 3))];
r=inportb(PORT_JOY); /* Joystick */
if ((r&JOY_BUT1)==0)
j|=KEY_FIRE;
if ((r&JOY_BUT2)==0)
j|=KEY_BOMB;
joykeyspressed=j;
joykeysnext|=j;
joykeysnext&=j|~joykeysprev;
}
}
int readjoychannel(int channel)
{
int t;
if ((inportb(PORT_JOY)&(1<<channel))!=0)
return 2560;
keypressedflag=FALSE;
outportb(PORT_TIMERC,0);
t=getwordfromport(PORT_TIMER0);
outportb(PORT_JOY,0);
while ((inportb(PORT_JOY)&(1<<channel))!=0);
if (keypressedflag)
return 640;
return t-getwordfromport(PORT_TIMER0);
}
void flushbuf(void)
{
/* if (!inplay || !ibmkeyboard) */
while (kbhit())
getkey();
}
void setcolour(int c)
{
writecharcol=c;
}
void updatescreen(void)
{
object *obj;
useonscreenbuf();
for (obj=firstobject;obj!=NULL;obj=obj->next)
if (obj->oldonscreen && obj->onscreen && obj->height!=1 &&
obj->oldsprite==obj->sprite && obj->y==obj->oldy &&
obj->oldx+scnleft==obj->x) {
if (obj->soundfunc!=NULL)
obj->soundfunc(obj);
}
else {
if (obj->oldonscreen)
putimage(obj->oldx,obj->oldy,obj->oldsprite,obj);
if (!obj->onscreen)
continue;
if (obj->x>=scnleft && obj->x<=scnright) {
putimage(obj->oldx=obj->x-scnleft,obj->oldy=obj->y,obj->sprite,obj);
if (obj->soundfunc!=NULL)
obj->soundfunc(obj);
}
else
obj->onscreen=FALSE;
}
for (obj=firstdeleted;obj!=NULL;obj=obj->next)
if (obj->oldonscreen)
putimage(obj->oldx,obj->oldy,obj->oldsprite,obj);
updateground();
}
void updateground(void)
{
if (!groundnotdrawn) {
if (pixtoscroll==0 && !cratertobedrawn)
return;
drawground(scrground);
}
memcpy(scrground,workingground+scnleft,320);
drawground(scrground);
groundnotdrawn=FALSE;
cratertobedrawn=FALSE;
}
void drawground(unsigned char *scrground)
{
int y=*scrground,y2;
int x;
for (x=0;x<320;x++) {
y2=*(scrground++);
if (y2==y)
putpixel(x,y,131);
else
if (y2>y)
do
putpixel(x,y++,131);
while (y!=y2);
else
do
putpixel(x,y--,131);
while (y!=y2);
}
}
void updateobjects(void)
{
object *current,*next;
if (firstdeleted!=NULL) {
lastdeleted->next=nextobject;
nextobject=firstdeleted;
lastdeleted=firstdeleted=NULL;
}
latencycount++;
if (latencycount>=latency)
latencycount=0;
current=firstobject;
while (current!=NULL) {
next=current->next;
current->oldonscreen=current->onscreen;
current->oldsprite=current->sprite;
current->onscreen=current->updatefunc(current);
current=next;
}
frametick++;
}
bool updateplayerplane(object *plane)
{
bool result;
int x,keys;
planeisenemy=FALSE;
planeisplayer=TRUE;
planeindex=plane->index;
finaleflag=finaleflags[playerindex];
if (finaleflag!=FINALE_NONE) {
finaletime--;
if (finaletime<=0) {
if (gamemode!=GAME_MULTIPLE && gamemode!=GAME_ASYNCH && !exiting)
restart();
finish(NULL,TRUE);
}
}
if (latencycount==0) {
if (gamemode==GAME_MULTIPLE)
keys=getmultiplekeys(plane);
else {
if (gamemode==GAME_ASYNCH)
keys=getasynchkeys(plane);
else {
keys=inkeys();
flushbuf();
}
}
processkeys(plane,keys);
}
else {
plane->deltarot=0;
plane->bombing=FALSE;
}
if ((plane->state==CRASHED || plane->state==GHOSTCRASHED) &&
plane->counter<=0) {
plane->deaths++;
if (finaleflag!=FINALE_WON &&
(plane->fuel<=-5000 || (!multiplayer && plane->deaths>=5))) {
if (finaleflag==FINALE_NONE)
gameover(plane);
}
else {
createplayerplane(plane);
initscreen(TRUE);
if (finaleflag==FINALE_WON) {
if (testbreak())
finish(NULL,TRUE);
createsun(plane);
}
}
}
x=plane->x;
result=updateplane(plane);
if (x<=180 || x>=2820)
pixtoscroll=0;
else {
pixtoscroll=plane->x-x;
scnleft+=pixtoscroll;
scnright+=pixtoscroll;
}
if (!plane->ishome) {
useonscreenbuf();
if (plane->firing)
ammobar(plane);
if (plane->bombing)
bombsbar(plane);
}
return result;
}
void processkeys(object *p,int keys)
{
int state=p->state;
p->deltarot=0;
p->firing=FALSE;
p->bombing=FALSE;
if (state!=FLYING && state!=STALLED &&
state!=FALLING && state!=GHOST &&
state!=GHOSTSTALLED)
return;
if (state!=FALLING) {
if (finaleflag!=FINALE_NONE) {
if (finaleflag==FINALE_LOST && planeisplayer)
flyhome(p);
return;
}
if ((keys&KEY_BREAK)!=0) {
p->fuel=-5000;
p->homing=FALSE;
if (p->ishome) {
state=(state>=FINISHED) ? GHOSTCRASHED : CRASHED;
p->state=state;
p->counter=0;
}
if (planeisplayer)
exiting=TRUE;
}
if ((keys&KEY_HOME)!=0 &&
(state==FLYING || state==GHOST))
p->homing=TRUE;
}
if ((keys&KEY_CLIMB)!=0) {
p->deltarot++;
p->homing=FALSE;
}
if ((keys&KEY_DESCEND)!=0) {
p->deltarot--;
p->homing=FALSE;
}
if ((keys&KEY_FLIP)!=0) {
p->inverted=!p->inverted;
p->homing=FALSE;
}
if ((keys&KEY_BRAKE)!=0) {
if (p->deltav!=0)
p->deltav--;
p->homing=FALSE;
}
if ((keys&KEY_ACCEL)!=0) {
if (p->deltav<4)
p->deltav++;
p->homing=FALSE;
}
if ((keys&KEY_FIRE)!=0 && state<FINISHED)
p->firing=TRUE;
if ((keys&KEY_BOMB)!=0 && state<FINISHED)
p->bombing=TRUE;
if ((keys&KEY_SOUND)!=0 && planeisplayer) {
if (soundflag) {
initsound(SOUND_OFF,0,NULL);
updatesound();
}
soundflag=!soundflag;
}
if (p->homing)
flyhome(p);
}
bool updateenemyplane(object *plane)
{
planeisenemy=TRUE;
planeisplayer=FALSE;
plane->deltarot=0;
plane->bombing=FALSE;
planeindex=plane->index;
finaleflag=finaleflags[planeindex];
if (latencycount==0)
plane->firing=FALSE;
switch (plane->state) {
case FLYING:
case STALLED:
if (finaleflag!=FINALE_NONE)
flyhome(plane);
else
if (latencycount==0)
enemylogic(plane);
break;
case CRASHED:
plane->firing=FALSE;
if (plane->counter<=0)
if (finaleflag==FINALE_NONE)
createenemyplane(plane);
break;
default:
plane->firing=FALSE;
}
return updateplane(plane);
}
bool updateplane(object *plane)
{
int rotation,speed,x,y,state,newstate,idealspeed;
bool update;
bool spinning;
state=plane->state;
switch(state) {
case FINISHED:
case WAITING:
return FALSE;
case CRASHED:
case GHOSTCRASHED:
plane->counter--;
break;
case FALLING:
plane->counter-=2;
if (plane->yv<0 && plane->xv!=0)
if (((plane->inverted ? 1 : 0)^(plane->xv<0 ? 1 : 0))!=0)
plane->counter-=plane->deltarot;
else
plane->counter+=plane->deltarot;
if (plane->counter<=0) {
if (plane->yv<0) {
if (plane->xv<0)
plane->xv++;
else
if (plane->xv>0)
plane->xv--;
else
plane->inverted=!plane->inverted;
}
if (plane->yv>-10)
plane->yv--;
plane->counter=10;
}
plane->rotation=direction(plane)<<1;
if (plane->yv<=0)
objectsound(plane,SOUND_FALLING);
break;
case STALLED:
case GHOSTSTALLED:
case FLYING:
case GHOST:
if (state==STALLED)
newstate=FLYING;
if (state==GHOSTSTALLED)
newstate=GHOST;
if (state==STALLED || state==GHOSTSTALLED) {
spinning=(plane->rotation!=12 || plane->speed<level+4);
if (!spinning)
plane->state=state=newstate;
}
else {
spinning=(plane->y>=200);
if (spinning) {
gointospin(plane);
state=plane->state;
}
}
if (finaleflying)
break;
if (plane->fuel<=0 && !plane->ishome &&
(state==FLYING || state==STALLED)) {
catchfire(plane);
score50(plane);
return updateplane(plane);
}
rotation=plane->rotation;
speed=plane->speed;
update=FALSE;
if (plane->deltarot!=0) {
if (plane->inverted)
rotation-=plane->deltarot;
else
rotation+=plane->deltarot;
rotation&=15;
update=TRUE;
}
if ((frametick&3)==0)
if (!spinning && speed<level+4) {
speed--;
update=TRUE;
}
else {
idealspeed=enginepower[rotation]+plane->deltav+level+4;
if (speed<idealspeed) {
speed++;
update=TRUE;
}
else
if (speed>idealspeed) {
speed--;
update=TRUE;
}
}
if (update) {
if (plane->ishome) {
if (plane->deltav || plane->deltarot)
speed=level+4;
else
speed=0;
}
else
if (speed<=0 && !spinning) {
gointospin(plane);
return updateplane(plane);
}
plane->speed=speed;
plane->rotation=rotation;
if (spinning) {
plane->yvfrac=plane->xvfrac=plane->xv=0;
plane->yv=-speed;
}
else
setvel(plane,speed,rotation);
}
if (spinning) {
plane->counter--;
if (plane->counter==0) {
plane->inverted=!plane->inverted;
plane->rotation=(8-plane->rotation)&15;
plane->counter=6;
}
}
if (plane->firing)
firebullet(plane,NULL);
if (plane->bombing)
dropbomb(plane);
if (!planeisenemy) {
if (planeisplayer && plane->speed>plane->fuel%900) {
useonscreenbuf();
fuelbar(plane);
}
plane->fuel-=plane->speed;
}
if (plane->speed!=0)
plane->ishome=FALSE;
}
if (finaleflag==FINALE_WON && planeisplayer && finaleflying)
plane->sprite=finalesprites[0][finaletime/18];
else
if (plane->state==FINISHED)
plane->sprite=NULL;
else
if (plane->state==FALLING && plane->xv==0 && plane->yv<0)
plane->sprite=fallingsprites[plane->inverted ? 1 : 0];
else
plane->sprite=planesprites[0][plane->inverted ? 1 : 0][plane->rotation];
moveobject(plane,&x,&y);
if (x<0)
plane->x=x=0;
else
if (x>=2984)
plane->x=x=2984;
if (!planeisenemy &&
(plane->state==FLYING || plane->state==STALLED) &&
finaleflags[playerindex]==FINALE_NONE)
attackable(plane);
delxlist(plane);
insxlist(plane,plane->nextx);
if (plane->bombtime)
plane->bombtime--;
if (!planeisenemy && plane->ishome && plane->state==FLYING)
refuel(plane);
if (y<200 && y>=0) {
if (plane->state==FALLING)
createsmoke(plane);
useonscreenbuf();
drawmapobject(plane);
if (!planeisplayer)
return (plane->state<FINISHED);
return TRUE;
}
return FALSE;
}
void attackable(object *obj)
{
object *plane,*attackee;
int i,x=obj->x,colour=obj->source->colour;
for (plane=firstobject+1,i=1;plane->type==OBJ_PLANE;plane++,i++)
if (plane->source->colour!=colour && plane->updatefunc==updateenemyplane &&
(gamemode!=GAME_COMPUTER || (regionleft[i]<=x &&
regionright[i]>=x))) {
attackee=attackees[i];
if (attackee==NULL || abs(x-plane->x)<abs(attackee->x-plane->x))
attackees[i]=obj;
}
}
void refuel(object *plane)
{
useonscreenbuf();
if (increment(&(plane->fuel),MAX_FUEL))
fuelbar(plane);
if (increment(&(plane->ammo),200))
ammobar(plane);
if (increment(&(plane->bombs),5))
bombsbar(plane);
}
bool increment(int *val,int max)
{
bool redraw=FALSE;
if (*val==max)
return redraw;
if (max<20) {
if (frametick%20==0) {
(*val)++;
redraw=planeisplayer;
}
}
else {
*val+=max/100;
redraw=planeisplayer;
}
if (*val>max)
*val=max;
return redraw;
}
bool updatebullet(object *bullet)
{
int x,y;
delxlist(bullet);
bullet->fuel--;
if (bullet->fuel==0) {
deleteobject(bullet);
return FALSE;
}
moveobject(bullet,&x,&y);
if (x<0 || x>=MAX_X || y<=workingground[x] || y>=200) {
deleteobject(bullet);
return FALSE;
}
insxlist(bullet,bullet->nextx);
bullet->sprite=(unsigned char *)131;
return TRUE;
}
bool updatebomb(object *bomb)
{
int x,y;
delxlist(bomb);
if (bomb->fuel<0) {
deleteobject(bomb);
bomb->state=FINISHED;
useonscreenbuf();
drawmapobject(bomb);
return FALSE;
}
bomb->fuel--;
if (bomb->fuel==0) {
if (bomb->yv<0)
if (bomb->xv<0)
bomb->xv++;
else
if (bomb->xv>0)
bomb->xv--;
if (bomb->yv>-10)
bomb->yv--;
bomb->fuel=5;
}
if (bomb->yv<=0)
objectsound(bomb,SOUND_BOMB);
moveobject(bomb,&x,&y);
if (x<0 || x>=MAX_X || y<0) {
deleteobject(bomb);
killsnd(bomb);
bomb->state=FINISHED;
useonscreenbuf();
drawmapobject(bomb);
return FALSE;
}
bomb->sprite=bombsprites[0][direction(bomb)];
if (y>=200) {
insxlist(bomb,bomb->nextx);
return FALSE;
}
insxlist(bomb,bomb->nextx);
useonscreenbuf();
drawmapobject(bomb);
return TRUE;
}
int direction(object *obj)
{
int xv=obj->xv,yv=obj->yv;
if (yv>0) { if (xv<0) return 3; if (xv==0) return 2; return 1; }
if (yv==0) { if (xv<0) return 4; if (xv==0) return 6; return 0; }
if (xv<0) return 5; if (xv==0) return 6; return 7;
}
/* bool updatemissile(object* missile); */
/* bool updatestarburst(object* starburst); */
bool updatebuilding(object *building)
{
int d2;
object *at=firstobject;
building->firing=FALSE;
if (level!=0 && building->state==STANDING &&
(at->state==FLYING || at->state==STALLED) &&
building->colour!=at->colour && (level>1 || frametick&1)) {
d2=distsqr(building->x,building->y,at->x,at->y);
if (d2>0 && d2<radarrange2) {
building->firing=TRUE; /* was at */
firebullet(building,at);
}
}
building->counter--;
if (building->counter<0)
building->counter=0;
if (building->state==STANDING)
building->sprite=buildingsprites[0][building->kind];
else
building->sprite=debrissprites[0];
return TRUE;
}
bool updateshrapnel(object *shrapnel)
{
int x,y,kind;
kind=shrapnel->kind;
delxlist(shrapnel);
if (shrapnel->fuel<0) {
if (kind!=0)
killsnd(shrapnel);
deleteobject(shrapnel);
return FALSE;
}
shrapnel->fuel--;
if (shrapnel->fuel==0) {
if (shrapnel->yv<0)
if (shrapnel->xv<0)
shrapnel->xv++;
else
if (shrapnel->xv>0)
shrapnel->xv--;
if ((shrapnel->kind!=0 && shrapnel->yv>-10) ||
(shrapnel->kind==0 && shrapnel->yv>-(level+4)))
shrapnel->yv--;
shrapnel->fuel=3;
}
moveobject(shrapnel,&x,&y);
if (x<0 || x>=MAX_X || y<=workingground[x]) {
if (kind!=0)
killsnd(shrapnel);
deleteobject(shrapnel);
return FALSE;
}
shrapnel->counter++;
shrapnel->sprite=shrapnelsprites[shrapnel->kind];
if (y>=200) {
insxlist(shrapnel,shrapnel->nextx);
return FALSE;
}
insxlist(shrapnel,shrapnel->nextx);
return TRUE;
}
bool updatesmoke(object *smoke)
{
smoke->fuel--;
if (smoke->fuel==0 ||
(smoke->source->state!=FALLING &&
smoke->source->state!=CRASHED)) {
deleteobject(smoke);
return FALSE;
}
smoke->sprite=(unsigned char *)(smoke->colour+128);
return TRUE;
}
bool updateflock(object *flock)
{
int x,y;
delxlist(flock);
if (flock->fuel==-1) {
useonscreenbuf();
drawmapobject(flock);
deleteobject(flock);
return FALSE;
}
flock->fuel--;
if (flock->fuel==0) {
flock->inverted=!flock->inverted;
flock->fuel=5;
}
if (flock->x<370 || flock->x>2630)
flock->xv=-flock->xv;
moveobject(flock,&x,&y);
insxlist(flock,flock->nextx);
flock->sprite=flocksprites[flock->inverted ? 1 : 0];
useonscreenbuf();
drawmapobject(flock);
return TRUE;
}
bool updatebird(object *bird)
{
int x,y;
delxlist(bird);
if (bird->fuel==-1) {
deleteobject(bird);
return FALSE;
}
if (bird->fuel==-2) {
bird->yv=-bird->yv;
bird->xv=(frametick&7)-4;
bird->fuel=4;
}
else {
bird->fuel--;
if (bird->fuel==0) {
bird->inverted=!bird->inverted;
bird->fuel=4;
}
}
moveobject(bird,&x,&y);
bird->sprite=birdsprites[bird->inverted ? 1 : 0];
if (x<0 || x>=MAX_X || y<=workingground[x] || y>=200) {
bird->y-=bird->yv;
bird->fuel=-2;
insxlist(bird,bird->nextx);
return FALSE;
}
insxlist(bird,bird->nextx);
return TRUE;
}
bool updateox(object *ox)
{
ox->sprite=oxsprites[ox->state==STANDING ? 0 : 1];
return TRUE;
}
void declarewinner(int n)
{
int colour;
object *player;
if (multiplayer /* && netinf->maxplayers!=1 */)
if (firstobject[1].score==firstobject[0].score)
colour=3-n;
else
colour=(firstobject[1].score>firstobject[0].score ? 1 : 0)+1;
else
colour=1;
for (player=firstobject;player->type==OBJ_PLANE;player=player->next)
if (finaleflags[player->index]==FINALE_NONE) {
if (player->colour==colour && (player->deaths<4 || (player->deaths<5 &&
(player->state==FLYING || player->state==STALLED))))
createsun(player);
else
gameover(player);
}
}
void createsun(object *player)
{
int index;
finaleflags[index=player->index]=FINALE_WON;
if (index==playerindex) {
finaletime=72;
finaleflying=TRUE;
player->yvfrac=0;
player->xvfrac=0;
player->yv=0;
player->xv=0;
player->state=FLYING;
player->fuel=MAX_FUEL;
player->speed=4;
}
}
void gameover(object *plane)
{
int player=plane->index;
finaleflags[player]=FINALE_LOST;
if (player==playerindex) {
setcolour(130);
poscurs(16,12);
printstr("THE END");
finaletime=20;
}
}
void enemylogic(object *plane)
{
object *attackee=attackees[planeindex];
if (attackee!=NULL)
enemyattack(plane,attackee);
else
if (!plane->ishome)
enemyflyhome(plane);
attackees[planeindex]=NULL;
}
void enemyattack(object *plane,object *attackee)
{
autoheight=((frametick&31)<16 ? 16 : 0);
if (attackee->speed!=0)
autopilot(plane,attackee->x-(fcos(32,attackee->rotation)>>8),
attackee->y-(fsin(32,attackee->rotation)>>8),attackee,FALSE);
else
autopilot(plane,attackee->x,attackee->y+4,attackee,FALSE);
}
void enemyflyhome(object *plane)
{
int x;
autoheight=((frametick&31)<16 ? 16 : 0);
x=homes[planeindex].x;
autopilot(plane,autoheight+(x<1000 ? 1000 : (x>2000 ? 2000 : x)),
150-(autoheight>>1),NULL,FALSE);
}
void flyhome(object *plane)
{
object *home;
if (plane->ishome)
return;
home=&homes[planeindex];
autoheight=((frametick&31)<16 ? 16 : 0);
if (abs(plane->x-home->x)<16 && abs(plane->y-home->y)<16) {
if (planeisplayer) {
createplayerplane(plane);
initscreen(TRUE);
}
else
if (planeisenemy)
createenemyplane(plane);
else
createplane(plane);
return;
}
autopilot(plane,home->x,home->y,NULL,FALSE);
}
bool ontarget(object *target)
{
object tbullet,ttarget;
int bulletx,bullety,targetx,targety,d2,i;
memcpy(&tbullet,&tplane,sizeof(object));
memcpy(&ttarget,target,sizeof(object));
setvel(&tbullet,tbullet.speed+10,tbullet.rotation);
tbullet.x+=8;
tbullet.y-=8;
for (i=0;i<10;i++) {
moveobject(&tbullet,&bulletx,&bullety);
moveobject(&ttarget,&targetx,&targety);
d2=distsqr(bulletx,bullety,targetx,targety);
if (d2<0 || d2>125*125)
return FALSE;
if (bulletx>=targetx && targetx+15>=bulletx && bullety<=targety &&
targety-15<=bullety)
return TRUE;
}
return FALSE;
}
/* void cleartargs(void); */
void initbuildingcheck(int x,int y)
{
int i,left,right;
left=x-(40+level);
right=x+40+level;
leftbuilding=-1;
rightbuilding=0;
for (i=0;i<20;i++)
if (buildings[i]->x>=left) {
leftbuilding=i;
break;
}
if (leftbuilding==-1)
return;
for (;i<20;i++)
if (buildings[i]->x>=right)
break;
rightbuilding=i-1;
}
bool doomed(int x,int y,int alt)
{
object *building;
int i,left,right,xx,yy;
if (alt>50)
return FALSE;
if (alt<20)
return TRUE;
left=x-32;
right=x+32;
for (i=leftbuilding;i<=rightbuilding;i++) {
building=buildings[i];
xx=building->x;
if (xx>=left) {
if (xx>right)
return FALSE;
yy=building->y+(building->state==STANDING ? 16 : 8);
if (y<=yy)
return TRUE;
}
}
return FALSE;
}
int distsqr(int x0,int y0,int x1,int y1)
{
int x=abs(x0-x1),y=abs(y0-y1),t;
if (x<125 && y<125)
return x*x+y*y;
if (x<y) { t=x; x=y; y=t; }
return -((x*7+(y<<2))>>3);
}
void autopilot(object *plane,int destx,int desty,object *destobj,bool recursing)
{
int px,py,distx,disty,i,newx,newy,ch,newrot,newspd,d2,mindist2;
if (plane->state==STALLED && plane->rotation!=12) {
plane->deltarot=-1;
return;
}
px=plane->x;
py=plane->y;
distx=px-destx;
if (abs(distx)>200) {
if (plane->xv!=0 && (distx<0)==(plane->xv<0)) {
if (plane->counter==0)
plane->counter=(py>150) ? 2 : 1;
autopilot(plane,px,plane->counter==1 ? py+25 : py-25,NULL,TRUE);
return;
}
plane->counter=0;
py+=100;
autopilot(plane,(distx<0 ? 150 : -150)+px,
py>(150-autoheight) ? 150-autoheight : py,NULL,TRUE);
return;
}
if (!recursing)
plane->counter=0;
if (plane->speed!=0) {
disty=py-desty;
if (disty!=0 && abs(disty)<6)
plane->y=(disty<0 ? ++py : --py);
else
if (distx!=0 && abs(distx)<6)
plane->x=(distx<0 ? ++px : --px);
}
initbuildingcheck(px,py);
memcpy(&tplane,plane,sizeof(object));
newspd=tplane.speed+1;
if (newspd>level+8)
newspd=level+8;
else
if (newspd<level+4)
newspd=level+4;
for (i=0;i<3;i++) {
newrot=(tplane.rotation+(tplane.inverted ? -autodeltarot[i] :
autodeltarot[i]))&15;
setvel(&tplane,newspd,newrot);
moveobject(&tplane,&newx,&newy);
autod2[i]=distsqr(newx,newy,destx,desty);
autoalt[i]=newy-ground[newx+8];
autodoomed[i]=doomed(newx,newy,autoalt[i]);
memcpy(&tplane,plane,sizeof(object));
}
if (destobj!=NULL && ontarget(destobj))
plane->firing=TRUE;
mindist2=32767;
for (i=0;i<3;i++) {
d2=autod2[i];
if (d2>=0 && d2<mindist2 && !autodoomed[i]) {
mindist2=d2;
ch=i;
}
}
if (mindist2==32767) {
mindist2=-32767;
for (i=0;i<3;i++) {
d2=autod2[i];
if (d2<0 && d2>mindist2 && !autodoomed[i]) {
mindist2=d2;
ch=i;
}
}
}
if (plane->speed<level+4)
plane->deltav=4;
if (mindist2!=-32767) {
if (plane->deltav<4)
plane->deltav++;
}
else {
if (plane->deltav!=0)
plane->deltav--;
ch=0;
disty=autoalt[0];
if (autoalt[1]>disty) {
disty=autoalt[1];
ch=1;
}
if (autoalt[2]>disty)
ch=2;
}
plane->deltarot=autodeltarot[ch];
if (plane->deltarot==0 && plane->speed!=0)
plane->inverted=(plane->xv<0);
}
void killplane(object *plane)
{
if (plane->xv<0)
plane->rotation=(plane->rotation+2)&15;
else
plane->rotation=(plane->rotation-2)&15;
plane->state=(plane->state>=GHOST ? GHOSTCRASHED : CRASHED);
plane->ishome=FALSE;
plane->speed=0;
plane->yvfrac=0;
plane->xvfrac=0;
plane->yv=0;
plane->xv=0;
plane->counter=10;
}
void catchfire(object *plane)
{
plane->xvfrac=0;
plane->yvfrac=0;
plane->counter=10;
plane->state=FALLING;
plane->ishome=FALSE;
}
void gointospin(object *plane)
{
plane->xv=0;
plane->yv=0;
plane->speed=0;
plane->inverted=FALSE;
plane->xvfrac=0;
plane->yvfrac=0;
plane->rotation=14;
plane->counter=6;
plane->state=(plane->state>=GHOST ? GHOSTSTALLED : STALLED);
plane->ishome=FALSE;
}
void insxlist(object *ins,object *list)
{
if (ins->x<list->x)
do
list=list->prevx;
while (ins->x<list->x);
else {
while (ins->x>=list->x)
list=list->nextx;
list=list->prevx;
}
ins->nextx=list->nextx;
ins->prevx=list;
list->nextx->prevx=ins;
list->nextx=ins;
}
void delxlist(object *del)
{
del->nextx->prevx=del->prevx;
del->prevx->nextx=del->nextx;
}
void initsndlist(void)
{
snd *p;
int i;
for (i=0,p=&sndlist[0];i<99;i++,p++)
p->next=p+1;
p->next=NULL;
lastsnd=NULL;
nextsnd=&sndlist[0];
}
void initsound(int type,int pitch,object *obj)
{
if (type<soundtype) {
soundtype=type;
soundpitch=pitch;
soundobj=obj;
}
else
if (type==soundtype && pitch<soundpitch) {
soundpitch=pitch;
soundobj=obj;
}
}
void updatesound(void)
{
snd *s;
/* disable(); */
for (s=lastsnd;s!=NULL;s=s->next)
s->t2v+=s->deltat2v*slidec;
slidec=0;
tune3f=FALSE;
switch (soundtype) {
case SOUND_OFF:
case SOUND_NONE:
default:
snosound();
sndobj=NULL;
soundperiodicfunc=NULL;
break;
case SOUND_ENGINE:
if (soundpitch==0)
ssound(0xf000);
else
ssound(soundpitch*0x1000+0xd000);
sndobj=NULL;
soundperiodicfunc=NULL;
break;
case SOUND_BOMB:
if (soundobj==sndobj)
break;
soundperiodicfunc=soundslide;
sndobj=soundobj;
soundslide();
break;
case SOUND_FALLING:
if (soundobj==sndobj)
break;
soundperiodicfunc=soundslide;
sndobj=soundobj;
soundslide();
break;
case SOUND_STUTTER:
ssound(getenginestutter(2)!=0 ? 0x9000 : 0xf000);
sndobj=NULL;
soundperiodicfunc=NULL;
break;
case SOUND_SHRAPNEL:
ssound(t2v2);
soundperiodicfunc=NULL;
sndobj=NULL;
break;
case SOUND_FIRING:
ssound(0x1000);
soundperiodicfunc=soundtoggle;
sndobj=NULL;
break;
case SOUND_TUNE:
tuneline3=0;
tuneptr3=0;
sound3();
soundperiodicfunc=NULL;
sndobj=NULL;
tune3f=TRUE;
}
soundpitch=0x7fff;
soundtype=SOUND_NONE;
}
void updatesoundint(void)
{
slidec++;
if (t2v!=0 && soundperiodicfunc!=NULL)
soundperiodicfunc();
if (numshrapnelsnd!=0)
updatetune2();
if (tune3f)
updatetune3();
}
void soundslide(void)
{
snd *s=sndobj->sndp;
ssound(s->t2v+s->deltat2v*slidec);
}
void soundtoggle(void)
{
if (t2v==0xf000)
ssound(ot2v);
else {
ot2v=t2v;
ssound(0xf000);
}
}
void updatetune2(void)
{
tunetime2--;
if (tunetime2<0)
setsound2();
}
void setsound2(void)
{
tuneline=tuneline2;
tuneptr=tuneptr2;
tune=tune1;
octavemultiplier=octavemul2;
updatetune();
tuneline2=tuneline;
tuneptr2=tuneptr;
t2v2=t2v1;
tunetime2+=tunedur; /* Interrupts originally cleared for this instruction */
octavemul2=octavemultiplier;
}
void updatetune3(void)
{
tunetime3--;
if (tunetime3<0)
sound3();
}
void sound3(void)
{
tuneline=tuneline3;
tuneptr=tuneptr3;
tune=tune1;
octavemultiplier=octavemul3;
updatetune();
tuneline3=tuneline;
tuneptr3=tuneptr;
t2v3=t2v1;
tunetime3+=tunedur; /* Interrupts originally cleared for this instruction */
octavemul3=octavemultiplier;
snosound();
ssound(t2v3);
}
void objectsound(object *obj,int sn)
{
snd *s;
if (obj->sndp!=NULL)
return;
if (obj->type==OBJ_SHRAPNEL) {
/* disable(); */
numshrapnelsnd++;
if (numshrapnelsnd==1) {
tuneptr2=tuneline2=0;
setsound2();
}
obj->sndp=(snd *)1; /* Suspect this is a bug */
/* enable(); */
return;
}
s=createsnd();
if (s!=NULL) {
/* disable(); */
switch (sn) {
case SOUND_BOMB:
s->t2v=0x300;
s->deltat2v=8;
break;
case SOUND_FALLING:
s->t2v=0x1200;
s->deltat2v=-8;
break;
}
obj->sndp=s;
/* enable(); */
return;
}
}
snd *createsnd(void)
{
snd *p;
if (nextsnd==NULL)
return NULL;
p=nextsnd;
nextsnd=p->next;
p->next=lastsnd;
p->prev=NULL;
if (lastsnd!=NULL)
lastsnd->prev=p;
return lastsnd=p;
}
void destroysnd(snd *s)
{
snd *p=s->prev;
if (p!=NULL)
p->next=s->next;
else
lastsnd=s->next;
p=s->next;
if (p!=NULL)
p->prev=s->prev;
s->next=nextsnd;
nextsnd=s;
}
void killsnd(object *o)
{
snd *s=o->sndp;
if (s==NULL)
return;
/* disable(); */
if (o->type==OBJ_SHRAPNEL)
numshrapnelsnd--;
else
destroysnd(s);
o->sndp=NULL;
/* enable(); */
}
void ssound(unsigned int t2)
{
if (!soundflag)
return;
if (t2v==t2)
return;
if (t2v==0)
outportb(PORT_TIMERC,0xb6);
outportb(PORT_TIMER2,t2);
outportb(PORT_TIMER2,t2>>8);
if (t2v==0)
outportb(PORT_SPKR,inportb(PORT_SPKR)|3);
t2v=t2;
}
void snosound(void)
{
if (t2v!=0) {
outportb(PORT_SPKR,inportb(PORT_SPKR)&0xfc);
t2v=0;
}
}
int getenginestutter(int f)
{
if (stutterp>=50)
stutterp=0;
return enginestutter[stutterp++]%f;
}
char tempobuf[5];
void updatetune(void)
{
bool notgotchar=TRUE;
int sharpen=0,tempobufp=0,dotdur=2,overflowoct=0x100,semitone,tempo,freq;
char tunechar,tunechar2;
while (TRUE) {
if (tuneline==0 && tuneptr==0)
octavemultiplier=0x100;
tunechar=toupper(tune[tuneline][tuneptr++]);
if (tunechar==0) {
tunechar=tune[++tuneline][tuneptr=0];
if (tunechar==0)
tuneline=0;
if (!notgotchar)
break;
}
else {
notgotchar=FALSE;
if (tunechar=='/')
break;
if (isalpha(tunechar)) {
semitone=majorscale[tunechar-'A'];
tunechar2=tunechar;
}
else {
switch(tunechar) {
case '>':
octavemultiplier<<=1;
break;
case '<':
octavemultiplier>>=1;
break;
case '+':
sharpen++;
break;
case '-':
sharpen--;
break;
case '.':
dotdur=3;
break;
default:
if (isdigit(tunechar))
tempobuf[tempobufp++]=tunechar;
}
}
}
}
tempobuf[tempobufp]=0;
tempo=atoi(tempobuf);
if (tempo<=0)
tempo=4;
if (tunechar2=='R')
freq=0x7d00;
else {
semitone+=sharpen;
while (semitone<0) {
semitone+=12;
overflowoct>>=1;
}
while (semitone>=12) {
semitone-=12;
overflowoct<<=1;
}
freq=(short)(((long)notefreq[semitone]*(long)octavemultiplier*
(long)overflowoct)>>16);
}
t2v1=(short)(1193181l/freq);
tunedur=((dotdur*1440)/(tempo*60))>>1;
}
void initrand(void)
{
while (randno==0) {
outportb(PORT_TIMERC,0);
randno=inportb(PORT_TIMER0);
randno|=(inportb(PORT_TIMER0)<<8);
}
}
void restart(void)
{
int sc,i;
object *plane;
if (finaleflags[playerindex]==FINALE_WON) {
plane=&objects[playerindex];
sc=0;
while (plane->deaths++<maxlives) {
sc+=25;
plane->score+=sc;
useonscreenbuf();
livesbar(plane);
writescore(plane);
timertick=0;
while (timertick<5)
flushbuf(); /* Jornand de Buisonje <[email protected]> is the only
person who would ever bother to fill up the keyboard
buffer here, so this line is only here because of him.*/
}
if (level<=5)
level++;
score=plane->score;
}
else
level=score=0;
initsndlist();
copyground();
initlists();
createplayerplane(NULL);
for (i=0;i<3;i++)
createenemyplane(NULL);
createbuildings();
initscreen(FALSE);
createflocks();
createoxen();
initdifficulty();
longjmp(startjbuf,0);
}
void initdifficulty(void)
{
radarrange2=100;
if (level<6)
radarrange2-=(6-level)*10;
radarrange2*=radarrange2;
}
void clearwin(void)
{
int i;
for (i=20;i<24;i++) {
poscurs(0,i);
clearline();
}
poscurs(0,20);
}
void getcontrol(void)
{
int k;
clearwin();
printstr("Key: 1 - Joystick with IBM Keyboard\r\n");
printstr(" 2 - Joystick with non-IBM Keyboard\r\n");
printstr(" 3 - IBM Keyboard only\r\n");
printstr(" 4 - Non-IBM keyboard only\r\n");
while (1) {
if (testbreak())
finish(NULL,FALSE);
k=inkeys();
if (k>='1' && k<='4')
break;
}
joyrequested=(k<='2');
ibmkeyboard=(k=='1' || k=='3');
}
int getgamemode(void)
{
clearwin();
printstr("Key: S - single player\r\n");
printstr(" C - single player against computer\r\n");
printstr(" M - multiple players on network\r\n");
printstr(" A - 2 players on asynchronous line");
while (TRUE) {
if (testbreak())
finish(NULL,FALSE);
switch (toupper(inkeys())) {
case 'S':
return GAME_SINGLE;
case 'M':
return GAME_MULTIPLE;
case 'C':
return GAME_COMPUTER;
case 'A':
return GAME_ASYNCH;
}
}
}
int getgamenumber(void)
{
int n;
clearwin();
printstr(" Key a game number");
while (1) {
if (testbreak())
finish(NULL,FALSE);
n=inkeys()-'0';
if (n>=0 && n<=7)
return n;
}
}
bool testbreak(void)
{
return breakf;
}
void copyground(void)
{
memcpy(&workingground,&ground,MAX_X);
}
void initscreen(bool drawnground)
{
object *plane;
if (drawnground==0) {
clearscrbuf();
useoffscreenbuf();
drawmapground();
soundoff();
deceased=FALSE;
}
copyoffscbuftoscn();
useonscreenbuf();
drawmapbuildings();
writescores();
plane=&objects[playerindex];
if (deceased) {
poscurs(16,24);
setcolour(plane->colour);
printstr("\2"); /* :-) */
}
else {
fuelbar(plane);
bombsbar(plane);
ammobar(plane);
livesbar(plane);
}
groundnotdrawn=TRUE;
}
void writescores(void)
{
if (score!=0) {
objects[0].score=score;
score=0;
}
writescore(objects);
/* if (multiplayer && netinf->maxplayers>1)
writescore(&objects[1]); */
}
void livesbar(object *p)
{
statbar(127,maxlives-p->deaths,maxlives,p->colour);
}
void fuelbar(object *p)
{
statbar(132,p->fuel>>4,562,p->colour);
}
void bombsbar(object *p)
{
statbar(137,p->bombs,5,3-p->colour);
}
void ammobar(object *p)
{
statbar(142,p->ammo,200,3);
}
void statbar(int x,int h,int hmax,int col)
{
int y;
if (deceased)
return;
h=(h*10)/hmax-1;
if (h>9)
h=9;
for (y=0;y<=h;y++)
putpixel(x,y,col);
for (;y<=9;y++)
putpixel(x,y,0);
}
void drawmapground(void)
{
int c,newy,x,sx,y;
c=0;
sx=152;
newy=15;
for (y=0;y<=newy;y++)
putpixel(sx,y,3);
newy=y=0;
for (x=0;x<MAX_X;x++) {
if (workingground[x]>newy)
newy=workingground[x];
c++;
if (c==19) {
newy/=13;
if (newy==y)
putpixel(sx,newy,3);
else
if (newy>y)
for (y++;y<=newy;y++)
putpixel(sx,y,3);
else
for (y--;y>=newy;y--)
putpixel(sx,y,3);
y=newy;
putpixel(sx,0,3);
sx++;
c=newy=0;
}
}
newy=15;
for (y=0;y<=newy;y++)
putpixel(sx,y,3);
for (x=0;x<320;x++)
putpixel(x,18,3);
}
void drawmapbuildings(void)
{
int i;
object *building;
mapobject *mapobj;
for (i=0,building=objects,mapobj=mapobjects;i<100;i++,building++,mapobj++) {
building->oldonscreen=0;
building->onscreen=0;
mapobj->colour=0;
}
for (i=0;i<20;i++) {
building=buildings[i];
if (building!=NULL)
if (building->state!=FINISHED)
drawmapobject(building);
}
}
void useoffscreenbuf(void)
{
scrseg=_DS;
scroff=((int)&scrbuf)-0x1000;
interlacediff=0x1000;
}
void useonscreenbuf(void)
{
scrseg=SCR_SEG;
scroff=0;
interlacediff=0x2000;
}
void copyoffscbuftoscn(void)
{
farmemset(MK_FP(SCR_SEG,0),0x1000,0);
farmemset(MK_FP(SCR_SEG,0x2000),0x1000,0);
farmemmove(MK_FP(_DS,&scrbuf),MK_FP(SCR_SEG,0x1000),0x1000);
farmemmove(MK_FP(_DS,(int)(&scrbuf)+0x1000),MK_FP(SCR_SEG,0x3000),0x1000);
}
void clearscrbuf(void)
{
memset(&scrbuf,0x2000,0);
}
void initlists(void)
{
int i;
object *o;
objleft.nextx=objleft.next=&objright;
objright.prevx=objright.prev=&objleft;
objleft.x=-32767;
objright.x=32767;
lastobject=firstobject=firstdeleted=lastdeleted=NULL;
nextobject=o=objects;
for (i=0;i<100;i++) {
o->next=o+1;
(o++)->index=i;
}
(o-1)->next=0;
}
void createenemyplane(object *pl)
{
object *plane=createplane(pl);
if (pl==NULL) {
plane->soundfunc=soundplane;
plane->updatefunc=updateenemyplane;
plane->colour=2;
if (!multiplayer)
plane->source=&objects[1];
else
if (plane->index==1)
plane->source=plane;
else
plane->source=plane-2;
memcpy(&homes[plane->index],plane,sizeof(object));
}
if (gamemode==GAME_SINGLE) {
plane->state=FINISHED;
delxlist(plane);
}
}
void createplayerplane(object *player)
{
object *plane=createplane(player);
if (player==NULL) {
plane->soundfunc=soundplane;
plane->updatefunc=updateplayerplane;
plane->colour=(plane->index&1)+1;
plane->source=plane;
memcpy(&homes[plane->index],plane,sizeof(object));
finaletime=1;
finaleflying=FALSE;
}
scnleft=plane->x-152;
scnright=scnleft+319;
flushbuf();
}
object *createplane(object *pl)
{
int y,x,left,right,pos;
object *plane=(pl!=NULL ? pl : newobject());
switch (gamemode) {
case GAME_SINGLE:
pos=singleplanes[plane->index];
break;
case GAME_MULTIPLE:
case GAME_ASYNCH:
pos=multipleplanes[plane->index];
break;
case GAME_COMPUTER:
pos=computerplanes[plane->index];
}
plane->type=OBJ_PLANE;
left=plane->x=world->planeposes[pos];
right=plane->x+20;
y=0;
for (x=left;x<=right;x++)
if (workingground[x]>y)
y=workingground[x];
plane->y=y+13;
plane->bombtime=0;
plane->counter=0;
plane->deltav=0;
plane->deltarot=0;
plane->speed=0;
plane->yfrac=0;
plane->xfrac=0;
setvel(plane,0,0);
plane->inverted=world->planeflip[pos];
plane->rotation=(plane->inverted ? 8 : 0);
plane->homing=FALSE;
plane->bombing=FALSE;
plane->firing=FALSE;
plane->height=16;
plane->width=16;
plane->ishome=TRUE;
if (pl==0 || plane->state==CRASHED || plane->state==GHOSTCRASHED) {
plane->ammo=200;
plane->bombs=5;
plane->fuel=MAX_FUEL;
}
if (pl==0) {
attackees[plane->index]=NULL;
finaleflags[plane->index]=FINALE_NONE;
plane->deaths=0;
/* plane->si1c=0; */
plane->score=0;
insxlist(plane,&objleft);
}
else {
delxlist(plane);
insxlist(plane,plane->nextx);
}
if (multiplayer && plane->deaths>=maxlives) {
plane->state=GHOST;
if (plane->index==playerindex)
deceased=TRUE;
}
else
plane->state=FLYING;
return plane;
}
void firebullet(object *obj,object *at)
{
object *bullet;
int xv,yv,dist,speed,atx,aty;
if (at==NULL && !planeisenemy && obj->ammo==0)
return;
bullet=newobject();
if (bullet==NULL)
return;
obj->ammo--;
speed=level+10;
if (at!=NULL) {
atx=at->x+(at->xv<<2);
aty=at->y+(at->yv<<2);
xv=atx-obj->x;
yv=aty-obj->y;
dist=distance(atx,aty,obj->x,obj->y);
if (dist<1) {
deleteobject(bullet);
return;
}
bullet->xv=(speed*xv)/dist;
bullet->yv=(speed*yv)/dist;
bullet->yvfrac=0;
bullet->xvfrac=0;
}
else
setvel(bullet,obj->speed+speed,obj->rotation);
bullet->type=OBJ_BULLET;
bullet->x=obj->x+8;
bullet->y=obj->y-8;
bullet->xfrac=obj->xfrac;
bullet->yfrac=obj->yfrac;
bullet->fuel=10;
bullet->source=obj;
bullet->colour=obj->colour;
bullet->width=1;
bullet->height=1;
bullet->soundfunc=NULL;
bullet->updatefunc=updatebullet;
bullet->speed=0;
insxlist(bullet,obj);
}
int distance(int x0,int y0,int x1,int y1)
{
int x=abs(x0-x1),y=abs(y0-y1),t;
if (x>100 || y>100)
return -1;
if (x<y) { t=x; x=y; y=t; }
return (x*7+(y<<2))>>3;
}
void dropbomb(object *plane)
{
object *bomb; /* Someone set us up the bomb! Sorry. */
int rot;
if ((!planeisenemy && plane->bombs==0) || plane->bombtime!=0)
return;
bomb=newobject();
if (bomb==NULL)
return;
plane->bombs--;
plane->bombtime=10;
bomb->type=OBJ_BOMB;
bomb->state=FALLING;
bomb->xv=plane->xv;
bomb->yv=plane->yv;
rot=(plane->inverted ? ((plane->rotation+4)&15) : ((plane->rotation-4)&15));
bomb->x=plane->x+(fcos(10,rot)>>8)+4;
bomb->y=plane->y+(fsin(10,rot)>>8)-4;
bomb->yvfrac=0;
bomb->xvfrac=0;
bomb->yfrac=0;
bomb->xfrac=0;
bomb->fuel=5;
bomb->source=plane;
bomb->colour=plane->colour;
bomb->width=8;
bomb->height=8;
bomb->soundfunc=soundbomb;
bomb->updatefunc=updatebomb;
insxlist(bomb,plane);
}
/* void createmissile(object* plane); */
/* void createstarburst(object* plane); */
void createbuildings(void)
{
int i,minaltitude,maxaltitude,y,gx,left,right;
object *building;
int *positions=world->buildingpositions;
int *types=world->buildingtypes;
if (multiplayer /* && netinf->maxplayers!=1 */)
buildingc[0]=buildingc[1]=10;
else {
buildingc[0]=0;
buildingc[1]=17;
}
for (i=0;i<20;i++) {
building=newobject();
buildings[i]=building;
building->x=left=*positions;
right=left+15;
minaltitude=999;
maxaltitude=0;
for (gx=left;gx<=right;gx++) {
if (workingground[gx]>maxaltitude)
maxaltitude=workingground[gx];
if (workingground[gx]<minaltitude)
minaltitude=workingground[gx];
}
for (y=(maxaltitude+minaltitude)>>1;(building->y=y+16)>=200;y--);
for (gx=left;gx<=right;gx++)
workingground[gx]=y;
building->counter=0;
building->rotation=0;
building->yvfrac=0;
building->xvfrac=0;
building->yfrac=0;
building->xfrac=0;
building->yv=0;
building->xv=0;
building->type=OBJ_BUILDING;
building->state=STANDING;
building->kind=*types;
building->fuel=i;
if (multiplayer /* && netinf->maxplayers!=1 */)
building->source=&objects[i<10 ? 0 : 1];
else
building->source=&objects[i<10 && i>6 ? 0 : 1];
building->colour=building->source->colour;
building->width=16;
building->height=16;
building->soundfunc=soundbuilding;
building->updatefunc=updatebuilding;
insxlist(building,&objleft);
positions++;
types++;
}
}
void createexplosion(object *obj)
{
object *shrapnel;
int i,step,l,x,y,xv,yv,colour,type,kind;
unsigned int randno1;
bool soundf;
x=obj->x+(obj->width>>1);
y=obj->y+(obj->height>>1);
xv=obj->xv;
yv=obj->yv;
colour=obj->colour;
type=obj->type;
if (type==OBJ_BUILDING && obj->kind==BUILDING_FUEL) {
step=1;
l=level+8;
}
else {
step=(type==OBJ_PLANE ? 6 : 2);
l=(level+4)>>1;
}
soundf=(type==OBJ_PLANE && obj->state==FLYING);
for (i=1;i<=15;i+=step) {
shrapnel=newobject();
if (shrapnel==NULL)
return;
shrapnel->type=OBJ_SHRAPNEL;
setvel(shrapnel,l,i);
shrapnel->xv+=xv;
shrapnel->yv+=yv;
shrapnel->y=shrapnel->yv+y;
shrapnel->x=shrapnel->xv+x;
randno1=(shrapnel->y)*(shrapnel->x)*randno*0x1d43;
shrapnel->fuel=3;
kind=shrapnel->kind=(int)(((unsigned long)((unsigned short)((unsigned long)randno1*(unsigned long)i))*8UL)>>16);
if (soundf && (kind==0 || kind==7)) {
kind=shrapnel->kind=0;
soundf=FALSE;
shrapnel->xv=xv;
shrapnel->yv=-(level+4);
}
shrapnel->speed=0;
shrapnel->counter=0;
shrapnel->yfrac=0;
shrapnel->xfrac=0;
shrapnel->source=obj;
shrapnel->colour=colour;
shrapnel->width=8;
shrapnel->height=8;
shrapnel->soundfunc=soundshrapnel;
shrapnel->updatefunc=updateshrapnel;
if (kind!=0)
objectsound(shrapnel,SOUND_SHRAPNEL);
insxlist(shrapnel,obj);
}
}
void createsmoke(object *plane)
{
object *smoke=newobject();
if (smoke==NULL)
return;
smoke->type=OBJ_SMOKE;
smoke->x=plane->x+8;
smoke->y=plane->y-8;
smoke->xv=plane->xv;
smoke->yv=plane->yv;
smoke->yvfrac=0;
smoke->xvfrac=0;
smoke->yfrac=0;
smoke->xfrac=0;
smoke->fuel=10;
smoke->source=plane;
smoke->width=1;
smoke->height=1;
smoke->soundfunc=NULL;
smoke->updatefunc=updatesmoke;
smoke->colour=plane->colour;
}
void createflocks(void)
{
object *flock;
int i,bird;
for (i=0;i<4;i++) {
flock=newobject();
if (flock==NULL)
return;
flock->type=OBJ_FLOCK;
flock->state=FLYING;
flock->x=flockx[i];
flock->y=flocky[i];
flock->xv=flockxv[i];
flock->yvfrac=0;
flock->xvfrac=0;
flock->yfrac=0;
flock->xfrac=0;
flock->yv=0;
flock->inverted=FALSE;
flock->fuel=5;
flock->source=flock;
flock->height=flock->width=16;
flock->soundfunc=NULL;
flock->updatefunc=updateflock;
flock->colour=1;
insxlist(flock,&objleft);
for (bird=0;bird<SPAREBIRDS;bird++)
createbird(flock,1);
}
}
void createbird(object *flock,int birdno)
{
object *bird=newobject();
if (bird==NULL)
return;
bird->type=OBJ_BIRD;
bird->x=flock->x+fscatterx[birdno];
bird->y=flock->y-fscattery[birdno];
bird->xv=fscatterxv[birdno];
bird->yv=fscatteryv[birdno];
bird->yvfrac=0;
bird->xvfrac=0;
bird->yfrac=0;
bird->xfrac=0;
bird->inverted=FALSE;
bird->fuel=4;
bird->source=flock;
bird->height=2;
bird->width=4;
bird->soundfunc=NULL;
bird->updatefunc=updatebird;
bird->colour=flock->colour;
insxlist(bird,flock);
}
void createoxen(void)
{
object *ox;
int i;
for (i=0;i<2;i++) {
ox=newobject();
if (ox==NULL) /* Test for the NULL ox. */
return;
ox->type=OBJ_OX;
ox->state=STANDING;
ox->x=oxx[i];
ox->y=oxy[i];
ox->yv=0; /* This is a particularly amusing variable */
ox->xv=0;
ox->yvfrac=0;
ox->xvfrac=0;
ox->yfrac=0;
ox->xfrac=0;
ox->inverted=FALSE; /* But this one is just plain bizarre */
ox->source=ox;
ox->height=16;
ox->width=16;
ox->soundfunc=NULL;
ox->updatefunc=updateox;
ox->colour=1;
insxlist(ox,&objleft);
}
}
void checkcollisions(void)
{
int right,top,bottom,i,type;
object **obj1,**obj2;
object *obj,*test;
colln=collc=0;
collxvr=2;
collyvr=1;
if (frametick&1) {
collxvr=-collxvr;
collyvr=-collyvr;
}
useoffscreenbuf();
for (obj=objleft.nextx;obj!=&objright;obj=obj->nextx) {
right=obj->x+obj->width-1;
bottom=obj->y;
top=bottom+1-obj->height;
for (test=obj->nextx;test->x<=right && test!=&objright;test=test->nextx)
if (test->y>=top && test->y-test->height+1<=bottom)
checkcollision(obj,test);
type=obj->type;
if ((type==OBJ_PLANE && obj->state!=FINISHED &&
obj->state!=WAITING && obj->y<workingground[obj->x+8]+24) ||
(type==OBJ_BOMB && obj->y<workingground[obj->x+4]+12))
checkcrash(obj);
}
for (i=0,obj1=collobj1,obj2=collobj2;i<collc;i++,obj1++,obj2++)
docollision(*obj1,*obj2);
for (i=0,obj1=collobjs;i<colln;i++,obj1++) {
(obj=*obj1)->xv=collxv[i];
obj->yv=collyv[i];
}
}
void checkcollision(object *obj1,object *obj2)
{
int type1,type2;
object *t;
type1=obj1->type;
type2=obj2->type;
if ((type1==OBJ_PLANE && obj1->state>=FINISHED) ||
(type2==OBJ_PLANE && obj2->state>=FINISHED) ||
(type1==OBJ_SHRAPNEL && type2==OBJ_SHRAPNEL))
return;
if (obj1->y<obj2->y) {
t=obj1;
obj1=obj2;
obj2=t;
}
drawobject(15,15,obj1);
if (bitblt(obj2->x-obj1->x+15,obj2->y-obj1->y+15,obj2) && collc<199) {
collobj1[collc]=obj1;
collobj2[collc++]=obj2;
collobj1[collc]=obj2;
collobj2[collc++]=obj1;
}
clearscorearea();
}
void checkcrash(object *obj)
{
int x,right,h;
bool f=FALSE;
drawobject(15,15,obj);
right=obj->x+obj->width-1;
for (x=obj->x;x<=right;x++) {
h=workingground[x]+15-obj->y;
if (h>15) {
f=TRUE;
break;
}
if (h>=0) {
f=pixel(x+15-obj->x,h,0x80);
if (f!=0)
break;
}
}
clearscorearea();
if (f && collc<200) {
collobj1[collc]=obj;
collobj2[collc++]=NULL;
}
}
void docollision(object *obj1,object *obj2)
{
int state,type2,i;
type2=(obj2!=NULL) ? obj2->type : OBJ_NONE;
if ((type2==OBJ_BIRD || type2==OBJ_FLOCK) && obj1->type!=OBJ_PLANE)
return;
switch (obj1->type) {
case OBJ_BOMB:
createexplosion(obj1);
obj1->fuel=-1;
if (obj2==NULL) /* No object - it hit the ground */
digcrater(obj1);
killsnd(obj1);
return;
case OBJ_BULLET:
obj1->fuel=1;
return;
case OBJ_SHRAPNEL:
if (obj2==NULL || obj1->kind!=0 ||
(obj1->kind==0 && collidescore(type2,obj2,200))) {
obj1->fuel=1;
killsnd(obj1);
}
return;
case OBJ_BUILDING:
if (obj1->state!=STANDING)
return;
if (type2==OBJ_SHRAPNEL)
return;
if (type2==OBJ_BULLET) {
obj1->counter+=10;
if (obj1->counter<(level+1)*10)
return;
}
obj1->state=FINISHED;
createexplosion(obj1);
useonscreenbuf();
drawmapobject(obj1);
useoffscreenbuf();
addscore(obj1,obj1->kind==BUILDING_FUEL ? 200 : 100);
buildingc[obj1->colour-1]--;
if (buildingc[obj1->colour-1]==0)
declarewinner(obj1->colour);
return;
case OBJ_PLANE:
state=obj1->state;
if (state==CRASHED || state==GHOSTCRASHED)
return;
if (finaleflags[obj1->index]==FINALE_WON)
return;
if (type2==OBJ_BIRD && obj1->ishome)
return;
if (obj2==NULL) {
if (state==FALLING) {
killsnd(obj1);
createexplosion(obj1);
digcrater(obj1);
}
else
if (state<FINISHED) {
score50(obj1);
createexplosion(obj1);
digcrater(obj1);
}
killplane(obj1);
return;
}
if (state==FALLING || state>=FINISHED)
return;
if (type2!=OBJ_BULLET) {
createexplosion(obj1);
if (type2==OBJ_PLANE) {
collxvr=-collxvr;
collxv[colln]=((obj1->xv+obj2->xv)>>1)+collxvr;
collyvr=-collyvr;
collyv[colln]=((obj1->yv+obj2->yv)>>1)+collyvr;
collobjs[colln++]=obj1;
}
}
catchfire(obj1);
score50(obj1);
return;
case OBJ_BIRD:
obj1->fuel=(collidescore(type2,obj2,25) ? -1 : -2);
return;
case OBJ_FLOCK:
if (type2!=OBJ_FLOCK && type2!=OBJ_BIRD && obj1->state==FLYING) {
for (i=0;i<8;i++)
createbird(obj1,i);
obj1->fuel=-1;
obj1->state=FINISHED;
}
return;
case OBJ_OX:
if (obj1->state!=STANDING)
return;
if (type2==OBJ_SHRAPNEL)
return;
collidescore(type2,obj2,200);
obj1->state=FINISHED;
return;
}
}
void digcrater(object *obj)
{
int left,right,x,ny,oy,miny,cx;
left=obj->x+(obj->width-8)/2;
right=left+7;
for (x=left,cx=0;x<=right;x++,cx++) {
oy=workingground[x];
miny=ground[x]-20;
if (miny<20)
miny=20;
ny=oy+1-crater[cx];
if (ny<=miny)
ny=miny+1;
workingground[x]=ny-1;
}
cratertobedrawn=TRUE;
}
bool collidescore(int type,object *obj,int score)
{
if (type==OBJ_BULLET || type==OBJ_BOMB || (type==OBJ_PLANE &&
(obj->state==FLYING ||
(obj->state==FALLING && obj->counter==10)) && !obj->ishome)) {
addscore(obj,score);
return TRUE;
}
return FALSE;
}
void addscore(object *destroyed,int score)
{
if (multiplayer /* && netinf->maxplayers==1 */) {
objects[2-destroyed->colour].score+=score;
writescore(&objects[2-destroyed->colour]);
}
else {
if (destroyed->colour==1)
objects->score-=score;
else
objects->score+=score;
writescore(&objects[0]);
}
}
void score50(object *destroyed)
{
addscore(destroyed,50);
}
void writescore(object *p)
{
poscurs(2+7*(p->colour-1),24);
setcolour(p->colour);
writenum(p->score,6);
}
void soundoff(void)
{
if (notitlesflag)
return;
initsound(SOUND_OFF,0,NULL);
updatesound();
}
void timerint(void)
{
timertick++;
speedtick++;
updatesoundint();
}
/* void displayplayerplane(object* plane); */
void soundbomb(object *bomb)
{
if (bomb->yv<=0)
initsound(SOUND_BOMB,-bomb->y,bomb);
}
/* void displaymissile(object* missile); */
/* void displaystarburst(object* starburst); */
void soundshrapnel(object *shrapnel)
{
if (shrapnel->kind!=0)
initsound(SOUND_SHRAPNEL,shrapnel->counter,shrapnel);
}
/* void displaycomputerplane(object* plane); */
/* void displayremoteplane(object* plane); */
void soundbuilding(object *building)
{
if (building->firing)
initsound(SOUND_FIRING,0,building);
}
/* void displayflock(object* flock); */
/* void displaybird(object* bird); */
void soundplane(object *plane)
{
if (plane->firing)
initsound(SOUND_FIRING,0,plane);
else
switch(plane->state) {
case FALLING:
if (plane->yv>=0)
initsound(SOUND_STUTTER,0,plane);
else
initsound(SOUND_FALLING,plane->y,plane);
break;
case FLYING:
initsound(SOUND_ENGINE,-plane->speed,plane);
break;
case STALLED:
initsound(SOUND_STUTTER,0,plane);
}
}
void drawmapobject(object *obj)
{
mapobject *mapobj=&mapobjects[obj->index];
int c;
if (mapobj->colour!=0)
putpixel(mapobj->x,mapobj->y,mapobj->colour-1);
if (obj->state>=FINISHED)
mapobj->colour=0;
else {
mapobj->x=(obj->x+obj->width/2)/19+152;
mapobj->y=(obj->y-obj->height/2)/13;
c=pixel(mapobj->x,mapobj->y,obj->source->colour);
if (c==0 || c==3) {
mapobj->colour=c+1;
return;
}
putpixel(mapobj->x,mapobj->y,c);
mapobj->colour=0;
}
}
void finish(char *msg,bool closef)
{
char *errmsg=NULL;
setgmode(3);
initsound(SOUND_OFF,0,NULL);
updatesound();
if (gamemode==GAME_MULTIPLE)
errmsg=finishcomms(closef);
else
if (gamemode==GAME_ASYNCH)
errmsg=finishserial();
restoreints();
flushhistory();
printstr("\r\n");
if (errmsg) {
printstr(errmsg);
printstr("\r\n");
}
if (msg) {
printstr(msg);
printstr("\r\n");
}
flushbuf();
if (msg!=NULL || errmsg!=NULL)
exit(1);
exit(0);
}
int getmaxplayers(void)
{
int n;
clearwin();
printstr(" Key maximum number of players allowed");
while (1) {
if (testbreak())
finish(NULL,FALSE);
n=inkeys()-'0';
if (n>=1 && n<=4)
return n;
}
}
bool updateremoteplane(object *plane)
{
planeisplayer=FALSE;
planeisenemy=FALSE;
finaleflag=finaleflags[planeindex=plane->index];
if (latencycount==0)
processkeys(plane,gamemode==GAME_MULTIPLE ? getmultiplekeys(plane) :
getasynchkeys(plane));
else {
plane->deltarot=0;
plane->bombing=FALSE;
}
if ((plane->state==CRASHED || plane->state==GHOSTCRASHED) &&
plane->counter<=0 && plane->fuel>-5000) {
plane->deaths++;
createplane(plane);
}
return updateplane(plane);
}
void initcomms(void)
{
world=&worlds[0];
}
char *finishcomms(bool closef)
{
return NULL;
}
char *finishserial(void)
{
return NULL;
}
/* This function loads a section of a file to a far address */
void ffread(FILE *fp,char huge *d,unsigned long l)
{
char buf[1024];
unsigned long a;
for (a=0;a<(l&-1024);a+=1024) {
fread(buf,1024,1,fp);
movedata(_DS,(unsigned int)buf,FP_SEG(d),FP_OFF(d),1024);
d=(char huge *)d+1024;
}
if ((l&1023)!=0) {
fread(buf,(unsigned int)(l&1023),1,fp);
movedata(_DS,(unsigned int)buf,FP_SEG(d),FP_OFF(d),(int)l&1023);
}
} /* ffread */
int inithistory(int randno)
{
long historybufsize;
FILE *inputfile;
if (playbackfilename!=NULL || recordfilename!=NULL) {
historybufsize=farcoreleft()
historybuf=(int huge *)farmalloc(historybufsize);
if (historybuf==0)
freeandexit("Unable to allocate history memory");
historyp=(int huge *)historybuf;
}
if (playbackfilename!=NULL) {
inputfile=fopen(playbackfilename,"rb");
if (inputfile==NULL)
freeandexit("Unable to open history input file");
fseek(inputfile,0,2);
historyfilelen=ftell(inputfile);
if (historybufsize<historyfilelen)
freeandexit("Insufficient memory to load history file");
historyspace=historybufsize-historyfilelen;
fseek(inputfile,0,0);
ffread(inputfile,(char huge *)historybuf,(int)historyfilelen);
fclose(inputfile);
randno=historyp[0];
historyp+=2;
historyfilelen-=4;
}
if (recordfilename!=NULL) {
outputfile=fopen(recordfilename,"wb");
if (outputfile==NULL)
freeandexit("Unable to open history output file");
if (playbackfilename==NULL) {
historyfilelen=historybufsize;
historyp[0]=randno;
historyp[1]=(int)(historybufsize>>4);
historyp+=2;
historyfilelen-=4;
}
}
return randno;
}
void freehistorybuf(void)
{
if (historybuf!=NULL)
farfree((void far *)historybuf);
}
void freeandexit(char *errmsg)
{
printstr(errmsg);
freehistorybuf();
exit(0);
}
int history(int keys)
{
if (playbackfilename!=NULL)
if (keys)
playbackfilename=NULL;
else {
if (historyp[0]==frametick) {
keys=historykeys=historyp[1];
historyp+=2;
historyfilelen-=4;
if (historyfilelen==0) {
playbackfilename=NULL;
historyfilelen=historyspace;
}
}
return historykeys;
}
if (recordfilename!=NULL && keys!=historykeys) {
historyp[0]=frametick;
historyp[1]=keys;
recording=TRUE;
historykeys=keys;
historyp+=2;
historyfilelen-=4;
if (historyfilelen==0)
recordfilename=NULL;
return historykeys;
}
return keys;
}
/* This function saves a far block to a file */
void ffwrite(FILE *fp,char huge *d,unsigned long l)
{
char buf[1024];
unsigned long a;
for (a=0;a<(l|1023)-1023;a+=1024) {
movedata(FP_SEG((unsigned long)d+a),FP_OFF((unsigned long)d+a),_DS,
(unsigned int)buf,1024);
fwrite(buf,1024,1,fp);
}
if ((l&1023)!=0) {
movedata(FP_SEG((unsigned long)d+a),FP_OFF((unsigned long)d+a),_DS,
(unsigned int)buf,(int)l&1023);
fwrite(buf,(unsigned int)(l&1023),1,fp);
}
} /* ffwrite */
void flushhistory(void)
{
if (recording)
ffwrite(outputfile,(char huge *)historybuf,(int)(historyp-historybuf)*sizeof(int));
if (outputfile!=NULL) {
fclose(outputfile);
freehistorybuf();
}
}
int getasynchkeys(object *plane)
{
return 0;
}
int getmultiplekeys(object *plane)
{
return 0;
}
void setvel(object *obj,int v,int dir)
{
int xv=fcos(v,dir),yv=fsin(v,dir);
obj->xv=xv>>8;
obj->xvfrac=xv<<8;
obj->yv=yv>>8;
obj->yvfrac=yv<<8;
}
void printstr(char *str)
{
while (*str!=0)
writechar(*(str++));
}
void moveobject(object *obj,int *x,int *y)
{
long pos,vel;
pos=(((long)(obj->x))<<16)+obj->xfrac;
vel=(((long)(obj->xv))<<16)+obj->xvfrac;
pos+=vel;
obj->x=(short)(pos>>16);
obj->xfrac=(short)pos;
*x=obj->x;
pos=(((long)(obj->y))<<16)+obj->yfrac;
vel=(((long)(obj->yv))<<16)+obj->yvfrac;
pos+=vel;
obj->y=(short)(pos>>16);
obj->yfrac=(short)pos;
*y=obj->y;
}
void writenum(int n,int width)
{
int c=0,zerof=1,exponent,dig;
if (n<0) {
n=-n;
writechar('-');
c++;
}
for (exponent=10000;exponent>1;exponent/=10) {
if ((dig=n/exponent)!=0 || zerof==0) {
zerof=0;
writechar(dig+'0');
c++;
}
n=n%exponent;
}
writechar(n+'0');
c++;
do {
c++;
if (c>width)
break;
writechar(' ');
} while (1);
}
void initasynch(void)
{
}
void createasynchremoteplane(void)
{
object *plane;
if (playerindex==0)
createplayerplane(NULL);
plane=createplane(NULL);
plane->soundfunc=soundplane;
plane->updatefunc=updateremoteplane;
plane->colour=1+(plane->index&1);
plane->source=plane;
plane->state=FLYING;
memcpy(&homes[plane->index],plane,sizeof(object));
if (playerindex!=0)
createplayerplane(NULL);
}
void getopt(int *argc,char **argv[],char *format,...)
{
va_list ap;
char **varg=*argv;
int carg=*argc;
char *arg,*p,*q,*a;
int i,**valp;
varg++;
while ((--carg)>0) {
arg=*varg;
if (*(arg++)!='-')
break;
if (*arg=='-') {
varg++;
carg--;
break;
}
p=arg;
va_start(ap,format);
q=format;
while (*q!=0) {
if (*q==':')
break;
i=0;
while (isalpha(q[i]))
i++;
if (strncmp(p,q,i)==0)
break;
q+=i;
if ((*q)!=0)
q++;
va_arg(ap,int);
}
if (*p!=*q) {
printf("Usage: ");
a=strchr(format,':');
if (a!=0) {
*(a++)=0;
q=strchr(a,'*');
if (q!=0) {
*(q++)=0;
printf("%s [-%s] %s\n",a,format,q);
}
else
printf("%s\n",a);
}
else
printf("cmd [-%s] args\n",format);
exit(0);
}
p=q+i;
arg+=i;
valp=(int **)(&va_arg(ap,int));
switch(*p) {
case '#':
a="%d";
if (*arg=='0') {
switch (*(++arg)) {
case 'o':
a="%o";
arg++;
break;
case 'x':
a="%x";
arg++;
}
}
sscanf(arg,a,*valp);
break;
case '*':
**valp=(int)arg;
break;
case '&':
**valp=(int)TRUE;
break;
default:
printf("Unknown format %c.\n",*p);
}
varg++;
}
*argv=varg;
*argc=carg;
}
object *newobject(void)
{
object *newobj;
if (nextobject==NULL)
return NULL;
newobj=nextobject;
nextobject=newobj->next;
newobj->next=NULL;
newobj->prev=lastobject;
if (lastobject!=NULL)
lastobject->next=newobj;
else
firstobject=newobj;
newobj->oldonscreen=newobj->onscreen=FALSE;
newobj->sndp=NULL;
if (newobj>maxobjectp)
maxobjectp=newobj;
return lastobject=newobj;
}
void deleteobject(object *obj)
{
object *other=obj->prev;
if (other!=NULL)
other->next=obj->next;
else
firstobject=obj->next;
other=obj->next;
if (other!=NULL)
other->prev=obj->prev;
else
lastobject=obj->prev;
obj->next=NULL;
if (lastdeleted)
lastdeleted->next=obj;
else
firstdeleted=obj;
lastdeleted=obj;
}
/* void randsd(void); */
/* void dispwindshot(void); */
/* void dispsplatbird(void); */
/* void dispoxsplat(void); */
void clearscorearea(void)
{
cgafbar(0,184,48,16,0);
}
void drawobject(int x,int y,object *obj)
{
putimage(x,y,obj->sprite,obj);
}
unsigned char blut[256]={
0x00,0x03,0x03,0x03,0x0c,0x0f,0x0f,0x0f,0x0c,0x0f,0x0f,0x0f,0x0c,0x0f,0x0f,0x0f,
0x30,0x33,0x33,0x33,0x3c,0x3f,0x3f,0x3f,0x3c,0x3f,0x3f,0x3f,0x3c,0x3f,0x3f,0x3f,
0x30,0x33,0x33,0x33,0x3c,0x3f,0x3f,0x3f,0x3c,0x3f,0x3f,0x3f,0x3c,0x3f,0x3f,0x3f,
0x30,0x33,0x33,0x33,0x3c,0x3f,0x3f,0x3f,0x3c,0x3f,0x3f,0x3f,0x3c,0x3f,0x3f,0x3f,
0xc0,0xc3,0xc3,0xc3,0xcc,0xcf,0xcf,0xcf,0xcc,0xcf,0xcf,0xcf,0xcc,0xcf,0xcf,0xcf,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,
0xc0,0xc3,0xc3,0xc3,0xcc,0xcf,0xcf,0xcf,0xcc,0xcf,0xcf,0xcf,0xcc,0xcf,0xcf,0xcf,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,
0xc0,0xc3,0xc3,0xc3,0xcc,0xcf,0xcf,0xcf,0xcc,0xcf,0xcf,0xcf,0xcc,0xcf,0xcf,0xcf,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,
0xf0,0xf3,0xf3,0xf3,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff
};
int bitblt(int x,int y,object *obj)
{
unsigned int linediff,bltreg;
unsigned char far *scp;
int width,height,border;
unsigned char retval=0,shift,bltleft;
unsigned char *p=obj->sprite;
if (obj->height==1 && obj->width==1)
return pixel(x,y,(int)p);
shift=8-((x&3)<<1);
width=(obj->width)>>2;
border=width-(80-(x>>2));
if (border>0)
width=80-(x>>2);
height=(obj->height>y+1 ? y+1 : obj->height);
scp=(unsigned char far *)MK_FP(scrseg,scroff+((199-y)>>1)*80+(x>>2));
linediff=interlacediff;
if ((y&1)==0) {
scp+=linediff;
linediff=80-linediff;
}
do {
bltleft=0;
for (x=0;x<width;x++) {
bltreg=((*p++)<<shift)|(bltleft<<8);
retval|=(*scp)&blut[bltreg>>8];
*(scp++)^=(bltreg>>8);
bltleft=bltreg;
}
if (border>=0)
p+=border;
else
if (bltleft!=0) {
retval|=(*scp)&blut[bltleft];
(*scp)^=bltleft;
}
scp+=linediff-width;
linediff=80-linediff;
height--;
} while (height!=0);
return retval;
}
void putimage(int x,int y,unsigned char *p,object *obj)
{
unsigned int linediff,bltreg;
unsigned char far *scp;
int width,height,border;
unsigned char shift,bltleft,col;
if (obj->height==1 && obj->width==1) {
putpixel(x,y,(int)p);
return;
}
col=(obj->colour==1 ? 0 : 0xff);
shift=8-((x&3)<<1);
width=(obj->width)>>2;
border=width-(80-(x>>2));
if (border>0)
width=80-(x>>2);
height=(obj->height>y+1 ? y+1 : obj->height);
scp=(unsigned char far *)MK_FP(scrseg,scroff+((199-y)>>1)*80+(x>>2));
linediff=interlacediff;
if ((y&1)==0) {
scp+=linediff;
linediff=80-linediff;
}
do {
bltleft=0;
for (x=0;x<width;x++) {
bltreg=((*p++)<<shift)|(bltleft<<8);
*(scp++)^=(bltreg>>8)^(blut[bltreg>>8]&col);
bltleft=bltreg;
}
if (border>=0)
p+=border;
else
if (bltleft!=0)
(*scp)^=bltleft^(blut[bltleft]&col);
scp+=linediff-width;
linediff=80-linediff;
height--;
} while (height!=0);
}
void putpixel(int x,int y,int c)
{
int shift=(3-(x&3))<<1;
unsigned char far *scp=(unsigned char far *)MK_FP(scrseg,scroff+((199-y)>>1)*80+(x>>2)+((y&1)==0 ? interlacediff : 0));
if ((c&0x80)==0)
*scp=((*scp)&(~(3<<shift)))|(c<<shift);
else
*scp^=((c&0x7f)<<shift);
}
int pixel(int x,int y,int c)
{
int shift=(3-(x&3))<<1;
unsigned char far *scp=(unsigned char far *)MK_FP(scrseg,scroff+((199-y)>>1)*80+(x>>2)+((y&1)==0 ? interlacediff : 0));
unsigned char o=(3<<shift)&(*scp);
if ((c&0x80)==0) {
*scp^=o;
*scp|=(c<<shift);
}
else
*scp^=(c&0x7f)<<shift;
return o>>shift;
}
| 22.815804
| 121
| 0.60572
|
[
"object"
] |
b232241ea942b93594909f2b58718f9f6ad32ec9
| 18,272
|
h
|
C
|
parc/concurrent/parc_Thread.h
|
parc-ccnx-archive/Libparc
|
ea4d62db143c2d54ae51222c969fd600ffc9d28f
|
[
"BSD-2-Clause"
] | 4
|
2016-10-18T20:00:41.000Z
|
2018-10-22T07:55:31.000Z
|
parc/concurrent/parc_Thread.h
|
parc-ccnx-archive/Libparc
|
ea4d62db143c2d54ae51222c969fd600ffc9d28f
|
[
"BSD-2-Clause"
] | 9
|
2016-02-03T01:10:07.000Z
|
2017-09-04T13:07:55.000Z
|
parc/concurrent/parc_Thread.h
|
parc-ccnx-archive/Libparc
|
ea4d62db143c2d54ae51222c969fd600ffc9d28f
|
[
"BSD-2-Clause"
] | 16
|
2016-02-02T00:59:55.000Z
|
2019-04-01T18:51:54.000Z
|
/*
* Copyright (c) 2013-2015, Xerox Corporation (Xerox) and Palo Alto Research Center, Inc (PARC)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL XEROX OR PARC BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ################################################################################
* #
* # PATENT NOTICE
* #
* # This software is distributed under the BSD 2-clause License (see LICENSE
* # file). This BSD License does not make any patent claims and as such, does
* # not act as a patent grant. The purpose of this section is for each contributor
* # to define their intentions with respect to intellectual property.
* #
* # Each contributor to this source code is encouraged to state their patent
* # claims and licensing mechanisms for any contributions made. At the end of
* # this section contributors may each make their own statements. Contributor's
* # claims and grants only apply to the pieces (source code, programs, text,
* # media, etc) that they have contributed directly to this software.
* #
* # There is no guarantee that this section is complete, up to date or accurate. It
* # is up to the contributors to maintain their portion of this section and up to
* # the user of the software to verify any claims herein.
* #
* # Do not remove this header notification. The contents of this section must be
* # present in all distributions of the software. You may only modify your own
* # intellectual property statements. Please provide contact information.
*
* - Palo Alto Research Center, Inc
* This software distribution does not grant any rights to patents owned by Palo
* Alto Research Center, Inc (PARC). Rights to these patents are available via
* various mechanisms. As of January 2016 PARC has committed to FRAND licensing any
* intellectual property used by its contributions to this software. You may
* contact PARC at [email protected] for more information or visit http://www.ccnx.org
*/
/**
* @file parc_Thread.h
* @ingroup threading
* @brief <#Brief Description#>
*
* <#Detailed Description#>
*
* @author Glenn Scott Computing Science Laboratory, PARC
* @copyright (c) 2013-2015, Xerox Corporation (Xerox) and Palo Alto Research Center, Inc (PARC). All rights reserved.
*/
#ifndef PARCLibrary_parc_Thread
#define PARCLibrary_parc_Thread
#include <stdbool.h>
#include <parc/algol/parc_JSON.h>
#include <parc/algol/parc_HashCode.h>
struct PARCThread;
typedef struct PARCThread PARCThread;
/**
* Increase the number of references to a `PARCThread` instance.
*
* Note that new `PARCThread` is not created,
* only that the given `PARCThread` reference count is incremented.
* Discard the reference by invoking `parcThread_Release`.
*
* @param [in] instance A pointer to a valid PARCThread instance.
*
* @return The same value as @p instance.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* PARCThread *b = parcThread_Acquire();
*
* parcThread_Release(&a);
* parcThread_Release(&b);
* }
* @endcode
*/
PARCThread *parcThread_Acquire(const PARCThread *instance);
#ifdef PARCLibrary_DISABLE_VALIDATION
# define parcThread_OptionalAssertValid(_instance_)
#else
# define parcThread_OptionalAssertValid(_instance_) parcThread_AssertValid(_instance_)
#endif
/**
* Assert that the given `PARCThread` instance is valid.
*
* @param [in] instance A pointer to a valid PARCThread instance.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* parcThread_AssertValid(a);
*
* printf("Instance is valid.\n");
*
* parcThread_Release(&b);
* }
* @endcode
*/
void parcThread_AssertValid(const PARCThread *instance);
/**
* Create an instance of PARCThread
*
* @return non-NULL A pointer to a valid PARCThread instance.
* @return NULL An error occurred.
*
* Example:
* @code
* {
*
* MyTask *task = myTask_Create();
* PARCThread *thread = parcThread_Create(myTask_Run, myTask);
*
* parcThread_Start(a);
*
* parcThread_Release(&a);
* }
* @endcode
*/
//#define parcThread_Create(_runFunction_, _argument_) parcThread_CreateImpl((void (*)(PARCObject *)) _runFunction_, (PARCObject *) _argument_)
PARCThread *parcThread_Create(void *(*run)(PARCThread *, PARCObject *), PARCObject *restrict argument);
/**
* Compares @p instance with @p other for order.
*
* Returns a negative integer, zero, or a positive integer as @p instance
* is less than, equal to, or greater than @p other.
*
* @param [in] instance A pointer to a valid PARCThread instance.
* @param [in] other A pointer to a valid PARCThread instance.
*
* @return <0 Instance is less than @p other.
* @return 0 Instance a and instance b compare the same.
* @return >0 Instance a is greater than instance b.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
* PARCThread *b = parcThread_Create();
*
* if (parcThread_Compare(a, b) == 0) {
* printf("Instances are equal.\n");
* }
*
* parcThread_Release(&a);
* parcThread_Release(&b);
* }
* @endcode
*
* @see parcThread_Equals
*/
int parcThread_Compare(const PARCThread *instance, const PARCThread *other);
/**
* Create an independent copy the given `PARCBuffer`
*
* A new buffer is created as a complete copy of the original.
*
* @param [in] original A pointer to a valid PARCThread instance.
*
* @return NULL Memory could not be allocated.
* @return non-NULL A pointer to a new `PARCThread` instance.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* PARCThread *copy = parcThread_Copy(&b);
*
* parcThread_Release(&b);
* parcThread_Release(©);
* }
* @endcode
*/
PARCThread *parcThread_Copy(const PARCThread *original);
/**
* Print a human readable representation of the given `PARCThread`.
*
* @param [in] instance A pointer to a valid PARCThread instance.
* @param [in] indentation The indentation level to use for printing.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* parcThread_Display(a, 0);
*
* parcThread_Release(&a);
* }
* @endcode
*/
void parcThread_Display(const PARCThread *instance, int indentation);
/**
* Determine if two `PARCThread` instances are equal.
*
* The following equivalence relations on non-null `PARCThread` instances are maintained: *
* * It is reflexive: for any non-null reference value x, `parcThread_Equals(x, x)` must return true.
*
* * It is symmetric: for any non-null reference values x and y, `parcThread_Equals(x, y)` must return true if and only if
* `parcThread_Equals(y x)` returns true.
*
* * It is transitive: for any non-null reference values x, y, and z, if
* `parcThread_Equals(x, y)` returns true and
* `parcThread_Equals(y, z)` returns true,
* then `parcThread_Equals(x, z)` must return true.
*
* * It is consistent: for any non-null reference values x and y, multiple invocations of `parcThread_Equals(x, y)`
* consistently return true or consistently return false.
*
* * For any non-null reference value x, `parcThread_Equals(x, NULL)` must return false.
*
* @param [in] x A pointer to a valid PARCThread instance.
* @param [in] y A pointer to a valid PARCThread instance.
*
* @return true The instances x and y are equal.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
* PARCThread *b = parcThread_Create();
*
* if (parcThread_Equals(a, b)) {
* printf("Instances are equal.\n");
* }
*
* parcThread_Release(&a);
* parcThread_Release(&b);
* }
* @endcode
* @see parcThread_HashCode
*/
bool parcThread_Equals(const PARCThread *x, const PARCThread *y);
/**
* Returns a hash code value for the given instance.
*
* The general contract of `HashCode` is:
*
* Whenever it is invoked on the same instance more than once during an execution of an application,
* the `HashCode` function must consistently return the same value,
* provided no information used in a corresponding comparisons on the instance is modified.
*
* This value need not remain consistent from one execution of an application to another execution of the same application.
* If two instances are equal according to the {@link parcThread_Equals} method,
* then calling the {@link parcThread_HashCode} method on each of the two instances must produce the same integer result.
*
* It is not required that if two instances are unequal according to the
* {@link parcThread_Equals} function,
* then calling the `parcThread_HashCode`
* method on each of the two objects must produce distinct integer results.
*
* @param [in] instance A pointer to a valid PARCThread instance.
*
* @return The hashcode for the given instance.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* PARCHashCode hashValue = parcThread_HashCode(buffer);
* parcThread_Release(&a);
* }
* @endcode
*/
PARCHashCode parcThread_HashCode(const PARCThread *instance);
/**
* Determine if an instance of `PARCThread` is valid.
*
* Valid means the internal state of the type is consistent with its required current or future behaviour.
* This may include the validation of internal instances of types.
*
* @param [in] instance A pointer to a valid PARCThread instance.
*
* @return true The instance is valid.
* @return false The instance is not valid.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* if (parcThread_IsValid(a)) {
* printf("Instance is valid.\n");
* }
*
* parcThread_Release(&a);
* }
* @endcode
*
*/
bool parcThread_IsValid(const PARCThread *instance);
/**
* Release a previously acquired reference to the given `PARCThread` instance,
* decrementing the reference count for the instance.
*
* The pointer to the instance is set to NULL as a side-effect of this function.
*
* If the invocation causes the last reference to the instance to be released,
* the instance is deallocated and the instance's implementation will perform
* additional cleanup and release other privately held references.
*
* @param [in,out] instancePtr A pointer to a pointer to the instance to release.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* parcThread_Release(&a);
* }
* @endcode
*/
void parcThread_Release(PARCThread **instancePtr);
/**
* Create a `PARCJSON` instance (representation) of the given object.
*
* @param [in] instance A pointer to a valid PARCThread instance.
*
* @return NULL Memory could not be allocated to contain the `PARCJSON` instance.
* @return non-NULL An allocated C string that must be deallocated via parcMemory_Deallocate().
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* PARCJSON *json = parcThread_ToJSON(a);
*
* printf("JSON representation: %s\n", parcJSON_ToString(json));
* parcJSON_Release(&json);
*
* parcThread_Release(&a);
* }
* @endcode
*/
PARCJSON *parcThread_ToJSON(const PARCThread *instance);
/**
* Produce a null-terminated string representation of the specified `PARCThread`.
*
* The result must be freed by the caller via {@link parcMemory_Deallocate}.
*
* @param [in] instance A pointer to a valid PARCThread instance.
*
* @return NULL Cannot allocate memory.
* @return non-NULL A pointer to an allocated, null-terminated C string that must be deallocated via {@link parcMemory_Deallocate}.
*
* Example:
* @code
* {
* PARCThread *a = parcThread_Create();
*
* char *string = parcThread_ToString(a);
*
* parcThread_Release(&a);
*
* parcMemory_Deallocate(&string);
* }
* @endcode
*
* @see parcThread_Display
*/
char *parcThread_ToString(const PARCThread *instance);
/**
* Wakes up a single thread that is waiting on this object (see `parcLinkedList_Wait)`.
* If any threads are waiting on this object, one of them is chosen to be awakened.
* The choice is arbitrary and occurs at the discretion of the underlying implementation.
*
* The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object.
* The awakened thread will compete in the usual manner with any other threads that might be actively
* competing to synchronize on this object;
* for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.
*
* @param [in] object A pointer to a valid PARCThread instance.
*
* Example:
* @code
* {
*
* parcThread_Notify(object);
* }
* @endcode
*/
parcObject_ImplementNotify(parcThread, PARCThread);
/**
* Causes the calling thread to wait until either another thread invokes the parcHashMap_Notify() function on the same object.
* *
* @param [in] object A pointer to a valid `PARCThread` instance.
*
* Example:
* @code
* {
*
* parcThread_Wait(object);
* }
* @endcode
*/
parcObject_ImplementWait(parcThread, PARCThread);
/**
* Obtain the lock on the given `PARCThread` instance.
*
* If the lock is already held by another thread, this function will block.
* If the lock is aleady held by the current thread, this function will return `false`.
*
* Implementors must avoid deadlock by attempting to lock the object a second time within the same calling thread.
*
* @param [in] object A pointer to a valid `PARCThread` instance.
*
* @return true The lock was obtained successfully.
* @return false The lock is already held by the current thread, or the `PARCThread` is invalid.
*
* Example:
* @code
* {
* if (parcThread_Lock(object)) {
*
* }
* }
* @endcode
*/
parcObject_ImplementLock(parcThread, PARCThread);
/**
* Try to obtain the advisory lock on the given PARCThread instance.
*
* Once the lock is obtained, the caller must release the lock as soon as possible.
*
* @param [in] object A pointer to a valid PARCThread instance.
*
* @return true The PARCThread is locked.
* @return false The PARCThread is unlocked.
*
* Example:
* @code
* {
* parcThread_TryLock(object);
* }
* @endcode
*/
parcObject_ImplementTryLock(parcThread, PARCThread);
/**
* Try to unlock the advisory lock on the given `PARCHashMap` instance.
*
* @param [in] object A pointer to a valid `PARCThread` instance.
*
* @return true The `PARCThread` was locked and now is unlocked.
* @return false The `PARCThread` was not locked and remains unlocked.
*
* Example:
* @code
* {
* parcThread_Unlock(object);
* }
* @endcode
*/
parcObject_ImplementUnlock(parcThread, PARCThread);
/**
* Determine if the advisory lock on the given `PARCThread` instance is locked.
*
* @param [in] object A pointer to a valid `PARCThread` instance.
*
* @return true The `PARCThread` is locked.
* @return false The `PARCThread` is unlocked.
* Example:
* @code
* {
* if (parcThread_IsLocked(object)) {
* ...
* }
* }
* @endcode
*/
parcObject_ImplementIsLocked(parcThread, PARCThread);
/**
* <#One Line Description#>
*
* <#Paragraphs Of Explanation#>
*
* @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
*
* @return <#value#> <#explanation#>
*
* Example:
* @code
* {
* <#example#>
* }
* @endcode
*/
void parcThread_Start(PARCThread *thread);
/**
* <#One Line Description#>
*
* <#Paragraphs Of Explanation#>
*
* @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
*
* @return <#value#> <#explanation#>
*
* Example:
* @code
* {
* <#example#>
* }
* @endcode
*/
PARCObject *parcThread_GetParameter(const PARCThread *thread);
/**
* <#One Line Description#>
*
* <#Paragraphs Of Explanation#>
*
* @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
*
* @return <#value#> <#explanation#>
*
* Example:
* @code
* {
* <#example#>
* }
* @endcode
*/
bool parcThread_Cancel(PARCThread *thread);
/**
* <#One Line Description#>
*
* <#Paragraphs Of Explanation#>
*
* @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
*
* @return <#value#> <#explanation#>
*
* Example:
* @code
* {
* <#example#>
* }
* @endcode
*/
bool parcThread_IsCancelled(const PARCThread *thread);
/**
* <#One Line Description#>
*
* <#Paragraphs Of Explanation#>
*
* @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
*
* @return <#value#> <#explanation#>
*
* Example:
* @code
* {
* <#example#>
* }
* @endcode
*/
bool parcThread_IsRunning(const PARCThread *thread);
/**
* <#One Line Description#>
*
* <#Paragraphs Of Explanation#>
*
* @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
*
* @return <#value#> <#explanation#>
*
* Example:
* @code
* {
* <#example#>
* }
* @endcode
*/
int parcThread_GetId(const PARCThread *thread);
/**
* <#One Line Description#>
*
* <#Paragraphs Of Explanation#>
*
* @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
*
* @return <#value#> <#explanation#>
*
* Example:
* @code
* {
* <#example#>
* }
* @endcode
*/
void parcThread_Join(PARCThread *thread);
#endif
| 28.416796
| 143
| 0.68345
|
[
"object"
] |
b23e0ad6f2bf8ccd3f8f171c3907bacbd92826e7
| 707
|
h
|
C
|
DEM/Src/L2/Physics/Collision/SphereShape.h
|
moltenguy1/deusexmachina
|
134f4ca4087fff791ec30562cb250ccd50b69ee1
|
[
"MIT"
] | 2
|
2017-04-30T20:24:29.000Z
|
2019-02-12T08:36:26.000Z
|
DEM/Src/L2/Physics/Collision/SphereShape.h
|
moltenguy1/deusexmachina
|
134f4ca4087fff791ec30562cb250ccd50b69ee1
|
[
"MIT"
] | null | null | null |
DEM/Src/L2/Physics/Collision/SphereShape.h
|
moltenguy1/deusexmachina
|
134f4ca4087fff791ec30562cb250ccd50b69ee1
|
[
"MIT"
] | null | null | null |
#pragma once
#ifndef __DEM_L2_PHYSICS_SPHERE_SHAPE_H__ //!!!to L1!
#define __DEM_L2_PHYSICS_SPHERE_SHAPE_H__
#include "Shape.h"
// Spherical collision shape
namespace Physics
{
class CSphereShape: public CShape
{
DeclareRTTI;
DeclareFactory(CSphereShape);
private:
float Radius;
public:
CSphereShape(): CShape(Sphere), Radius(1.0f) {}
virtual ~CSphereShape() {}
virtual void Init(Data::PParams Desc);
virtual bool Attach(dSpaceID SpaceID);
virtual void RenderDebug(const matrix44& ParentTfm);
void SetRadius(float R) { n_assert(!IsAttached()); Radius = R; }
float GetRadius() const { return Radius; }
};
RegisterFactory(CSphereShape);
}
#endif
| 18.605263
| 68
| 0.705799
|
[
"shape"
] |
b23e5f47cfcdaa8da1f4946af7725d148d53d448
| 8,347
|
h
|
C
|
interfaces/innerkits/libdbinder/include/dbinder_service.h
|
openharmony-sig-ci/communication_ipc
|
212baa3affdf10a365657464c4e86e8fdab4224c
|
[
"Apache-2.0"
] | 3
|
2021-11-16T20:51:58.000Z
|
2022-02-28T21:21:11.000Z
|
interfaces/innerkits/libdbinder/include/dbinder_service.h
|
openharmony-sig-ci/communication_ipc
|
212baa3affdf10a365657464c4e86e8fdab4224c
|
[
"Apache-2.0"
] | null | null | null |
interfaces/innerkits/libdbinder/include/dbinder_service.h
|
openharmony-sig-ci/communication_ipc
|
212baa3affdf10a365657464c4e86e8fdab4224c
|
[
"Apache-2.0"
] | 1
|
2021-09-13T12:07:50.000Z
|
2021-09-13T12:07:50.000Z
|
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* 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
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef OHOS_IPC_SERVICES_DBINDER_DBINDER_SERVICE_H
#define OHOS_IPC_SERVICES_DBINDER_DBINDER_SERVICE_H
#include <string>
#include <map>
#include <mutex>
#include <shared_mutex>
#include <memory>
#include <list>
#include <thread>
#include "ipc_object_proxy.h"
#include "ipc_object_stub.h"
#include "dbinder_service_stub.h"
namespace OHOS {
class DBinderRemoteListener;
constexpr int DEVICEID_LENGTH = 64;
constexpr int SERVICENAME_LENGTH = 200;
constexpr int VERSION_NUM = 1;
constexpr int ENCRYPT_HEAD_LEN = 28;
constexpr int ENCRYPT_LENGTH = 4;
struct DeviceIdInfo {
uint16_t afType;
uint16_t reserved;
char fromDeviceId[DEVICEID_LENGTH + 1];
char toDeviceId[DEVICEID_LENGTH + 1];
};
struct DHandleEntryHead {
uint32_t len;
uint32_t version;
};
struct DHandleEntryTxRx {
struct DHandleEntryHead head;
uint32_t transType;
uint32_t dBinderCode;
uint16_t fromPort;
uint16_t toPort;
uint64_t stubIndex;
uint32_t seqNumber;
binder_uintptr_t binderObject;
struct DeviceIdInfo deviceIdInfo;
binder_uintptr_t stub;
uint16_t serviceNameLength;
char serviceName[SERVICENAME_LENGTH + 1];
uint32_t pid;
uint32_t uid;
};
struct SessionInfo {
uint32_t type;
uint16_t toPort;
uint16_t fromPort;
uint64_t stubIndex;
uint32_t socketFd;
std::string serviceName;
struct DeviceIdInfo deviceIdInfo;
};
enum DBinderCode {
MESSAGE_AS_INVOKER = 1,
MESSAGE_AS_REPLY = 2,
MESSAGE_AS_OBITUARY = 3,
};
enum AfType {
IPV4_TYPE = 1,
IPV6_TYPE = 2,
DATABBUS_TYPE = 3,
};
struct ThreadLockInfo {
std::mutex mutex;
std::condition_variable condition;
bool ready = false;
};
class DBinderService : public virtual RefBase {
public:
DBinderService();
virtual ~DBinderService();
public:
static sptr<DBinderService> GetInstance();
bool StartDBinderService();
sptr<DBinderServiceStub> MakeRemoteBinder(const std::u16string &serviceName,
const std::string &deviceID, binder_uintptr_t binderObject, uint64_t pid = 0);
bool RegisterRemoteProxy(std::u16string serviceName, sptr<IRemoteObject> binderObject);
bool RegisterRemoteProxy(std::u16string serviceName, int32_t systemAbilityId);
bool OnRemoteMessageTask(const struct DHandleEntryTxRx *message);
std::shared_ptr<struct SessionInfo> QuerySessionObject(binder_uintptr_t stub);
bool DetachDeathRecipient(sptr<IRemoteObject> object);
bool AttachDeathRecipient(sptr<IRemoteObject> object, sptr<IRemoteObject::DeathRecipient> deathRecipient);
sptr<IRemoteObject::DeathRecipient> QueryDeathRecipient(sptr<IRemoteObject> object);
bool DetachCallbackProxy(sptr<IRemoteObject> object);
bool AttachCallbackProxy(sptr<IRemoteObject> object, DBinderServiceStub *dbStub);
int32_t NoticeServiceDie(const std::u16string &serviceName, const std::string &deviceID);
int32_t NoticeDeviceDie(const std::string &deviceID);
bool DetachBusNameObject(IPCObjectProxy *proxy);
std::string CreateDatabusName(int uid, int pid);
bool DetachProxyObject(binder_uintptr_t binderObject);
private:
static std::shared_ptr<DBinderRemoteListener> GetRemoteListener();
static bool StartRemoteListener();
static void StopRemoteListener();
static std::string ConvertToSecureDeviceID(const std::string &deviceID);
std::u16string GetRegisterService(binder_uintptr_t binderObject);
bool InvokerRemoteDBinder(const sptr<DBinderServiceStub> stub, uint32_t seqNumber);
bool OnRemoteReplyMessage(const struct DHandleEntryTxRx *replyMessage);
void MakeSessionByReplyMessage(const struct DHandleEntryTxRx *replyMessage);
bool OnRemoteInvokerMessage(const struct DHandleEntryTxRx *message);
void WakeupThreadByStub(uint32_t seqNumber);
void DetachThreadLockInfo(uint32_t seqNumber);
bool AttachThreadLockInfo(uint32_t seqNumber, std::shared_ptr<struct ThreadLockInfo> object);
std::shared_ptr<struct ThreadLockInfo> QueryThreadLockInfo(uint32_t seqNumber);
bool AttachProxyObject(sptr<IRemoteObject> object, binder_uintptr_t binderObject);
sptr<IRemoteObject> QueryProxyObject(binder_uintptr_t binderObject);
bool DetachSessionObject(binder_uintptr_t stub);
bool AttachSessionObject(std::shared_ptr<struct SessionInfo> object, binder_uintptr_t stub);
sptr<IRemoteObject> FindOrNewProxy(binder_uintptr_t binderObject, int32_t systemAbilityId);
bool SendEntryToRemote(const sptr<DBinderServiceStub> stub, uint32_t seqNumber);
uint16_t AllocFreeSocketPort();
std::string GetLocalDeviceID();
bool CheckBinderObject(const sptr<DBinderServiceStub> &stub, binder_uintptr_t binderObject);
bool HasDBinderStub(binder_uintptr_t binderObject);
bool IsSameStubObject(const sptr<DBinderServiceStub> &stub, const std::u16string &service,
const std::string &device);
sptr<DBinderServiceStub> FindDBinderStub(const std::u16string &service, const std::string &device);
bool DeleteDBinderStub(const std::u16string &service, const std::string &device);
sptr<DBinderServiceStub> FindOrNewDBinderStub(const std::u16string &service,
const std::string &device, binder_uintptr_t binderObject);
void ProcessCallbackProxy(sptr<DBinderServiceStub> dbStub);
bool NoticeCallbackProxy(sptr<DBinderServiceStub> dbStub);
std::list<std::u16string> FindServicesByDeviceID(const std::string &deviceID);
int32_t NoticeServiceDieInner(const std::u16string &serviceName, const std::string &deviceID);
uint32_t GetRemoteTransType();
bool OnRemoteInvokerDataBusMessage(IPCObjectProxy *proxy, struct DHandleEntryTxRx *replyMessage,
std::string &remoteDeviceId, int pid, int uid);
bool IsDeviceIdIllegal(const std::string &deviceID);
bool AttachBusNameObject(IPCObjectProxy *proxy, const std::string &name);
std::string QueryBusNameObject(IPCObjectProxy *proxy);
std::string GetDatabusNameByProxy(IPCObjectProxy *proxy);
uint32_t GetSeqNumber();
bool RegisterRemoteProxyInner(std::u16string serviceName, binder_uintptr_t binder);
bool CheckSystemAbilityId(int32_t systemAbilityId);
private:
DISALLOW_COPY_AND_MOVE(DBinderService);
static std::mutex instanceMutex_;
static constexpr int WAIT_FOR_REPLY_MAX_SEC = 4;
static constexpr int RETRY_TIMES = 2;
static std::shared_ptr<DBinderRemoteListener> remoteListener_;
static bool mainThreadCreated_;
static sptr<DBinderService> instance_;
std::shared_mutex remoteBinderMutex_;
std::shared_mutex busNameMutex_;
std::shared_mutex proxyMutex_;
std::shared_mutex deathRecipientMutex_;
std::shared_mutex sessionMutex_;
std::mutex handleEntryMutex_;
std::mutex threadLockMutex_;
std::mutex callbackProxyMutex_;
std::mutex deathNotificationMutex_;
uint32_t seqNumber_ = 0; /* indicate make remote binder message sequence number, and can be overflow */
std::list<sptr<DBinderServiceStub>> DBinderStubRegisted_;
std::map<std::u16string, binder_uintptr_t> mapRemoteBinderObjects_;
std::map<uint32_t, std::shared_ptr<struct ThreadLockInfo>> threadLockInfo_;
std::map<int, sptr<IRemoteObject>> proxyObject_;
std::map<binder_uintptr_t, std::shared_ptr<struct SessionInfo>> sessionObject_;
std::map<sptr<IRemoteObject>, DBinderServiceStub *> noticeProxy_;
std::map<sptr<IRemoteObject>, sptr<IRemoteObject::DeathRecipient>> deathRecipients_;
std::map<IPCObjectProxy *, std::string> busNameObject_;
static constexpr int32_t FIRST_SYS_ABILITY_ID = 0x00000001;
static constexpr int32_t LAST_SYS_ABILITY_ID = 0x00ffffff;
};
} // namespace OHOS
#endif // OHOS_IPC_SERVICES_DBINDER_DBINDER_SERVICE_H
| 41.735
| 110
| 0.766743
|
[
"object"
] |
b24423ce47ccbcb16b424be51e67e0f124684c46
| 12,597
|
h
|
C
|
BSON/BSONEncoder.h
|
paulmelnikow/ObjCMongoDB
|
16de7e22bbc1ac2ac423b6c443955d49ae219993
|
[
"Apache-2.0"
] | 59
|
2015-01-14T05:32:07.000Z
|
2022-03-23T20:14:26.000Z
|
BSON/BSONEncoder.h
|
paulmelnikow/ObjCMongoDB
|
16de7e22bbc1ac2ac423b6c443955d49ae219993
|
[
"Apache-2.0"
] | 9
|
2015-01-12T14:49:55.000Z
|
2017-09-22T03:55:48.000Z
|
BSON/BSONEncoder.h
|
paulmelnikow/ObjCMongoDB
|
16de7e22bbc1ac2ac423b6c443955d49ae219993
|
[
"Apache-2.0"
] | 13
|
2015-02-22T03:11:28.000Z
|
2018-06-12T15:13:43.000Z
|
//
// BSONEncoder.h
// ObjCMongoDB
//
// Copyright 2012 Paul Melnikow and other contributors
//
// 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
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#if TARGET_OS_IPHONE
#import <UIKit/UIKit.h>
#else
#import <AppKit/AppKit.h>
#endif
#import <Foundation/Foundation.h>
#import "BSONTypes.h"
typedef enum {
BSONDoNothingOnNil,
BSONEncodeNullOnNil,
BSONRaiseExceptionOnNil
} BSONEncoderBehaviorOnNil;
@class BSONEncoder;
@class BSONDocument;
/**
Supports context-dependent encoding with BSONEncoder. Implement these methods to customize encoding by
reference, or to handle encoding of an object graph when you don't want to add BSON-related code to the
object-graph classes.
These methods are never called with the root object as <code>obj</code>.
By all means use the delegate instead of subclassing BSONEncoder.
*/
@protocol BSONEncoderDelegate
@optional
/**
Return <code>YES</code> to indicate that in the given context the encoder should encode an object ID in
place of the object. If this method returns <code>YES</code>, the object must respond to
<code>-BSONObjectID</code> or <code>-BSONObjectIDForEncoder:</code>. Return <code>NO</code> to proceed
normally with encoding.
You may use the key path, key path depth, the object, or the delegate's own state.
The encoder calls this method before the <code>-willEncodeObject:forKeyPath:</code> delegate method, and in turn
before it calls <code>-encodeWithCoder:</code> on <code>obj</code>.
@param encoder The active encoder
@param obj The object about to be encoded
@param keyPathComponents An array of keys descending from the root object (including numbers as strings in
the case of array elements)
@return <code>YES</code> to substite an object ID, <code>NO</code> to encode normally
*/
- (BOOL) encoder:(BSONEncoder *) encoder shouldSubstituteObjectIDForObject:(id) obj forKeyPath:(NSArray *) keyPathComponents;
/**
Provides a substitute
Return <code>obj</code> to proceed normally with encoding.
You may use the key path, key path depth, the object, or the delegate's own state.
The encoder calls this method after it calls the <code>-shouldSubstituteObjectIDForObject:forKeyPath:</code>
delegate method, and before it calls <code>-encodeWithCoder:</code> is called on <code>obj</code>.
@param encoder The active encoder
@param obj The object about to be encoded
@param keyPathComponents An array of keys descending from the root object (including numbers as strings in
the case of array elements)
@return The object to substitute for the given object
*/
- (id) encoder:(BSONEncoder *) encoder willEncodeObject:(id) obj forKeyPath:(NSArray *) keyPathComponents;
- (void) encoder:(BSONEncoder *) encoder willReplaceObject:(id) obj withObject:(id) replacementObj forKeyPath:(NSArray *) keyPathComponents;
- (void) encoder:(BSONEncoder *) encoder didEncodeObject:(id) obj forKeyPath:(NSArray *) keyPathComponents;
- (void) encoderWillFinish:(BSONEncoder *) encoder;
- (void) encoderDidFinish:(BSONEncoder *) encoder;
@end
/**
Creates a BSON document from a root object. <code>BSONEncoder</code> handles BSON-supported types,
arrays and dictionaries, custom objects which conform to <code>NSCoding</code> and support keyed
archiving, and Core Data managed objects.
Invoke <code>BSONDocument</code> to finish encoding and return the encoded document. To encode another
root object, instantiate another encoder.
As much as possible <code>BSONEncoder</code> follows the design of <code>NSCoder</code>. For more
information, refer to Apple's Archives and Serializations Guide.
Important differences from <code>NSKeyedArchiver</code>:
- <code>BSONEncoder</code> provides its own encoding implementation for:
- <code>NSString</code>
- <code>NSNumber</code>
- <code>NSDate</code>
- <code>NSData</code>
- <code>NSImage or UIImage</code>
- <code>NSDictionary</code>
- <code>NSArray</code>
- <code>BSONObjectID</code> and the other classes defined in <code>BSONTypes.h</code>
- <code>BSONEncoder</code> does not store class information. While BSON documents include enough
type information to decode to appropriate Objective-C object types, <code>BSONDecoder</code> relies
on objects to provide class information for their descendent custom objects.
- <code>BSONEncoder</code> does not store version information.
- <code>BSONEncoder</code> does not support unkeyed coding. (If your custom objects can't implement
unkeyed coding, you can implement unkeyed coding by subclassing <code>BSONEncoder</code> and
overriding the unkeyed methods to automatically generate pre-defined, sequential key names, and
subclassing <code>BSONDecoder</code> to override the decoding methods to use these pre-defined key
names in the same sequence.)
- BSON documents may contain only one root object. Encoding multiple objects by encapsulating
them in an parent object, or by creating a separate BSON document for each one. (Each document
inserted into a MongoDB collection needs its own BSON document.)
- In MongoDB, key names may not contain <code>$</code> or <code.</code> characters. By default,
<code>BSONEncoder</code> throws an exception on illegal keys. You can control this behavior by
setting <code>restrictsKeyNamesForMongoDB</code> to <code>NO</code>. (Note that implementations
of <code>-encodeWithCoder:</code> in some Foundation classes may generate illegal keys. If this is
a problem, consider subclassing to mangle the keys so they're safe for MongoDB.)
- <code>BSONEncoder</code> does not allow objects to override their encoding with
<code>classForCoder</code>. Use <code>-encodeWithCoder:</code> (from <code>NSCoding</code>),
<code>-replacementObjectForCoder:</code> (from <code>NSObject</code>),
<code>-encodeWithBSONEncoder:</code>, or <code>-replacementObjectForBSONEncoder:</code> (both from
<code>BSONCoding</code>) instead.
- <code>BSONEncoder</code> does not automatically encode objects by reference, even duplicate objects.
(BSON's object ID type is useful for identifying a reference to another document in a MongoDB collection,
but unlike an Objective-C pointer, it can't be used to refer to a sub-object. A BSON object ID only
gets meaning in the context of a MongoDB collection. It has no meaning within a single document.) To
encode an object by reference, either the object or the delegate needs to substitute another object.
(See Encoding by Reference below.)
- To avoid infinite loops, <code>BSONEncoder</code> throws an exception if an object attempts to encode
its parent object or its direct ancestors. This check is done after object and delegate substitution,
so it isn't triggered when, for example, an object ID is substituted in place of a parent object.
- <code>BSONEncoderDelegate</code> provides a similar interface to <code>NSKeyedArchiverDelegate</code>,
but conveys additional state information in the encoder's key path, and provides an additional delegate
method for substituting object IDs during encoding.
Encoding by reference
While by default <code>BSONEncoder</code> embeds child objects, it provides a mechanism for substituting
BSON object IDs. If an object should <i>always</i> encode a child as an object ID, its
<code>-encodeWithCoder:</code> can invoke <code>-encodeObjectIDForObject:forKey:</code>. If the
appropriate behavior depends on context, have the delegate implement
<code>-encoder:shouldSubstituteObjectIDForObject:forKeyPath:</code>, and consider the key path,
key path depth, the object, or the delegate's own state.
For either of these to work, the child object must be able to generate an object ID by implementing
<code>BSONObjectID</code> or <code>BSONObjectIDForEncoder:</code> (defined in <code>BSONCoding</code>).
To encode some other reference structure, use one of the substitution methods of the object or delegate.
Controlling encoding of sub-objects
Objects may control their encoding by implementing one of these methods:
- <code>-encodeWithCoder:</code>
- <code>-encodeWithBSONEncoder:</code>
- <code>-replacementObjectForCoder:</code>
- <code>-replacementObjectForBSONEncoder:</code>
In addition, a delegate may control encoding by implementing one of these methods:
- <code>-encoder:shouldSubstituteObjectIDForObject:forKeyPath:</code>
- <code>-encoder:willEncodeObject:forKeyPath:</code>
Encoding managed objects
The <code>BSONCoding</code> category on <code>NSManagedObject</code> uses the entity description
to automatically encode the properties of managed objects. <code>NSManagedObject</code>'s default
implementation of <code>-encodeWithBSONEncoder:</code> uses the property names as key names, and
encodes all persistent attributes and relationships. If you need to skip certain relationships or
attributes, replace entities with references, or otherwise customize the encoding, override one of
the category's helper methods, providing your own logic where needed and invoking
<code>super</code> the rest of the time.
- <code>-encodeAttribute:withEncoder:</code>
- <code>-encodeRelationship:withEncoder:</code>
- <code>-encodeFetchedProperty:withEncoder:</code>
You can also override <code>-encodeWithBSONEncoder:</code> if necessary.
*/
@interface BSONEncoder : NSCoder
- (BSONEncoder *) initForWriting;
+ (BSONDocument *) documentForObject:(id) obj;
+ (BSONDocument *) documentForObject:(id) obj
restrictingKeyNamesForMongoDB:(BOOL) restrictingKeyNamesForMongoDB;
+ (BSONDocument *) documentForDictionary:(NSDictionary *) dictionary;
+ (BSONDocument *) documentForDictionary:(NSDictionary *) dictionary
restrictingKeyNamesForMongoDB:(BOOL) restrictingKeyNamesForMongoDB;
- (BSONDocument *) BSONDocument;
- (NSData *) data;
- (void) encodeObject:(id) obj;
- (void) encodeDictionary:(NSDictionary *) dictionary;
- (void) encodeObject:(id) objv forKey:(NSString *) key;
// objectid is substituted before other methods, eg delegate, are called
// objv must implement -BSONObjectID or -BSONObjectIDForEncoder: method
- (void) encodeObjectIDForObject:(id) objv forKey:(NSString *) key;
- (void) encodeDictionary:(NSDictionary *) dictionary forKey:(NSString *) key;
- (void) encodeArray:(NSArray *) array forKey:(NSString *) key;
- (void) encodeBSONDocument:(BSONDocument *) objv forKey:(NSString *) key;
- (void) encodeNullForKey:(NSString *) key;
- (void) encodeUndefinedForKey:(NSString *) key;
- (void) encodeNewObjectID;
- (void) encodeObjectID:(BSONObjectID *)objv forKey:(NSString *) key;
- (void) encodeInt:(int) intv forKey:(NSString *) key;
- (void) encodeInt64:(int64_t) intv forKey:(NSString *) key;
- (void) encodeBool:(BOOL) boolv forKey:(NSString *) key;
- (void) encodeDouble:(double) realv forKey:(NSString *) key;
- (void) encodeNumber:(NSNumber *) objv forKey:(NSString *) key;
- (void) encodeString:(NSString *)objv forKey:(NSString *) key;
- (void) encodeSymbol:(BSONSymbol *)objv forKey:(NSString *) key;
- (void) encodeDate:(NSDate *) objv forKey:(NSString *) key;
#if TARGET_OS_IPHONE
- (void) encodeImage:(UIImage *) objv forKey:(NSString *) key;
#else
- (void) encodeImage:(NSImage *) objv forKey:(NSString *) key;
#endif
- (void) encodeRegularExpression:(BSONRegularExpression *) regex forKey:(NSString *) key;
- (void) encodeRegularExpressionPattern:(NSString *) pattern options:(NSString *) options forKey:(NSString *) key;
- (void) encodeCode:(BSONCode *) objv forKey:(NSString *) key;
- (void) encodeCodeString:(NSString *) objv forKey:(NSString *) key;
- (void) encodeCodeWithScope:(BSONCodeWithScope *) codeWithScope forKey:(NSString *) key;
- (void) encodeCodeString:(NSString *) code withScope:(BSONDocument *)scope forKey:(NSString *) key;
- (void) encodeData:(NSData *) objv forKey:(NSString *) key;
- (void) encodeTimestamp:(BSONTimestamp *) objv forKey:(NSString *) key;
- (NSArray *) keyPathComponents;
@property (retain) NSObject<BSONEncoderDelegate> * delegate;
@property (assign) BSONEncoderBehaviorOnNil behaviorOnNil;
@property (assign) BOOL restrictsKeyNamesForMongoDB;
@end
| 49.594488
| 140
| 0.762483
|
[
"object"
] |
b2485d960e4625fce4aac8d42cd7953414269a1a
| 6,120
|
h
|
C
|
html.h
|
fritzen/robot-esp8266-joystick
|
ba6a39a5940e0fbeaf50cf5de300a73cfe7c4ed9
|
[
"MIT"
] | null | null | null |
html.h
|
fritzen/robot-esp8266-joystick
|
ba6a39a5940e0fbeaf50cf5de300a73cfe7c4ed9
|
[
"MIT"
] | null | null | null |
html.h
|
fritzen/robot-esp8266-joystick
|
ba6a39a5940e0fbeaf50cf5de300a73cfe7c4ed9
|
[
"MIT"
] | null | null | null |
char html[] PROGMEM = R"=====(
<html lang="en">
<head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<script>
let Socket;
function start() {
//Socket = new WebSocket('ws://' + window.location.hostname + ':81/');
Socket = new WebSocket('ws://192.168.0.2:81/');
Socket.onmessage = function(evt) {
//document.getElementById("rxConsole").value += evt.data;
}
}
function enterpressed() {
Socket.send("fritzen");
}
</script>
<title>Robot</title>
<link rel="stylesheet" href="./styles.css" data-inprogress="">
<style>
body {
margin: 0;
padding: 0;
width: 100%;
height: 100%;
}
.zone {
display: none;
position: absolute;
width: 100%;
height: 100%;
left: 0;
}
.zone.active {
display: block;
}
.zone > h1 {
position: absolute;
padding: 10px 10px;
margin: 0;
color: white;
right: 0;
bottom: 0;
}
.zone.dynamic {
background: rgba(0, 0, 255, 0.1);
}
</style>
</head>
<body translate="no" onload="javascript:start();">
<div id="zone_joystick">
<div id="debug">
<ul>
<li class="position">
position :
<ul>
<li class="x">x : <span class="data">762</span></li>
<li class="y">y : <span class="data">545</span></li>
</ul>
</li>
<li class="force">force : <span class="data">3.825388869121674</span></li>
<li class="pressure">pressure : <span class="data">0.5</span></li>
<li class="distance">distance : <span class="data">50</span></li>
<li class="angle">
angle :
<ul>
<li class="radian">radian : <span class="data">6.167909181208635</span></li>
<li class="degree">degree : <span class="data">353.39516450324606</span></li>
</ul>
</li>
<li class="direction">
direction :
<ul>
<li class="x">x : <span class="data">right</span></li>
<li class="y">y : <span class="data">down</span></li>
<li class="angle">angle : <span class="data">right</span></li>
</ul>
</li>
</ul>
</div>
<div class="zone dynamic" style="touch-action: none;"><h1>fritzen.io</h1></div>
</div>
<script src="./nipplejs.js"></script>
<script id="rendered-js">
var s = function (sel) {
return document.querySelector(sel);
};
var sId = function (sel) {
return document.getElementById(sel);
};
var joysticks = {
dynamic: {
zone: s('.zone.dynamic'),
color: 'white',
multitouch: true }
};
var joystick;
// Get debug elements and map them
var elDebug = sId('debug');
var elDump = elDebug.querySelector('.dump');
var els = {
position: {
x: elDebug.querySelector('.position .x .data'),
y: elDebug.querySelector('.position .y .data') },
force: elDebug.querySelector('.force .data'),
pressure: elDebug.querySelector('.pressure .data'),
distance: elDebug.querySelector('.distance .data'),
angle: {
radian: elDebug.querySelector('.angle .radian .data'),
degree: elDebug.querySelector('.angle .degree .data') },
direction: {
x: elDebug.querySelector('.direction .x .data'),
y: elDebug.querySelector('.direction .y .data'),
angle: elDebug.querySelector('.direction .angle .data') } };
var timeoutCreate;
function createThrottle(evt) {
clearTimeout(timeoutCreate);
timeoutCreate = setTimeout(() => {
createNipple(evt);
}, 100);
}
createNipple('dynamic');
function bindNipple() {
joystick.on('start end', function (evt, data) {
dump(evt.type);
debug(data);
}).on('move', function (evt, data) {
debug(data);
}).on('dir:up plain:up dir:left plain:left dir:down ' +
'plain:down dir:right plain:right',
function (evt, data) {
dump(evt.type);
}).
on('pressure', function (evt, data) {
debug({
pressure: data });
});
}
function createNipple(evt) {
var type = typeof evt === 'string' ?
evt : evt.target.getAttribute('data-type');
if (joystick) {
joystick.destroy();
}
s('.zone.' + type).className += ' active';
joystick = nipplejs.create(joysticks[type]);
bindNipple();
}
function testInterval(refValue, degreeValue) {
const step = 22.5;
let max = refValue + step;
let min = refValue - step;
return (degreeValue >= min && degreeValue <= max);
}
// Print data into elements
function debug(obj) {
if (obj.angle) {
//console.log(obj.angle.degree);
//console.log(obj.distance);
if (obj.distance > 0) {
let degree = obj.angle.degree;
const right_up = 45;
const up = 90;
const left_up = 135;
const left = 180;
const left_down = 225;
const down = 270;
const right_down = 315;
const right = 0;
let choice = "";
if (testInterval(right_up, degree)){
choice = "right_up";
} else if (testInterval(up, degree)) {
choice = "up";
} else if (testInterval(left_up, degree)) {
choice = "left_up";
} else if (testInterval(left, degree)) {
choice = "left";
} else if (testInterval(left_down, degree)) {
choice = "left_down";
} else if (testInterval(down, degree)) {
choice = "down";
} else if (testInterval(right_down, degree)) {
choice = "right_down";
} else {
choice = "right";
}
console.log(choice);
Socket.send(choice);
}
}
function parseObj(sub, el) {
for (var i in sub) {
if (typeof sub[i] === 'object' && el) {
parseObj(sub[i], el[i]);
} else if (el && el[i]) {
el[i].innerHTML = sub[i];
}
}
}
setTimeout(function () {
parseObj(obj, els);
}, 0);
}
var nbEvents = 0;
// Dump data
function dump(evt) {
setTimeout(function () {
if (evt == "end") {
console.log(JSON.stringify(evt));
Socket.send(evt);
}
var newEvent = document.createElement('div');
newEvent.innerHTML = '#' + nbEvents + ' : <span class="data">' +
evt + '</span>';
nbEvents += 1;
}, 0);
}
</script>
</body></html>
)=====";
| 21.935484
| 81
| 0.566176
|
[
"object"
] |
b25a7c1088f9cf9f45c12dc49b312941fba7cff2
| 37,921
|
h
|
C
|
server/wkt.h
|
Amine-El-Ghaoual/griddb
|
fa1d5698711b0243efa4f216c22210e2bb77f081
|
[
"Apache-2.0"
] | 646
|
2016-02-24T13:44:26.000Z
|
2022-03-30T19:24:55.000Z
|
server/wkt.h
|
ouellani/griddb_nosql
|
2ccb037d7ea2d79d3b9ee5830cdcb209f8d6d612
|
[
"Apache-2.0"
] | 57
|
2020-06-20T01:17:56.000Z
|
2022-03-12T02:22:48.000Z
|
server/wkt.h
|
ouellani/griddb_nosql
|
2ccb037d7ea2d79d3b9ee5830cdcb209f8d6d612
|
[
"Apache-2.0"
] | 1,697
|
2020-06-17T08:43:28.000Z
|
2022-03-31T21:25:58.000Z
|
/*
Copyright (c) 2017 TOSHIBA Digital Solutions Corporation
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file
* @brief C++ Driver template for the LEMON parser generator.
* Just ported into C++ style.
*
*/
#ifndef LEMPAR_CPP_wktParser_GENERATED_HPP
#define LEMPAR_CPP_wktParser_GENERATED_HPP
#ifdef _WIN32
#pragma warning(disable : 4065)
#endif
/* First off, code is included that follows the "include" declaration
** in the input grammar file. */
#include "wkt_token.h"
#include "util/container.h"
#include "gs_error.h"
#include "qp_def.h"
#include <cassert>
#include <iostream>
#include <stdexcept>
#include "expression.h"
#include "gis_multipolygon.h"
#include "gis_pointgeom.h"
#include "gis_polygon.h"
#include "gis_polyhedralsurface.h"
#include "gis_quadraticsurface.h"
#ifdef _WIN32
#define atoll atol
#endif
/*
** Disable all error recovery processing in the parser push-down
** automaton.
*/
#define YYNOERRORRECOVERY 1
#define PRINT(...)
namespace lemon_wktParser {
struct wktParserArg {
Expr **ev;
TransactionContext *txn;
ObjectManager *objectManager;
FunctionMap *fmap;
int err;
};
};
#define WKTPARSER_NEW QP_ALLOC_NEW(arg->txn->getDefaultAllocator())
#define WKTPARSER_DELETE(x) QP_ALLOC_DELETE(arg->txn->getDefaultAllocator(), x)
#include <iostream>
/* Next is all token values, in a form suitable for use by makeheaders.
** This section will be null unless lemon is run with the -m switch.
*/
/*
** These constants (all generated automatically by the parser generator)
** specify the various kinds of tokens (terminals) that the parser
** understands.
**
** Each symbol here is a terminal symbol in the grammar.
*/
/* Make sure the INTERFACE macro is defined.
*/
#ifndef INTERFACE
#define INTERFACE 1
#endif
/* The next thing included is series of defines which control
** various aspects of the generated parser.
** wktParser_YYCODETYPE is the data type used for storing terminal
** and nonterminal numbers. "unsigned char" is
** used if there are fewer than 250 terminals
** and nonterminals. "int" is used otherwise.
** wktParser_YYNOCODE is a number of type wktParser_YYCODETYPE
*which corresponds
** to no legal terminal or nonterminal number. This
** number is used to fill in empty slots of the hash
** table.
** wktParser_YYFALLBACK If defined, this indicates that one or more
*tokens
** have fall-back values which should be used if the
** original value of the token will not parse.
** wktParser_YYACTIONTYPE is the data type used for storing terminal
** and nonterminal numbers. "unsigned char" is
** used if there are fewer than 250 rules and
** states combined. "int" is used otherwise.
** wktParserTOKENTYPE is the data type used for minor tokens given
** directly to the parser from the tokenizer.
** wktParser_YYMINORTYPE is the data type used for all minor tokens.
** This is typically a union of many types, one of
** which is wktParserTOKENTYPE. The entry in the union
** for base tokens is called "yy0".
** wktParser_YYSTACKDEPTH is the maximum depth of the parser's stack.
*If
** zero the stack is dynamically sized using realloc()
** wktParserARG_SDECL A static variable declaration for the
*%extra_argument
** wktParserARG_PDECL A parameter declaration for the %extra_argument
** wktParser_YYNSTATE the combined number of states.
** wktParser_YYNRULE the number of rules in the grammar
** wktParser_YYERRORSYMBOL is the code number of the error symbol. If
*not
** defined, then do no error processing.
*/
#define wktParser_YYCODETYPE unsigned char
#define wktParser_YYNOCODE 35
#define wktParser_YYACTIONTYPE unsigned char
#define wktParser_YYWILDCARD 1
#define wktParserTOKENTYPE Token
typedef union {
int yyinit;
wktParserTOKENTYPE yy0;
QuadraticSurface *yy2;
double yy8;
MultiPolygon *yy22;
MultiPoint *yy28;
QP_XArray<Expr *> *yy29;
QP_XArray<Point *> *yy30;
Polygon *yy35;
Expr *yy46;
QP_XArray<Polygon *> *yy47;
QP_XArray<MultiPoint *> *yy59;
Point *yy61;
} wktParser_YYMINORTYPE;
#ifndef wktParser_YYSTACKDEPTH
#define wktParser_YYSTACKDEPTH 2000
#endif
#define wktParserARG_SDECL lemon_wktParser::wktParserArg *arg
#define wktParserARG_PDECL , lemon_wktParser::wktParserArg *arg
#define wktParserARG_STORE this->arg = arg
#define wktParser_YYNSTATE 80
#define wktParser_YYNRULE 38
#define wktParser_YY_NO_ACTION (wktParser_YYNSTATE + wktParser_YYNRULE + 2)
#define wktParser_YY_ACCEPT_ACTION (wktParser_YYNSTATE + wktParser_YYNRULE + 1)
#define wktParser_YY_ERROR_ACTION (wktParser_YYNSTATE + wktParser_YYNRULE)
/* The yyzerominor constant is used to initialize instances of
** wktParser_YYMINORTYPE objects to zero. */
static const wktParser_YYMINORTYPE wktParser_yyzerominor = {0};
/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
**
** Applications can choose to define yytestcase() in the %include section
** to a macro that can assist in verifying code coverage. For production
** code the yytestcase() macro should be turned off. But it is useful
** for testing.
*/
#ifndef yytestcase
#define yytestcase(X)
#endif
/*!
* @brief wktParser
*
*/
namespace lemon_wktParser {
/*!
* @brief wktParser parser main
*
*/
class wktParser {
/* Next are the tables used to determine what action to take based on the
** current state and lookahead token. These tables are used to implement
** functions that take a state number and lookahead value and return an
** action integer.
**
** Suppose the action integer is N. Then the action is determined as
** follows
**
** 0 <= N < wktParser_YYNSTATE Shift N. That is, push the
*lookahead
** token onto the stack and goto state N.
**
** wktParser_YYNSTATE <= N < wktParser_YYNSTATE+wktParser_YYNRULE Reduce by
*rule N-wktParser_YYNSTATE.
**
** N == wktParser_YYNSTATE+wktParser_YYNRULE A syntax error has
*occurred.
**
** N == wktParser_YYNSTATE+wktParser_YYNRULE+1 The parser accepts
*its input.
**
** N == wktParser_YYNSTATE+wktParser_YYNRULE+2 No such action.
*Denotes unused
** slots in the yy_action[] table.
**
** The action table is constructed as a single large table named yy_action[].
** Given state S and lookahead X, the action is computed as
**
** yy_action[ yy_shift_ofst[S] + X ]
**
** If the index value yy_shift_ofst[S]+X is out of range or if the value
** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
** is equal to wktParser_YY_SHIFT_USE_DFLT, it means that the action is not in
*the table
** and that yy_default[S] should be used instead.
**
** The formula above is for computing the action when the lookahead is
** a terminal symbol. If the lookahead is a non-terminal (as occurs after
** a reduce action) then the yy_reduce_ofst[] array is used in place of
** the yy_shift_ofst[] array and wktParser_YY_REDUCE_USE_DFLT is used in place
*of
** wktParser_YY_SHIFT_USE_DFLT.
**
** The following are the tables generated in this section:
**
** yy_action[] A single table containing all actions.
** yy_lookahead[] A table containing the lookahead for each entry in
** yy_action. Used to detect hash collisions.
** yy_shift_ofst[] For each state, the offset into yy_action for
** shifting terminals.
** yy_reduce_ofst[] For each state, the offset into yy_action for
** shifting non-terminals after a reduce.
** yy_default[] Default action for each state.
*/
#define wktParser_YY_ACTTAB_COUNT (240)
#define wktParser_YY_SHIFT_USE_DFLT (-7)
#define wktParser_YY_SHIFT_COUNT (51)
#define wktParser_YY_SHIFT_MIN (-6)
#define wktParser_YY_SHIFT_MAX (126)
#define wktParser_YY_REDUCE_USE_DFLT (-14)
#define wktParser_YY_REDUCE_COUNT (28)
#define wktParser_YY_REDUCE_MIN (-13)
#define wktParser_YY_REDUCE_MAX (206)
#define wktParser_YYNFALLBACK (1)
static const wktParser_YYACTIONTYPE yy_action[wktParser_YY_ACTTAB_COUNT];
static const wktParser_YYCODETYPE yy_lookahead[wktParser_YY_ACTTAB_COUNT];
static const short yy_shift_ofst[wktParser_YY_SHIFT_COUNT + 1];
static const short yy_reduce_ofst[wktParser_YY_REDUCE_COUNT + 1];
static const wktParser_YYACTIONTYPE yy_default[];
/* The next table maps tokens into fallback tokens. If a construct
** like the following:
**
** %fallback ID X Y Z.
**
** appears in the grammar, then ID becomes a fallback token for X, Y,
** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
** but it does not parse, the type of the token is changed to ID and
** the parse is retried before an error is thrown.
*/
#ifdef wktParser_YYFALLBACK
static const wktParser_YYCODETYPE yyFallback[wktParser_YYNFALLBACK];
#endif /* wktParser_YYFALLBACK */
/* The following structure represents a single element of the
** parser's stack. Information stored includes:
**
** + The state number for the parser at this level of the stack.
**
** + The value of the token stored at this level of the stack.
** (In other words, the "major" token.)
**
** + The semantic value stored at this level of the stack. This is
** the information used by the action routines in the grammar.
** It is sometimes called the "minor" token.
*/
/*!
* @brief parser's stack
*/
struct yyStackEntry {
wktParser_YYACTIONTYPE stateno; /* The state-number */
wktParser_YYCODETYPE major; /* The major token value. This is the code
** number for the token at this stack level */
wktParser_YYMINORTYPE
minor; /* The user-supplied minor token value. This
** is the value of the token */
};
typedef struct yyStackEntry yyStackEntry;
/* The state of the parser is completely contained in an instance of
** the following structure */
int yyidx; /* Index of top element in stack */
#ifdef wktParser_YYTRACKMAXSTACKDEPTH
int yyidxMax; /* Maximum value of yyidx */
#endif
int yyerrcnt; /* Shifts left before out of the error */
wktParserARG_SDECL; /* A place to hold %extra_argument */
#if wktParser_YYSTACKDEPTH <= 0
int yystksz; /* Current side of the stack */
yyStackEntry *yystack; /* The parser's stack */
#else
yyStackEntry yystack[wktParser_YYSTACKDEPTH]; /* The parser's stack */
#endif
#ifndef NDEBUG
std::ostream *yyTraceFILE;
const char *yyTracePrompt;
#endif /* NDEBUG */
#ifndef NDEBUG
/*
** Turn parser tracing on by giving a stream to which to write the trace
** and a prompt to preface each trace message. Tracing is turned off
** by making either argument NULL
**
** Inputs:
** <ul>
** <li> A FILE* to which trace output should be written.
** If NULL, then tracing is turned off.
** <li> A prefix string written at the beginning of every
** line of trace output. If NULL, then tracing is
** turned off.
** </ul>
**
** Outputs:
** None.
*/
public:
void wktParserSetTrace(std::ostream *TraceFILE, const char *zTracePrompt) {
yyTraceFILE = TraceFILE;
yyTracePrompt = zTracePrompt;
if (yyTraceFILE == 0) yyTraceFILE = 0;
}
#endif /* NDEBUG */
#ifndef NDEBUG
protected:
static const char *const yyTokenName[];
static const char *const yyRuleName[wktParser_YYNRULE];
#endif
#if wktParser_YYSTACKDEPTH <= 0
/*
** Try to increase the size of the parser stack.
*/
void yyGrowStack() {
int newSize;
yyStackEntry *pNew;
newSize = yystksz * 2 + 100;
pNew = new yyStackEntry[newSize];
if (pNew) {
memcpy(pNew, yystack, newSize * sizeof(pNew[0]));
delete yystack;
yystack = pNew;
yystksz = newSize;
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "Stack grows to " << yystksz
<< " entries!" << std::endl;
}
#endif
}
}
#endif
/*
** This function allocates a new parser.
** The only argument is a pointer to a function which works like
** malloc.
**
** Inputs:
** A pointer to the function used to allocate memory.
**
** Outputs:
** A pointer to a parser. This pointer is used in subsequent calls
** to wktParser and wktParserFree.
*/
public:
wktParser() {
yyidx = -1;
#ifdef wktParser_YYTRACKMAXSTACKDEPTH
yidxMax = 0;
#endif
#if wktParser_YYSTACKDEPTH <= 0
yystack = NULL;
yystksz = 0;
yyGrowStack();
#else
#endif
#ifndef NDEBUG
yyTraceFILE = NULL;
#endif
yyerrcnt = -1;
}
/* The following function deletes the value associated with a
** symbol. The symbol can be either a terminal or nonterminal.
** "yymajor" is the symbol code, and "yypminor" is a pointer to
** the value.
*/
void yy_destructor(
wktParser_YYCODETYPE yymajor, /* Type code for object to destroy */
wktParser_YYMINORTYPE *yypminor /* The object to be destroyed */
) {
switch (yymajor) {
/* Here is inserted the actions which take place when a
** terminal or non-terminal is destroyed. This can happen
** when the symbol is popped from the stack during a
** reduce or during error processing or when a parser is
** being destroyed before it is finished parsing.
**
** Note: during a reduce, the only symbols destroyed are those
** which appear on the RHS of the rule, but which are not used
** inside the C code.
*/
default:
break; /* If no destructor action specified: do nothing */
}
}
/*
** Pop the parser's stack once.
**
** If there is a destructor routine associated with the token which
** is popped from the stack, then call it.
**
** Return the major token number for the symbol popped.
*/
int yy_pop_parser_stack() {
wktParser_YYCODETYPE yymajor;
yyStackEntry *yytos;
if (yyidx < 0) return 0;
yytos = &yystack[yyidx];
#ifndef NDEBUG
if (yyTraceFILE && yyidx >= 0) {
*yyTraceFILE << yyTracePrompt << "Popping "
<< yyTokenName[yytos->major] << std::endl;
}
#endif
yymajor = yytos->major;
yy_destructor(yymajor, &yytos->minor);
yyidx--;
return yymajor;
}
/*
** Deallocate and destroy a parser. Destructors are all called for
** all stack elements before shutting the parser down.
**
** Inputs:
** <ul>
** <li> A pointer to the parser. This should be a pointer
** obtained from wktParserAlloc.
** <li> A pointer to a function used to reclaim memory obtained
** from malloc.
** </ul>
*/
public:
~wktParser() {
while (yyidx >= 0) yy_pop_parser_stack();
#if wktParser_YYSTACKDEPTH <= 0
delete yystack;
yystack = NULL;
#endif
}
/*
** Return the peak depth of the stack for a parser.
*/
#ifdef wktParser_YYTRACKMAXSTACKDEPTH
public:
int wktParserStackPeak(void *p) {
return yyidxMax;
}
#endif
/*
** Find the appropriate action for a parser given the terminal
** look-ahead token iLookAhead.
**
** If the look-ahead token is wktParser_YYNOCODE, then check to see if the
*action is
** independent of the look-ahead. If it is, return the action, otherwise
** return wktParser_YY_NO_ACTION.
*/
int yy_find_shift_action(
wktParser_YYCODETYPE iLookAhead /* The look-ahead token */
) {
int i;
int stateno = this->yystack[this->yyidx].stateno;
if (stateno > wktParser_YY_SHIFT_COUNT ||
(i = yy_shift_ofst[stateno]) == wktParser_YY_SHIFT_USE_DFLT) {
return yy_default[stateno];
}
assert(iLookAhead != wktParser_YYNOCODE);
i += iLookAhead;
if (i < 0 || i >= wktParser_YY_ACTTAB_COUNT ||
yy_lookahead[i] != iLookAhead) {
if (iLookAhead > 0) {
#ifdef wktParser_YYFALLBACK
wktParser_YYCODETYPE iFallback; /* Fallback token */
if (iLookAhead < wktParser_YYNFALLBACK &&
(iFallback = yyFallback[iLookAhead]) != 0) {
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "FALLBACK "
<< yyTokenName[iLookAhead] << " => "
<< yyTokenName[iFallback] << std::endl;
}
#endif
return yy_find_shift_action(iFallback);
}
#endif
#ifdef wktParser_YYWILDCARD
{
int j = i - iLookAhead + wktParser_YYWILDCARD;
if (
#if wktParser_YY_SHIFT_MIN + wktParser_YYWILDCARD < 0
j >= 0 &&
#endif
#if wktParser_YY_SHIFT_MAX + wktParser_YYWILDCARD >= wktParser_YY_ACTTAB_COUNT
j < wktParser_YY_ACTTAB_COUNT &&
#endif
yy_lookahead[j] == wktParser_YYWILDCARD) {
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "WILDCARD "
<< yyTokenName[iLookAhead] << " => "
<< yyTokenName[wktParser_YYWILDCARD]
<< std::endl;
}
#endif /* NDEBUG */
return yy_action[j];
}
}
#endif /* wktParser_YYWILDCARD */
}
return yy_default[stateno];
}
else {
return yy_action[i];
}
}
/*
** Find the appropriate action for a parser given the non-terminal
** look-ahead token iLookAhead.
**
** If the look-ahead token is wktParser_YYNOCODE, then check to see if the
*action is
** independent of the look-ahead. If it is, return the action, otherwise
** return wktParser_YY_NO_ACTION.
*/
int yy_find_reduce_action(int stateno, /* Current state number */
wktParser_YYCODETYPE iLookAhead /* The look-ahead token */
) {
int i;
#ifdef wktParser_YYERRORSYMBOL
if (stateno > wktParser_YY_REDUCE_COUNT) {
return yy_default[stateno];
}
#else
assert(stateno <= wktParser_YY_REDUCE_COUNT);
#endif
i = yy_reduce_ofst[stateno];
assert(i != wktParser_YY_REDUCE_USE_DFLT);
assert(iLookAhead != wktParser_YYNOCODE);
i += iLookAhead;
#ifdef wktParser_YYERRORSYMBOL
if (i < 0 || i >= wktParser_YY_ACTTAB_COUNT ||
yy_lookahead[i] != iLookAhead) {
return yy_default[stateno];
}
#else
assert(i >= 0 && i < wktParser_YY_ACTTAB_COUNT);
assert(yy_lookahead[i] == iLookAhead);
#endif
return yy_action[i];
}
/*
** The following routine is called if the stack overflows.
*/
void yyStackOverflow(wktParser_YYMINORTYPE *yypMinor) {
yyidx--;
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "Stack Overflow!" << std::endl;
}
#endif
while (yyidx >= 0) yy_pop_parser_stack();
/* Here code is inserted which will execute if the parser
** stack every overflows */
}
/*
** Perform a shift action.
*/
void yy_shift(int yyNewState, /* The new state to shift in */
int yyMajor, /* The major token to shift in */
wktParser_YYMINORTYPE
*yypMinor /* Pointer to the minor token to shift in */
) {
yyStackEntry *yytos;
yyidx++;
#ifdef wktParser_YYTRACKMAXSTACKDEPTH
if (yyidx > yyidxMax) {
yyidxMax = yyidx;
}
#endif
#if wktParser_YYSTACKDEPTH > 0
if (yyidx >= wktParser_YYSTACKDEPTH) {
yyStackOverflow(yypMinor);
return;
}
#else
if (yyidx >= yystksz) {
yyGrowStack();
if (yyidx >= yystksz) {
yyStackOverflow(yypMinor);
return;
}
}
#endif
yytos = &yystack[yyidx];
yytos->stateno = (wktParser_YYACTIONTYPE)yyNewState;
yytos->major = (wktParser_YYCODETYPE)yyMajor;
yytos->minor = *yypMinor;
#ifndef NDEBUG
if (yyTraceFILE && yyidx > 0) {
int i;
*yyTraceFILE << yyTracePrompt << "Shift " << yyNewState
<< std::endl;
*yyTraceFILE << yyTracePrompt << "Stack:";
for (i = 1; i <= yyidx; i++) {
*yyTraceFILE << " " << yyTokenName[yystack[i].major];
}
*yyTraceFILE << std::endl;
}
#endif
}
/* The following table contains information about every rule that
** is used during the reduce.
*/
/*!
@brief Contains information about every rule
that is used during the reduce
*/
static const struct RULEINFO {
wktParser_YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
unsigned char nrhs; /* Number of right-hand side symbols in the rule */
} yyRuleInfo[];
/*
** Perform a reduce action and the shift that must immediately
** follow the reduce.
*/
private:
void yy_reduce(int yyruleno /* Number of the rule by which to reduce */
) {
int yygoto; /* The next state */
int yyact; /* The next action */
wktParser_YYMINORTYPE yygotominor; /* The LHS of the rule reduced */
yyStackEntry *yymsp; /* The top of the parser's stack */
int yysize; /* Amount to pop the stack */
yymsp = &yystack[yyidx];
#ifndef NDEBUG
if (yyTraceFILE && yyruleno >= 0 && yyruleno < wktParser_YYNRULE) {
*yyTraceFILE << yyTracePrompt << "Reduce [" << yyRuleName[yyruleno]
<< "]." << std::endl;
}
#endif /* NDEBUG */
/* Silence complaints from purify about yygotominor being uninitialized
** in some cases when it is copied into the stack after the following
** switch. yygotominor is uninitialized when a rule reduces that does
** not set the value of its left-hand side nonterminal. Leaving the
** value of the nonterminal uninitialized is utterly harmless as long
** as the value is never used. So really the only thing this code
** accomplishes is to quieten purify.
**
** 2007-01-16: The wireshark project (www.wireshark.org) reports that
** without this code, their parser segfaults. I'm not sure what there
** parser is doing to make this happen. This is the second bug report
** from wireshark this week. Clearly they are stressing Lemon in ways
** that it has not been previously stressed... (SQLite ticket #2172)
*/
/*memset(&yygotominor, 0, sizeof(yygotominor));*/
yygotominor = wktParser_yyzerominor;
switch (yyruleno) {
/* Beginning here are the reduction cases. A typical example
** follows:
** case 0:
** #line <lineno> <grammarfile>
** { ... }
** #line <lineno> <thisfile>
** break;
*/
case 0: /* geom ::= GISFUNC LP gisarg RP */
{
Expr *e = Expr::newFunctionNode(yymsp[-3].minor.yy0,
yymsp[-1].minor.yy29, *(arg->txn), *(arg->fmap));
*arg->ev = e->eval(*(arg->txn), *(arg->objectManager), NULL,
arg->fmap, EVAL_MODE_NORMAL);
WKTPARSER_DELETE(e);
if (yymsp[-1].minor.yy29) {
WKTPARSER_DELETE(yymsp[-1].minor.yy29);
}
} break;
case 1: /* geom ::= GISFUNC LP EMPTY RP */
{
Expr *emptyArg1 = Expr::newStringValue("EMPTY", *(arg->txn));
QP_XArray<Expr *> emptyArg(arg->txn->getDefaultAllocator());
emptyArg.push_back(emptyArg1);
Expr *e = Expr::newFunctionNode(
yymsp[-3].minor.yy0, &emptyArg, *(arg->txn), *(arg->fmap));
*arg->ev = e->eval(*(arg->txn), *(arg->objectManager), NULL,
arg->fmap, EVAL_MODE_NORMAL);
WKTPARSER_DELETE(e);
WKTPARSER_DELETE(emptyArg1);
} break;
case 2: /* gisarg ::= gisexpr */
{
yygotominor.yy29 =
WKTPARSER_NEW ExprList(arg->txn->getDefaultAllocator());
yygotominor.yy29->push_back(yymsp[0].minor.yy46);
yygotominor.yy29->push_back(
Expr::newNumericValue(static_cast<int64_t>(-1), *(arg->txn)));
} break;
case 3: /* gisarg ::= gisexpr SEMICOLON INTEGER */
{
yygotominor.yy29 =
WKTPARSER_NEW ExprList(arg->txn->getDefaultAllocator());
yygotominor.yy29->push_back(yymsp[-2].minor.yy46);
char **endptr = NULL;
int64_t val = std::strtol(yymsp[0].minor.yy0.z, endptr, 0);
yygotominor.yy29->push_back(Expr::newNumericValue(val,
*(arg->txn)));
} break;
case 4: /* gisarg ::= gisexpr SEMICOLON MINUS INTEGER */
{
yygotominor.yy29 =
WKTPARSER_NEW ExprList(arg->txn->getDefaultAllocator());
yygotominor.yy29->push_back(yymsp[-3].minor.yy46);
char **endptr = NULL;
int64_t val = std::strtol(yymsp[0].minor.yy0.z, endptr, 0);
yygotominor.yy29->push_back(Expr::newNumericValue(-val,
*(arg->txn)));
} break;
case 5: /* gisarg ::= */
{
yygotominor.yy29 = NULL;
} break;
case 6: /* gisexpr ::= gismultipoint2d */
{
yygotominor.yy46 =
Expr::newGeometryValue(yymsp[0].minor.yy28, *(arg->txn));
} break;
case 7: /* gisexpr ::= gismultipoint3d */
{
yygotominor.yy46 =
Expr::newGeometryValue(yymsp[0].minor.yy28, *(arg->txn));
} break;
case 8: /* gisexpr ::= gispolygon2d */
case 9: /* gisexpr ::= gispolygon3d */
yytestcase(yyruleno == 9);
{
yygotominor.yy46 =
Expr::newGeometryValue(yymsp[0].minor.yy35, *(arg->txn));
}
break;
case 10: /* gisexpr ::= gismultipolygon3d */
{
yygotominor.yy46 =
Expr::newGeometryValue(yymsp[0].minor.yy22, *(arg->txn));
} break;
case 11: /* gisexpr ::= gisqsf */
{
yygotominor.yy46 =
Expr::newGeometryValue(yymsp[0].minor.yy2, *(arg->txn));
} break;
case 12: /* gispolygon2d ::= LP gisnpointlist2d RP */
{
yygotominor.yy35 = WKTPARSER_NEW Polygon(static_cast<int64_t>(-1),
yymsp[-1].minor.yy59, *(arg->txn), *(arg->objectManager));
while (!yymsp[-1].minor.yy59->empty()) {
WKTPARSER_DELETE(yymsp[-1].minor.yy59->back());
yymsp[-1].minor.yy59->pop_back();
}
WKTPARSER_DELETE(yymsp[-1].minor.yy59);
} break;
case 13: /* gispolygon2d ::= gisnpointlist2d */
{
yygotominor.yy35 = WKTPARSER_NEW Polygon(
-1, yymsp[0].minor.yy59, *(arg->txn), *(arg->objectManager));
while (!yymsp[0].minor.yy59->empty()) {
WKTPARSER_DELETE(yymsp[0].minor.yy59->back());
yymsp[0].minor.yy59->pop_back();
}
WKTPARSER_DELETE(yymsp[0].minor.yy59);
} break;
case 14: /* gisnpointlist2d ::= gisnpointlist2d COMMA LP gismultipoint2d
RP */
case 24: /* gisnpointlist3d ::= gisnpointlist3d COMMA LP gismultipoint3d
RP */
yytestcase(yyruleno == 24);
{
yygotominor.yy59 = yymsp[-4].minor.yy59;
yymsp[-4].minor.yy59->push_back(yymsp[-1].minor.yy28);
}
break;
case 15: /* gisnpointlist2d ::= LP gismultipoint2d RP */
case 25: /* gisnpointlist3d ::= LP gismultipoint3d RP */
yytestcase(yyruleno == 25);
{
yygotominor.yy59 = WKTPARSER_NEW QP_XArray<MultiPoint *>(
arg->txn->getDefaultAllocator());
yygotominor.yy59->push_back(yymsp[-1].minor.yy28);
}
break;
case 16: /* gismultipoint2d ::= gispointlist2d */
{
yygotominor.yy28 = WKTPARSER_NEW MultiPoint(
-1, *yymsp[0].minor.yy30, *(arg->txn), *(arg->objectManager));
while (!yymsp[0].minor.yy30->empty()) {
WKTPARSER_DELETE(yymsp[0].minor.yy30->back());
yymsp[0].minor.yy30->pop_back();
}
WKTPARSER_DELETE(yymsp[0].minor.yy30);
} break;
case 17: /* gispointlist2d ::= gispointlist2d COMMA gispoint2d */
case 27: /* gispointlist3d ::= gispointlist3d COMMA gispoint3d */
yytestcase(yyruleno == 27);
{
if (yymsp[-2].minor.yy30 == NULL) {
yygotominor.yy30 = WKTPARSER_NEW QP_XArray<Point *>(
arg->txn->getDefaultAllocator());
}
else {
yygotominor.yy30 = yymsp[-2].minor.yy30;
}
yygotominor.yy30->push_back(yymsp[0].minor.yy61);
}
break;
case 18: /* gispointlist2d ::= gispoint2d */
case 28: /* gispointlist3d ::= gispoint3d */
yytestcase(yyruleno == 28);
{
yygotominor.yy30 = WKTPARSER_NEW QP_XArray<Point *>(
arg->txn->getDefaultAllocator());
yygotominor.yy30->push_back(yymsp[0].minor.yy61);
}
break;
case 19: /* gispoint2d ::= signed signed */
{
yygotominor.yy61 =
WKTPARSER_NEW Point(-1, yymsp[-1].minor.yy8, yymsp[0].minor.yy8,
std::numeric_limits<double>::quiet_NaN(), *(arg->txn));
} break;
case 20: /* gismultipolygon3d ::= gisnpolygonlist3d */
{
yygotominor.yy22 =
WKTPARSER_NEW MultiPolygon(static_cast<int64_t>(-1),
*yymsp[0].minor.yy47, *(arg->txn), *(arg->objectManager));
while (!yymsp[0].minor.yy47->empty()) {
WKTPARSER_DELETE(yymsp[0].minor.yy47->back());
yymsp[0].minor.yy47->pop_back();
}
WKTPARSER_DELETE(yymsp[0].minor.yy47);
} break;
case 21: /* gisnpolygonlist3d ::= gisnpolygonlist3d COMMA LP
gispolygon3d RP */
{
yygotominor.yy47 = yymsp[-4].minor.yy47;
yygotominor.yy47->push_back(yymsp[-1].minor.yy35);
} break;
case 22: /* gisnpolygonlist3d ::= LP gispolygon3d RP */
{
yygotominor.yy47 = WKTPARSER_NEW QP_XArray<Polygon *>(
arg->txn->getDefaultAllocator());
yygotominor.yy47->push_back(yymsp[-1].minor.yy35);
} break;
case 23: /* gispolygon3d ::= gisnpointlist3d */
{
yygotominor.yy35 = WKTPARSER_NEW Polygon(
-1, yymsp[0].minor.yy59, *(arg->txn), *(arg->objectManager));
while (!yymsp[0].minor.yy59->empty()) {
WKTPARSER_DELETE(yymsp[0].minor.yy59->back());
yymsp[0].minor.yy59->pop_back();
}
WKTPARSER_DELETE(yymsp[0].minor.yy59);
} break;
case 26: /* gismultipoint3d ::= gispointlist3d */
{
yygotominor.yy28 = WKTPARSER_NEW MultiPoint(
-1, *yymsp[0].minor.yy30, *(arg->txn), *(arg->objectManager));
while (!yymsp[0].minor.yy30->empty()) {
WKTPARSER_DELETE(yymsp[0].minor.yy30->back());
yymsp[0].minor.yy30->pop_back();
}
WKTPARSER_DELETE(yymsp[0].minor.yy30);
} break;
case 29: /* gispoint3d ::= signed signed signed */
{
yygotominor.yy61 = WKTPARSER_NEW Point(-1, yymsp[-2].minor.yy8,
yymsp[-1].minor.yy8, yymsp[0].minor.yy8, *(arg->txn));
} break;
case 30: /* gisqsf ::= signed signed signed signed signed signed signed
signed signed signed signed signed signed */
{
yygotominor.yy2 = WKTPARSER_NEW QuadraticSurface(*(arg->txn),
TR_PV3KEY_NONE, 13, yymsp[-12].minor.yy8, yymsp[-11].minor.yy8,
yymsp[-10].minor.yy8, yymsp[-9].minor.yy8, yymsp[-8].minor.yy8,
yymsp[-7].minor.yy8, yymsp[-6].minor.yy8, yymsp[-5].minor.yy8,
yymsp[-4].minor.yy8, yymsp[-3].minor.yy8, yymsp[-2].minor.yy8,
yymsp[-1].minor.yy8, yymsp[0].minor.yy8);
} break;
case 31: /* signed ::= plus_num */
case 32: /* signed ::= minus_num */
yytestcase(yyruleno == 32);
{ yygotominor.yy8 = yymsp[0].minor.yy8; }
break;
case 33: /* plus_num ::= plus_opt number */
{
yygotominor.yy8 = yymsp[0].minor.yy8;
} break;
case 34: /* minus_num ::= MINUS number */
{
yygotominor.yy8 = -yymsp[0].minor.yy8;
} break;
case 35: /* number ::= INTEGER|FLOAT */
{
yygotominor.yy8 = atof(yymsp[0].minor.yy0.z);
} break;
case 36: /* plus_opt ::= PLUS */
{
PRINT("PLUS_OPT1");
} break;
case 37: /* plus_opt ::= */
{
PRINT("PLUS_OPT2");
} break;
default:
break;
};
yygoto = yyRuleInfo[yyruleno].lhs;
yysize = yyRuleInfo[yyruleno].nrhs;
yyidx -= yysize;
yyact = yy_find_reduce_action(
yymsp[-yysize].stateno, (wktParser_YYCODETYPE)yygoto);
if (yyact < wktParser_YYNSTATE) {
#ifdef NDEBUG
/* If we are not debugging and the reduce action popped at least
** one element off the stack, then we can push the new element back
** onto the stack here, and skip the stack overflow test in
*yy_shift().
** That gives a significant speed improvement. */
if (yysize) {
yyidx++;
yymsp -= yysize - 1;
yymsp->stateno = (wktParser_YYACTIONTYPE)yyact;
yymsp->major = (wktParser_YYCODETYPE)yygoto;
yymsp->minor = yygotominor;
}
else
#endif
{
yy_shift(yyact, yygoto, &yygotominor);
}
}
else {
assert(yyact == wktParser_YYNSTATE + wktParser_YYNRULE + 1);
yy_accept();
}
}
/*
** The following code executes when the parse fails
*/
#ifndef wktParser_YYNOERRORRECOVERY
void yy_parse_failed() {
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "Fail!" << std::endl;
}
#endif
while (yyidx >= 0) yy_pop_parser_stack();
/* Here code is inserted which will be executed whenever the
** parser fails */
}
#endif /* wktParser_YYNOERRORRECOVERY */
/*
** The following code executes when a syntax error first occurs.
*/
void yy_syntax_error(int yymajor, /* The major type of the error token */
wktParser_YYMINORTYPE yyminor /* The minor type of the error token */
) {
#define TOKEN (yyminor.yy0)
arg->err = 1;
}
/*
** The following is executed when the parser accepts
*/
void yy_accept() {
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "Accept!" << std::endl;
}
#endif
while (yyidx >= 0) yy_pop_parser_stack();
/* Here code is inserted which will be executed whenever the
** parser accepts */
}
/* The main parser program.
** The first argument is a pointer to a structure obtained from
** "wktParserAlloc" which describes the current state of the parser.
** The second argument is the major token number. The third is
** the minor token. The fourth optional argument is whatever the
** user wants (and specified in the grammar) and is available for
** use by the action routines.
**
** Inputs:
** <ul>
** <li> A pointer to the parser (an opaque structure.)
** <li> The major token number.
** <li> The minor token number.
** <li> An option argument of a grammar-specified type.
** </ul>
**
** Outputs:
** None.
*/
public:
void Execute(int yymajor, /* The major token code number */
wktParserTOKENTYPE &yyminor /* The value for the token */
wktParserARG_PDECL /* Optional %extra_argument parameter */
) {
wktParser_YYMINORTYPE yyminorunion;
int yyact; /* The parser action. */
int yyendofinput; /* True if we are at the end of input */
#ifdef wktParser_YYERRORSYMBOL
int yyerrorhit = 0; /* True if yymajor has invoked an error */
#endif
/* (re)initialize the parser, if necessary */
if (yyidx < 0) {
#if wktParser_YYSTACKDEPTH <= 0
if (yystksz <= 0) {
/*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
yyminorunion = wktParser_yyzerominor;
yyStackOverflow(&yyminorunion);
return;
}
#endif
yyidx = 0;
yyerrcnt = -1;
yystack[0].stateno = 0;
yystack[0].major = 0;
}
yyminorunion.yy0 = yyminor;
yyendofinput = (yymajor == 0);
wktParserARG_STORE;
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "Input " << yyTokenName[yymajor]
<< std::endl;
}
#endif
do {
yyact = yy_find_shift_action((wktParser_YYCODETYPE)yymajor);
if (yyact < wktParser_YYNSTATE) {
assert(!yyendofinput); /* Impossible to shift the $ token */
yy_shift(yyact, yymajor, &yyminorunion);
yyerrcnt--;
yymajor = wktParser_YYNOCODE;
}
else if (yyact < wktParser_YYNSTATE + wktParser_YYNRULE) {
yy_reduce(yyact - wktParser_YYNSTATE);
}
else {
assert(yyact == wktParser_YY_ERROR_ACTION);
#ifdef wktParser_YYERRORSYMBOL
int yymx;
#endif
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "Syntax Error!"
<< std::endl;
}
#endif
#ifdef wktParser_YYERRORSYMBOL
/* A syntax error has occurred.
** The response to an error depends upon whether or not the
** grammar defines an error token "ERROR".
**
** This is what we do if the grammar does define ERROR:
**
** * Call the %syntax_error function.
**
** * Begin popping the stack until we enter a state where
** it is legal to shift the error symbol, then shift
** the error symbol.
**
** * Set the error count to three.
**
** * Begin accepting and shifting new tokens. No new error
** processing will occur until three tokens have been
** shifted successfully.
**
*/
if (yyerrcnt < 0) {
yy_syntax_error(yymajor, yyminorunion);
}
yymx = yystack[yyidx].major;
if (yymx == wktParser_YYERRORSYMBOL || yyerrorhit) {
#ifndef NDEBUG
if (yyTraceFILE) {
*yyTraceFILE << yyTracePrompt << "Discard input token "
<< yyTokenName[yymajor] << std::endl;
}
#endif
yy_destructor((wktParser_YYCODETYPE)yymajor, &yyminorunion);
yymajor = wktParser_YYNOCODE;
}
else {
while (
yyidx >= 0 && yymx != wktParser_YYERRORSYMBOL &&
(yyact = yy_find_reduce_action(yystack[yyidx].stateno,
wktParser_YYERRORSYMBOL)) >= wktParser_YYNSTATE) {
yy_pop_parser_stack();
}
if (yyidx < 0 || yymajor == 0) {
yy_destructor(
(wktParser_YYCODETYPE)yymajor, &yyminorunion);
yy_parse_failed();
yymajor = wktParser_YYNOCODE;
}
else if (yymx != wktParser_YYERRORSYMBOL) {
wktParser_YYMINORTYPE u2;
u2.wktParser_YYERRSYMDT = 0;
yy_shift(yyact, wktParser_YYERRORSYMBOL, &u2);
}
}
yyerrcnt = 3;
yyerrorhit = 1;
#elif defined(wktParser_YYNOERRORRECOVERY)
/* If the wktParser_YYNOERRORRECOVERY macro is defined, then do
*not attempt to
** do any kind of error recovery. Instead, simply invoke the
*syntax
** error routine and continue going as if nothing had happened.
**
** Applications can set this macro (for example inside %include)
*if
** they intend to abandon the parse upon the first syntax error
*seen.
*/
yy_syntax_error(yymajor, yyminorunion);
yy_destructor((wktParser_YYCODETYPE)yymajor, &yyminorunion);
yymajor = wktParser_YYNOCODE;
#else /* wktParser_YYERRORSYMBOL is not defined */
/* This is what we do if the grammar does not define ERROR:
**
** * Report an error message, and throw away the input token.
**
** * If the input token is $, then fail the parse.
**
** As before, subsequent error messages are suppressed until
** three input tokens have been successfully shifted.
*/
if (yyerrcnt <= 0) {
yy_syntax_error(yymajor, yyminorunion);
}
yyerrcnt = 3;
yy_destructor((wktParser_YYCODETYPE)yymajor, &yyminorunion);
if (yyendofinput) {
yy_parse_failed();
}
yymajor = wktParser_YYNOCODE;
#endif
}
} while (yymajor != wktParser_YYNOCODE && yyidx >= 0);
return;
}
};
}
#endif
| 31.339669
| 79
| 0.673321
|
[
"object"
] |
b264102bdae52aeed319a438150a6d3f07f4db95
| 4,467
|
h
|
C
|
app/src/main/cpp/media/decoder/base_decoder.h
|
qzhuorui/OctoberPlayer
|
92489a75c3fc3c195cc495d4674801788c336752
|
[
"Apache-2.0"
] | null | null | null |
app/src/main/cpp/media/decoder/base_decoder.h
|
qzhuorui/OctoberPlayer
|
92489a75c3fc3c195cc495d4674801788c336752
|
[
"Apache-2.0"
] | null | null | null |
app/src/main/cpp/media/decoder/base_decoder.h
|
qzhuorui/OctoberPlayer
|
92489a75c3fc3c195cc495d4674801788c336752
|
[
"Apache-2.0"
] | null | null | null |
/**
* @ProjectName: OctoberPlayer
* @Description: 封装解码中基础的流程
* @Author: qzhuorui
* @CreateDate: 2020/10/12 16:16
*/
#ifndef OCTOBERPLAYER_BASE_DECODER_H
#define OCTOBERPLAYER_BASE_DECODER_H
#include <jni.h>
#include <string>
#include <thread>
#include "../../utils/logger.h"
#include "i_decoder.h"
#include "decode_state.h"
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/frame.h>
#include <libavutil/time.h>
};
class BaseDecoder : public IDecoder {
private :
const char *TAG = "BaseDecoder";
//-------------------------------------------FFmpeg相关的结构体参数，定义解码相关
//解码信息上下文
AVFormatContext *m_format_ctx = NULL;
//解码器
AVCodec *m_codec = NULL;
//解码器上下文
AVCodecContext *m_codec_ctx = NULL;
//待解码包
AVPacket *m_packet = NULL;
//最终解码数据
AVFrame *m_frame = NULL;
//总时长
long m_duration = 0;
//当前播放时间
int64_t m_cur_t_s = 0;
//开始播放的时间
int64_t m_started_t = -1;
//解码状态
DecodeState m_state = STOP;
//数据流索引
int m_stream_index = -1;
//-------------------------------------------解码器基本方法
/**
* 初始化
* @param env jvm环境
* @param path 本地文件路径
*/
void Init(JNIEnv *env, jstring path);
/**
* 初始化FFMpeg相关的参数
* @param env jvm环境
*/
void InitFFMpegDecoder(JNIEnv *env);
/**
* 分配解码过程中需要的缓存
*/
void AllocFrameBuffer();
/**
* 循环解码
*/
void LoopDecode();
/**
* 获取当前帧时间戳
*/
void ObtainTimeStamp();
/**
* 解码完成
* @param env jvm环境
*/
void DoneDecode(JNIEnv *env);
/**
* 时间同步
*/
void SyncRender();
public:
//-------------------------------------------构造方法，析构方法
BaseDecoder(JNIEnv *env, jstring path, bool for_synthesizer);
virtual ~BaseDecoder();
/**
* 视频宽度
* @return
*/
int width() {
return m_codec_ctx->width;
}
/**
* 视频高度
* @return
*/
int height() {
return m_codec_ctx->height;
}
/**
* 视频时长
* @return
*/
long duration() {
return m_duration;
}
//-------------------------------------------实现基类方法，解码器基础功能
void GoOn() override;
void Pause() override;
void Stop() override;
bool IsRunning() override;
long GetDuration() override;
long GetCurPos() override;
//-------------------------------------------定义线程相关
//线程依附的JVM环境，同于在新的解码线程中获取env，JNIEnv和线程是一一对应的
JavaVM *m_jvm_for_thread = NULL;
//原始路径jstring引用，否则无法在线程中操作
jobject m_path_ref = NULL;
//经过转换的路径
const char *m_path = NULL;
//线程等待锁变量
pthread_mutex_t m_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t m_cond = PTHREAD_COND_INITIALIZER;
// 为合成器提供解码
bool m_for_synthesizer = false;
/**
* 新建解码线程
*/
void CreateDecodeThread();
/**
* 静态解码方法，用于解码线程回调
* @param that 当前解码器
*/
static void Decode(std::shared_ptr<BaseDecoder> that);
protected:
/**
* 进入等待
*/
void Wait(long second = 0);
/**
* 恢复解码
*/
void SendSignal();
/**
* 是否为合成器提供解码
* @return true 为合成器提供解码 false 解码播放
*/
bool ForSynthesizer() {
return m_for_synthesizer;
}
const char *path() {
return m_path;
}
/**
* 解码器上下文
* @return
*/
AVCodecContext *codec_cxt() {
return m_codec_ctx;
}
/**
* 视频数据编码格式
* @return
*/
AVPixelFormat video_pixel_format() {
return m_codec_ctx->pix_fmt;
}
/**
* 获取解码时间基
*/
AVRational time_base() {
return m_format_ctx->streams[m_stream_index]->time_base;
}
/**
* 解码一帧数据
* @return
*/
AVFrame *DecodeOneFrame();
//-------------------------------------------子类需要实现的虚函数，规定子类需要实现的方法
/**
* 子类准备回调方法
* @note 注：在解码线程中回调
* @param env 解码线程绑定的JVM环境
*/
virtual void Prepare(JNIEnv *env) = 0;
/**
* 子类渲染回调方法
* @note 注：在解码线程中回调
* @param frame 视频：一帧YUV数据；音频：一帧PCM数据
*/
virtual void Render(AVFrame *frame) = 0;
/**
* 子类释放资源回调方法
*/
virtual void Release() = 0;
/**
* Log前缀
*/
virtual const char *const LogSpec() = 0;
/**
* 音视频索引
*/
virtual AVMediaType GetMediaType() = 0;
/**
* 是否需要自动循环解码
*/
virtual bool NeedLoopDecode() = 0;
};
#endif //OCTOBERPLAYER_BASE_DECODER_H
| 17.449219
| 71
| 0.528543
|
[
"render"
] |
b26e9128bc92e0e580b4c50678767dba82ffa521
| 56,083
|
c
|
C
|
usr/src/uts/common/xen/dtrace/xdt.c
|
AsahiOS/gate
|
283d47da4e17a5871d9d575e7ffb81e8f6c52e51
|
[
"MIT"
] | null | null | null |
usr/src/uts/common/xen/dtrace/xdt.c
|
AsahiOS/gate
|
283d47da4e17a5871d9d575e7ffb81e8f6c52e51
|
[
"MIT"
] | null | null | null |
usr/src/uts/common/xen/dtrace/xdt.c
|
AsahiOS/gate
|
283d47da4e17a5871d9d575e7ffb81e8f6c52e51
|
[
"MIT"
] | 1
|
2020-12-30T00:04:16.000Z
|
2020-12-30T00:04:16.000Z
|
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Xen event provider for DTrace
*
* NOTE: This provider is PRIVATE. It is intended as a short-term solution and
* may disappear or be re-implemented at anytime.
*
* This provider isn't suitable as a general-purpose solution for a number of
* reasons. First and foremost, we rely on the Xen tracing mechanism and don't
* have any way to gather data other than that collected by the Xen trace
* buffers. Further, it does not fit into the DTrace model (see "Interacting
* with DTrace" below.)
*
*
* Tracing in Xen
* --------------
*
* Xen implements a tracing facility for generating and collecting execution
* event traces from the hypervisor. When tracing is enabled, compiled in
* probes record events in contiguous per-CPU trace buffers.
*
* +---------+
* +------+ | |
* | CPUn |----> | BUFFERn |
* +------+ | |
* +---------+- tbuf.va + (tbuf.size * n)
* : :
* +---------+
* +------+ | |
* | CPU1 |----> | BUFFER1 |
* +------+ | |
* +---------+- tbuf.va + tbuf.size
* +------+ | |
* | CPU0 |----> | BUFFER0 |
* +------+ | |
* +---------+- tbuf.va
*
* Each CPU buffer consists of a metadata header followed by the trace records.
* The metadata consists of a producer/consumer pair of pointers into the buffer
* that point to the next record to be written and the next record to be read
* respectively.
*
* A trace record can be in one of two forms, depending on if the TSC is
* included. The record header indicates whether or not the TSC field is
* present.
*
* 1. Trace record without TSC:
* +------------------------------------------------------------+
* | HEADER(uint32_t) | DATA FIELDS |
* +------------------------------------------------------------+
*
* 2. Trace record with TSC:
* +--------------------------------------------------------------------------+
* | HEADER(uint32_t) | TSC(uint64_t) | DATA FIELDS |
* +--------------------------------------------------------------------------+
*
* Where,
*
* HEADER bit field:
* +--------------------------------------------------------------------------+
* | C | NDATA | EVENT |
* +--------------------------------------------------------------------------+
* 31 30 28 27 0
*
* EVENT: Event ID.
* NDATA: Number of populated data fields.
* C: TSC included.
*
* DATA FIELDS:
* +--------------------------------------------------------------------------+
* | D1(uint32_t) | D2(uint32_t) | D3(uint32_t) | . . . | D7(uint32_t) |
* +--------------------------------------------------------------------------+
*
*
* Interacting with DTrace
* -----------------------
*
* Every xdt_poll_nsec nano-seconds we poll the trace buffers for data and feed
* each entry into dtrace_probe() with the corresponding probe ID for the event.
* As a result of this periodic collection implementation probe firings are
* asynchronous. This is the only sensible way to implement this form of
* provider, but because of its asynchronous nature asking things like
* "current CPU" and, more importantly, arbitrary questions about the context
* surrounding the probe firing are not meaningful. So, consumers should not
* attempt to infer anything beyond what is supplied via the probe arguments.
*/
#include <sys/xpv_user.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/modctl.h>
#include <sys/sunddi.h>
#include <sys/ddi.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/stat.h>
#include <sys/cmn_err.h>
#include <sys/dtrace.h>
#include <sys/sdt.h>
#include <sys/cyclic.h>
#include <vm/seg_kmem.h>
#include <vm/hat_i86.h>
#include <sys/hypervisor.h>
#include <xen/public/trace.h>
#include <xen/public/sched.h>
#define XDT_POLL_DEFAULT 100000000 /* default poll interval (ns) */
#define XDT_POLL_MIN 10000000 /* min poll interval (ns) */
#define XDT_TBUF_RETRY 50 /* tbuf disable retry count */
/*
* The domid must match IDLE_DOMAIN_ID in xen.hg/xen/include/xen/sched.h
* in the xVM gate.
*/
#define IS_IDLE_DOM(domid) (domid == 0x7FFFU)
/* Macros to extract the domid and cpuid from a HVM trace data field */
#define HVM_DOMID(d) (d >> 16)
#define HVM_VCPUID(d) (d & 0xFFFF)
/* Flags for shadow page table events */
#define SH_GUEST_32 0x000
#define SH_GUEST_PAE 0x100
#define SH_GUEST_64 0x200
#define XDT_PROBE5(event, arg0, arg1, arg2, arg3, arg4) { \
dtrace_id_t id = xdt_probemap[event]; \
if (id) \
dtrace_probe(id, arg0, arg1, arg2, arg3, arg4); \
} \
#define XDT_PROBE4(event, arg0, arg1, arg2, arg3) \
XDT_PROBE5(event, arg0, arg1, arg2, arg3, 0)
#define XDT_PROBE3(event, arg0, arg1, arg2) \
XDT_PROBE5(event, arg0, arg1, arg2, 0, 0)
#define XDT_PROBE2(event, arg0, arg1) \
XDT_PROBE5(event, arg0, arg1, 0, 0, 0)
#define XDT_PROBE1(event, arg0) \
XDT_PROBE5(event, arg0, 0, 0, 0, 0)
#define XDT_PROBE0(event) \
XDT_PROBE5(event, 0, 0, 0, 0, 0)
/* Probe classes */
#define XDT_SCHED 0
#define XDT_MEM 1
#define XDT_HVM 2
#define XDT_GEN 3
#define XDT_PV 4
#define XDT_SHADOW 5
#define XDT_PM 6
#define XDT_NCLASSES 7
/* Probe events */
#define XDT_EVT_INVALID (-(int)1)
#define XDT_SCHED_OFF_CPU 0
#define XDT_SCHED_ON_CPU 1
#define XDT_SCHED_IDLE_OFF_CPU 2
#define XDT_SCHED_IDLE_ON_CPU 3
#define XDT_SCHED_BLOCK 4
#define XDT_SCHED_SLEEP 5
#define XDT_SCHED_WAKE 6
#define XDT_SCHED_YIELD 7
#define XDT_SCHED_SHUTDOWN_POWEROFF 8
#define XDT_SCHED_SHUTDOWN_REBOOT 9
#define XDT_SCHED_SHUTDOWN_SUSPEND 10
#define XDT_SCHED_SHUTDOWN_CRASH 11
#define XDT_MEM_PAGE_GRANT_MAP 12
#define XDT_MEM_PAGE_GRANT_UNMAP 13
#define XDT_MEM_PAGE_GRANT_TRANSFER 14
#define XDT_HVM_VMENTRY 15
#define XDT_HVM_VMEXIT 16
#define XDT_TRC_LOST_RECORDS 17
#define XDT_SCHED_ADD_VCPU 18
#define XDT_SCHED_REM_VCPU 19 /* unused */
#define XDT_SCHED_CTL 20 /* unused */
#define XDT_SCHED_ADJDOM 21
#define XDT_SCHED_S_TIMER_FN 22 /* unused */
#define XDT_SCHED_T_TIMER_FN 23 /* unused */
#define XDT_SCHED_DOM_TIMER_FN 24 /* unused */
#define XDT_PV_HYPERCALL 25
#define XDT_PV_TRAP 26
#define XDT_PV_PAGE_FAULT 27
#define XDT_PV_FORCED_INVALID_OP 28
#define XDT_PV_EMULATE_PRIVOP 29
#define XDT_PV_EMULATE_4GB 30 /* unused (32-bit HV only ) */
#define XDT_PV_MATH_STATE_RESTORE 31
#define XDT_PV_PAGING_FIXUP 32
#define XDT_PV_DT_MAPPING_FAULT 33
#define XDT_PV_PTWR_EMULATION 34
#define XDT_HVM_PF_XEN 35
#define XDT_HVM_PF_INJECT 36
#define XDT_HVM_EXC_INJECT 37
#define XDT_HVM_VIRQ_INJECT 38
#define XDT_HVM_VIRQ_REINJECT 39
#define XDT_HVM_IO_READ 40 /* unused */
#define XDT_HVM_IO_WRITE 41 /* unused */
#define XDT_HVM_CR_READ 42
#define XDT_HVM_CR_WRITE 43
#define XDT_HVM_DR_READ 44 /* unused */
#define XDT_HVM_DR_WRITE 45 /* unused */
#define XDT_HVM_MSR_READ 46
#define XDT_HVM_MSR_WRITE 47
#define XDT_HVM_CPUID 48
#define XDT_HVM_INTR 49
#define XDT_HVM_INTR_WINDOW 50
#define XDT_HVM_NMI 51
#define XDT_HVM_SMI 52
#define XDT_HVM_VMMCALL 53
#define XDT_HVM_HLT 54
#define XDT_HVM_INVLPG 55
#define XDT_HVM_MCE 56
#define XDT_HVM_IOPORT_READ 57
#define XDT_HVM_IOPORT_WRITE 58
#define XDT_HVM_CLTS 59
#define XDT_HVM_LMSW 60
#define XDT_HVM_IOMEM_READ 61
#define XDT_HVM_IOMEM_WRITE 62
#define XDT_SHADOW_NOT_SHADOW 63
#define XDT_SHADOW_FAST_PROPAGATE 64
#define XDT_SHADOW_FAST_MMIO 65
#define XDT_SHADOW_FALSE_FAST_PATH 66
#define XDT_SHADOW_MMIO 67
#define XDT_SHADOW_FIXUP 68
#define XDT_SHADOW_DOMF_DYING 69
#define XDT_SHADOW_EMULATE 70
#define XDT_SHADOW_EMULATE_UNSHADOW_USER 71
#define XDT_SHADOW_EMULATE_UNSHADOW_EVTINJ 72
#define XDT_SHADOW_EMULATE_UNSHADOW_UNHANDLED 73
#define XDT_SHADOW_WRMAP_BF 74
#define XDT_SHADOW_PREALLOC_UNPIN 75
#define XDT_SHADOW_RESYNC_FULL 76
#define XDT_SHADOW_RESYNC_ONLY 77
#define XDT_PM_FREQ_CHANGE 78
#define XDT_PM_IDLE_ENTRY 79
#define XDT_PM_IDLE_EXIT 80
#define XDT_SCHED_RUNSTATE_CHANGE 81
#define XDT_SCHED_CONTINUE_RUNNING 82
#define XDT_NEVENTS 83
typedef struct {
const char *pr_mod; /* probe module */
const char *pr_name; /* probe name */
int evt_id; /* event id */
uint_t class; /* probe class */
} xdt_probe_t;
typedef struct {
uint32_t trc_mask; /* trace mask */
uint32_t cnt; /* num enabled probes in class */
} xdt_classinfo_t;
typedef struct {
ulong_t prev_domid; /* previous dom executed */
ulong_t prev_vcpuid; /* previous vcpu executed */
ulong_t prev_ctime; /* time spent on cpu */
ulong_t next_domid; /* next dom to be scheduled */
ulong_t next_vcpuid; /* next vcpu to be scheduled */
ulong_t next_wtime; /* time spent waiting to get on cpu */
ulong_t next_ts; /* allocated time slice */
ulong_t cur_domid; /* current dom */
ulong_t cur_vcpuid; /* current vcpuid */
int curinfo_valid; /* info is valid */
} xdt_schedinfo_t;
static struct {
uint_t cnt; /* total num of trace buffers */
size_t size; /* size of each cpu buffer */
mfn_t start_mfn; /* starting mfn of buffers */
caddr_t va; /* va buffers are mapped into */
/* per-cpu buffers */
struct t_buf **meta; /* buffer metadata */
struct t_rec **data; /* buffer data records */
/* statistics */
uint64_t stat_dropped_recs; /* records dropped */
uint64_t stat_spurious_cpu; /* recs with garbage cpuids */
uint64_t stat_spurious_switch; /* inconsistent vcpu switches */
uint64_t stat_unknown_shutdown; /* unknown shutdown code */
uint64_t stat_unknown_recs; /* unknown records */
} tbuf;
static size_t tbuf_data_size;
static char *xdt_stats[] = {
"dropped_recs",
};
/*
* Tunable variables
*
* The following may be tuned by adding a line to /etc/system that
* includes both the name of the module ("xdt") and the name of the variable.
* For example:
* set xdt:xdt_tbuf_pages = 40
*/
uint_t xdt_tbuf_pages = 20; /* pages to alloc per-cpu buf */
/*
* The following may be tuned by adding a line to
* /platform/i86xpv/kernel/drv/xdt.conf.
* For example:
* xdt_poll_nsec = 200000000;
*/
static hrtime_t xdt_poll_nsec; /* trace buffer poll interval */
/*
* Another tunable variable: the maximum number of records to process
* in one scan. If it is 0 (e.g. not set in /etc/system), it will
* be set to ncpu * (bufsize / max_rec_size).
*
* Having an upper limit avoids a situation where the scan would loop
* endlessly in case the hypervisor adds records quicker than we
* can process them. It's better to drop records than to loop, obviously.
*/
uint_t xdt_max_recs = 0;
/*
* Internal variables
*/
static dev_info_t *xdt_devi;
static dtrace_provider_id_t xdt_id;
static uint_t xdt_ncpus; /* total number of phys CPUs */
static uint32_t cur_trace_mask; /* current trace mask */
static xdt_schedinfo_t *xdt_cpu_schedinfo; /* per-cpu sched info */
dtrace_id_t xdt_probemap[XDT_NEVENTS]; /* map of enabled probes */
dtrace_id_t xdt_prid[XDT_NEVENTS]; /* IDs of registered events */
static cyclic_id_t xdt_cyclic = CYCLIC_NONE;
static kstat_t *xdt_kstats;
static xdt_classinfo_t xdt_classinfo[XDT_NCLASSES];
/*
* These provide context when probes fire. They can be accessed
* from xdt dtrace probe (as `xdt_curdom, etc). It's ok for these
* to be global, and not per-cpu, as probes are run strictly in sequence
* as the trace buffers are
*/
uint_t xdt_curdom, xdt_curvcpu, xdt_curpcpu;
uint64_t xdt_timestamp;
static xdt_probe_t xdt_probe[] = {
/* Sched probes */
{ "sched", "off-cpu", XDT_SCHED_OFF_CPU, XDT_SCHED },
{ "sched", "on-cpu", XDT_SCHED_ON_CPU, XDT_SCHED },
{ "sched", "idle-off-cpu", XDT_SCHED_IDLE_OFF_CPU, XDT_SCHED },
{ "sched", "idle-on-cpu", XDT_SCHED_IDLE_ON_CPU, XDT_SCHED },
{ "sched", "block", XDT_SCHED_BLOCK, XDT_SCHED },
{ "sched", "sleep", XDT_SCHED_SLEEP, XDT_SCHED },
{ "sched", "wake", XDT_SCHED_WAKE, XDT_SCHED },
{ "sched", "yield", XDT_SCHED_YIELD, XDT_SCHED },
{ "sched", "shutdown-poweroff", XDT_SCHED_SHUTDOWN_POWEROFF,
XDT_SCHED },
{ "sched", "shutdown-reboot", XDT_SCHED_SHUTDOWN_REBOOT, XDT_SCHED },
{ "sched", "shutdown-suspend", XDT_SCHED_SHUTDOWN_SUSPEND, XDT_SCHED },
{ "sched", "shutdown-crash", XDT_SCHED_SHUTDOWN_CRASH, XDT_SCHED },
{ "sched", "add", XDT_SCHED_ADD_VCPU, XDT_SCHED },
{ "sched", "runstate-change", XDT_SCHED_RUNSTATE_CHANGE, XDT_SCHED },
{ "sched", "continue-running", XDT_SCHED_CONTINUE_RUNNING, XDT_SCHED },
/* Memory probes */
{ "mem", "page-grant-map", XDT_MEM_PAGE_GRANT_MAP, XDT_MEM },
{ "mem", "page-grant-unmap", XDT_MEM_PAGE_GRANT_UNMAP, XDT_MEM },
{ "mem", "page-grant-transfer", XDT_MEM_PAGE_GRANT_TRANSFER, XDT_MEM },
{"pv", "hypercall", XDT_PV_HYPERCALL, XDT_PV },
{"pv", "trap", XDT_PV_TRAP, XDT_PV },
{"pv", "page-fault", XDT_PV_PAGE_FAULT, XDT_PV },
{"pv", "forced-invalid-op", XDT_PV_FORCED_INVALID_OP, XDT_PV },
{"pv", "emulate-priv-op", XDT_PV_EMULATE_PRIVOP, XDT_PV },
{"pv", "math-state-restore", XDT_PV_MATH_STATE_RESTORE, XDT_PV },
{"pv", "paging-fixup", XDT_PV_PAGING_FIXUP, XDT_PV },
{"pv", "dt-mapping-fault", XDT_PV_DT_MAPPING_FAULT, XDT_PV },
{"pv", "pte-write-emul", XDT_PV_PTWR_EMULATION, XDT_PV },
/* HVM probes */
{ "hvm", "vmentry", XDT_HVM_VMENTRY, XDT_HVM },
{ "hvm", "vmexit", XDT_HVM_VMEXIT, XDT_HVM },
{ "hvm", "pagefault-xen", XDT_HVM_PF_XEN, XDT_HVM },
{ "hvm", "pagefault-inject", XDT_HVM_PF_INJECT, XDT_HVM },
{ "hvm", "exception-inject", XDT_HVM_EXC_INJECT, XDT_HVM },
{ "hvm", "virq-inject", XDT_HVM_VIRQ_INJECT, XDT_HVM },
{ "hvm", "cr-read", XDT_HVM_CR_READ, XDT_HVM },
{ "hvm", "cr-write", XDT_HVM_CR_WRITE, XDT_HVM },
{ "hvm", "msr-read", XDT_HVM_MSR_READ, XDT_HVM },
{ "hvm", "msr-write", XDT_HVM_MSR_WRITE, XDT_HVM },
{ "hvm", "cpuid", XDT_HVM_CPUID, XDT_HVM },
{ "hvm", "intr", XDT_HVM_INTR, XDT_HVM },
{ "hvm", "intr-window", XDT_HVM_INTR_WINDOW, XDT_HVM },
{ "hvm", "nmi", XDT_HVM_NMI, XDT_HVM },
{ "hvm", "smi", XDT_HVM_SMI, XDT_HVM },
{ "hvm", "vmmcall", XDT_HVM_VMMCALL, XDT_HVM },
{ "hvm", "hlt", XDT_HVM_HLT, XDT_HVM },
{ "hvm", "invlpg", XDT_HVM_INVLPG, XDT_HVM },
{ "hvm", "mce", XDT_HVM_MCE, XDT_HVM },
{ "hvm", "pio-read", XDT_HVM_IOPORT_READ, XDT_HVM },
{ "hvm", "pio-write", XDT_HVM_IOPORT_WRITE, XDT_HVM },
{ "hvm", "mmio-read", XDT_HVM_IOMEM_READ, XDT_HVM },
{ "hvm", "mmio-write", XDT_HVM_IOMEM_WRITE, XDT_HVM },
{ "hvm", "clts", XDT_HVM_CLTS, XDT_HVM },
{ "hvm", "lmsw", XDT_HVM_LMSW, XDT_HVM },
{ "shadow", "fault-not-shadow", XDT_SHADOW_NOT_SHADOW, XDT_SHADOW },
{ "shadow", "fast-propagate", XDT_SHADOW_FAST_PROPAGATE, XDT_SHADOW },
{ "shadow", "fast-mmio", XDT_SHADOW_FAST_MMIO, XDT_SHADOW },
{ "shadow", "false-fast-path", XDT_SHADOW_FALSE_FAST_PATH,
XDT_SHADOW },
{ "shadow", "mmio", XDT_SHADOW_MMIO, XDT_SHADOW },
{ "shadow", "fixup", XDT_SHADOW_FIXUP, XDT_SHADOW },
{ "shadow", "domf-dying", XDT_SHADOW_DOMF_DYING, XDT_SHADOW },
{ "shadow", "emulate", XDT_SHADOW_EMULATE, XDT_SHADOW },
{ "shadow", "emulate-unshadow-user", XDT_SHADOW_EMULATE_UNSHADOW_USER,
XDT_SHADOW },
{ "shadow", "emulate-unshadow-evtinj",
XDT_SHADOW_EMULATE_UNSHADOW_EVTINJ, XDT_SHADOW },
{ "shadow", "emulate-unshadow-unhandled",
XDT_SHADOW_EMULATE_UNSHADOW_UNHANDLED, XDT_SHADOW },
{ "shadow", "wrmap-bf", XDT_SHADOW_WRMAP_BF, XDT_SHADOW },
{ "shadow", "prealloc-unpin", XDT_SHADOW_PREALLOC_UNPIN, XDT_SHADOW },
{ "shadow", "resync-full", XDT_SHADOW_RESYNC_FULL, XDT_SHADOW },
{ "shadow", "resync-only", XDT_SHADOW_RESYNC_ONLY, XDT_SHADOW },
{ "pm", "freq-change", XDT_PM_FREQ_CHANGE, XDT_PM },
{ "pm", "idle-entry", XDT_PM_IDLE_ENTRY, XDT_PM },
{ "pm", "idle-exit", XDT_PM_IDLE_EXIT, XDT_PM },
/* Trace buffer related probes */
{ "trace", "records-lost", XDT_TRC_LOST_RECORDS, XDT_GEN },
{ NULL }
};
static inline uint32_t
xdt_nr_active_probes()
{
int i;
uint32_t tot = 0;
for (i = 0; i < XDT_NCLASSES; i++)
tot += xdt_classinfo[i].cnt;
return (tot);
}
static void
xdt_init_trace_masks(void)
{
xdt_classinfo[XDT_SCHED].trc_mask = TRC_SCHED;
xdt_classinfo[XDT_MEM].trc_mask = TRC_MEM;
xdt_classinfo[XDT_HVM].trc_mask = TRC_HVM;
xdt_classinfo[XDT_GEN].trc_mask = TRC_GEN;
xdt_classinfo[XDT_PV].trc_mask = TRC_PV;
xdt_classinfo[XDT_SHADOW].trc_mask = TRC_SHADOW;
xdt_classinfo[XDT_PM].trc_mask = TRC_PM;
}
static int
xdt_kstat_update(kstat_t *ksp, int flag)
{
kstat_named_t *knp;
if (flag != KSTAT_READ)
return (EACCES);
knp = ksp->ks_data;
/*
* Assignment order should match that of the names in
* xdt_stats.
*/
(knp++)->value.ui64 = tbuf.stat_dropped_recs;
return (0);
}
static void
xdt_kstat_init(void)
{
int nstats = sizeof (xdt_stats) / sizeof (xdt_stats[0]);
char **cp = xdt_stats;
kstat_named_t *knp;
if ((xdt_kstats = kstat_create("xdt", 0, "trace_statistics", "misc",
KSTAT_TYPE_NAMED, nstats, 0)) == NULL)
return;
xdt_kstats->ks_update = xdt_kstat_update;
knp = xdt_kstats->ks_data;
while (nstats > 0) {
kstat_named_init(knp, *cp, KSTAT_DATA_UINT64);
knp++;
cp++;
nstats--;
}
kstat_install(xdt_kstats);
}
static int
xdt_sysctl_tbuf(xen_sysctl_tbuf_op_t *tbuf_op)
{
xen_sysctl_t op;
int xerr;
op.cmd = XEN_SYSCTL_tbuf_op;
op.interface_version = XEN_SYSCTL_INTERFACE_VERSION;
op.u.tbuf_op = *tbuf_op;
if ((xerr = HYPERVISOR_sysctl(&op)) != 0)
return (xen_xlate_errcode(xerr));
*tbuf_op = op.u.tbuf_op;
return (0);
}
static int
xdt_map_trace_buffers(mfn_t mfn, caddr_t va, size_t len)
{
x86pte_t pte;
caddr_t const sva = va;
caddr_t const eva = va + len;
int xerr;
ASSERT(mfn != MFN_INVALID);
ASSERT(va != NULL);
ASSERT(IS_PAGEALIGNED(len));
for (; va < eva; va += MMU_PAGESIZE) {
/*
* Ask the HAT to load a throwaway mapping to page zero, then
* overwrite it with the hypervisor mapping. It gets removed
* later via hat_unload().
*/
hat_devload(kas.a_hat, va, MMU_PAGESIZE, (pfn_t)0,
PROT_READ | HAT_UNORDERED_OK,
HAT_LOAD_NOCONSIST | HAT_LOAD);
pte = mmu_ptob((x86pte_t)mfn) | PT_VALID | PT_USER
| PT_FOREIGN | PT_WRITABLE;
xerr = HYPERVISOR_update_va_mapping_otherdomain((ulong_t)va,
pte, UVMF_INVLPG | UVMF_LOCAL, DOMID_XEN);
if (xerr != 0) {
/* unmap pages loaded so far */
size_t ulen = (uintptr_t)(va + MMU_PAGESIZE) -
(uintptr_t)sva;
hat_unload(kas.a_hat, sva, ulen, HAT_UNLOAD_UNMAP);
return (xen_xlate_errcode(xerr));
}
mfn++;
}
return (0);
}
static int
xdt_attach_trace_buffers(void)
{
xen_sysctl_tbuf_op_t tbuf_op;
size_t len;
int err;
uint_t i;
/*
* Xen does not support trace buffer re-sizing. If the buffers
* have already been allocated we just use them as is.
*/
tbuf_op.cmd = XEN_SYSCTL_TBUFOP_get_info;
if ((err = xdt_sysctl_tbuf(&tbuf_op)) != 0)
return (err);
if (tbuf_op.size == 0) {
/* set trace buffer size */
tbuf_op.cmd = XEN_SYSCTL_TBUFOP_set_size;
tbuf_op.size = xdt_tbuf_pages;
(void) xdt_sysctl_tbuf(&tbuf_op);
/* get trace buffer info */
tbuf_op.cmd = XEN_SYSCTL_TBUFOP_get_info;
if ((err = xdt_sysctl_tbuf(&tbuf_op)) != 0)
return (err);
if (tbuf_op.size == 0) {
cmn_err(CE_NOTE, "Couldn't allocate trace buffers.");
return (ENOBUFS);
}
}
tbuf.size = tbuf_op.size;
tbuf.start_mfn = (mfn_t)tbuf_op.buffer_mfn;
tbuf.cnt = xdt_ncpus;
ASSERT(tbuf.start_mfn != MFN_INVALID);
ASSERT(tbuf.cnt > 0);
len = tbuf.size * tbuf.cnt;
tbuf.va = vmem_alloc(heap_arena, len, VM_SLEEP);
if ((err = xdt_map_trace_buffers(tbuf.start_mfn, tbuf.va, len)) != 0) {
vmem_free(heap_arena, tbuf.va, len);
tbuf.va = NULL;
return (err);
}
tbuf.meta = (struct t_buf **)kmem_alloc(tbuf.cnt * sizeof (*tbuf.meta),
KM_SLEEP);
tbuf.data = (struct t_rec **)kmem_alloc(tbuf.cnt * sizeof (*tbuf.data),
KM_SLEEP);
for (i = 0; i < tbuf.cnt; i++) {
void *cpu_buf = (void *)(tbuf.va + (tbuf.size * i));
tbuf.meta[i] = cpu_buf;
tbuf.data[i] = (struct t_rec *)((uintptr_t)cpu_buf +
sizeof (struct t_buf));
/* throw away stale trace records */
tbuf.meta[i]->cons = tbuf.meta[i]->prod;
}
tbuf_data_size = tbuf.size - sizeof (struct t_buf);
if (xdt_max_recs == 0)
xdt_max_recs = (xdt_ncpus * tbuf_data_size)
/ sizeof (struct t_rec);
return (0);
}
static void
xdt_detach_trace_buffers(void)
{
size_t len = tbuf.size * tbuf.cnt;
ASSERT(tbuf.va != NULL);
hat_unload(kas.a_hat, tbuf.va, len,
HAT_UNLOAD_UNMAP | HAT_UNLOAD_UNLOCK);
vmem_free(heap_arena, tbuf.va, len);
kmem_free(tbuf.meta, tbuf.cnt * sizeof (*tbuf.meta));
kmem_free(tbuf.data, tbuf.cnt * sizeof (*tbuf.data));
}
static void
xdt_update_sched_context(uint_t cpuid, uint_t dom, uint_t vcpu)
{
xdt_schedinfo_t *sp = &xdt_cpu_schedinfo[cpuid];
sp->cur_domid = dom;
sp->cur_vcpuid = vcpu;
sp->curinfo_valid = 1;
}
static void
xdt_update_domain_context(uint_t dom, uint_t vcpu)
{
xdt_curdom = dom;
xdt_curvcpu = vcpu;
}
static size_t
xdt_process_rec(uint_t cpuid, struct t_rec *rec)
{
xdt_schedinfo_t *sp = &xdt_cpu_schedinfo[cpuid];
uint_t dom, vcpu;
int eid;
uint32_t *data;
uint64_t tsc, addr64, rip64, val64, pte64;
size_t rec_size;
ASSERT(rec != NULL);
ASSERT(xdt_ncpus == xpv_nr_phys_cpus());
eid = 0;
if (cpuid >= xdt_ncpus) {
tbuf.stat_spurious_cpu++;
goto done;
}
/*
* If our current state isn't valid, and if this is not
* an event that will update our state, skip it.
*/
if (!sp->curinfo_valid &&
rec->event != TRC_SCHED_SWITCH &&
rec->event != TRC_LOST_RECORDS)
goto done;
if (rec->cycles_included) {
data = rec->u.cycles.extra_u32;
tsc = (((uint64_t)rec->u.cycles.cycles_hi) << 32)
| rec->u.cycles.cycles_lo;
} else {
data = rec->u.nocycles.extra_u32;
tsc = 0;
}
xdt_timestamp = tsc;
switch (rec->event) {
/*
* Sched probes
*/
case TRC_SCHED_SWITCH_INFPREV:
/*
* Info on vCPU being de-scheduled
*
* data[0] = prev domid
* data[1] = time spent on pcpu
*/
sp->prev_domid = data[0];
sp->prev_ctime = data[1];
break;
case TRC_SCHED_SWITCH_INFNEXT:
/*
* Info on next vCPU to be scheduled
*
* data[0] = next domid
* data[1] = time spent waiting to get on cpu
* data[2] = time slice
*/
sp->next_domid = data[0];
sp->next_wtime = data[1];
sp->next_ts = data[2];
break;
case TRC_SCHED_SWITCH:
/*
* vCPU switch
*
* data[0] = prev domid
* data[1] = prev vcpuid
* data[2] = next domid
* data[3] = next vcpuid
*/
/*
* Provide valid context for this probe if there
* wasn't one.
*/
if (!sp->curinfo_valid)
xdt_update_domain_context(data[0], data[1]);
xdt_update_sched_context(cpuid, data[0], data[1]);
if (data[0] != sp->prev_domid &&
data[2] != sp->next_domid) {
/* prev and next info don't match doms being sched'd */
tbuf.stat_spurious_switch++;
goto switchdone;
}
sp->prev_vcpuid = data[1];
sp->next_vcpuid = data[3];
XDT_PROBE3(IS_IDLE_DOM(sp->prev_domid)?
XDT_SCHED_IDLE_OFF_CPU:XDT_SCHED_OFF_CPU,
sp->prev_domid, sp->prev_vcpuid, sp->prev_ctime);
XDT_PROBE4(IS_IDLE_DOM(sp->next_domid)?
XDT_SCHED_IDLE_ON_CPU:XDT_SCHED_ON_CPU,
sp->next_domid, sp->next_vcpuid, sp->next_wtime,
sp->next_ts);
switchdone:
xdt_update_sched_context(cpuid, data[2], data[3]);
xdt_update_domain_context(data[2], data[3]);
break;
case TRC_SCHED_BLOCK:
/*
* vCPU blocked
*
* data[0] = domid
* data[1] = vcpuid
*/
XDT_PROBE2(XDT_SCHED_BLOCK, data[0], data[1]);
break;
case TRC_SCHED_SLEEP:
/*
* Put vCPU to sleep
*
* data[0] = domid
* data[1] = vcpuid
*/
XDT_PROBE2(XDT_SCHED_SLEEP, data[0], data[1]);
break;
case TRC_SCHED_WAKE:
/*
* Wake up vCPU
*
* data[0] = domid
* data[1] = vcpuid
*/
XDT_PROBE2(XDT_SCHED_WAKE, data[0], data[1]);
break;
case TRC_SCHED_YIELD:
/*
* vCPU yielded
*
* data[0] = domid
* data[1] = vcpuid
*/
XDT_PROBE2(XDT_SCHED_YIELD, data[0], data[1]);
break;
case TRC_SCHED_SHUTDOWN:
/*
* Guest shutting down
*
* data[0] = domid
* data[1] = initiating vcpu
* data[2] = shutdown code
*/
switch (data[2]) {
case SHUTDOWN_poweroff:
eid = XDT_SCHED_SHUTDOWN_POWEROFF;
break;
case SHUTDOWN_reboot:
eid = XDT_SCHED_SHUTDOWN_REBOOT;
break;
case SHUTDOWN_suspend:
eid = XDT_SCHED_SHUTDOWN_SUSPEND;
break;
case SHUTDOWN_crash:
eid = XDT_SCHED_SHUTDOWN_CRASH;
break;
default:
tbuf.stat_unknown_shutdown++;
goto done;
}
XDT_PROBE2(eid, data[0], data[1]);
break;
case TRC_SCHED_DOM_REM:
case TRC_SCHED_CTL:
case TRC_SCHED_S_TIMER_FN:
case TRC_SCHED_T_TIMER_FN:
case TRC_SCHED_DOM_TIMER_FN:
/* unused */
break;
case TRC_SCHED_DOM_ADD:
/*
* Add vcpu to a guest.
*
* data[0] = domid
* data[1] = vcpu
*/
XDT_PROBE2(XDT_SCHED_ADD_VCPU, data[0], data[1]);
break;
case TRC_SCHED_ADJDOM:
/*
* Scheduling parameters for a guest
* were modified.
*
* data[0] = domid;
*/
XDT_PROBE1(XDT_SCHED_ADJDOM, data[1]);
break;
case TRC_SCHED_RUNSTATE_CHANGE:
/*
* Runstate change for a VCPU.
*
* data[0] = (domain << 16) | vcpu;
* data[1] = oldstate;
* data[2] = newstate;
*/
XDT_PROBE4(XDT_SCHED_RUNSTATE_CHANGE, data[0] >> 16,
data[0] & 0xffff, data[1], data[2]);
break;
case TRC_SCHED_CONTINUE_RUNNING:
/*
* VCPU is back on a physical CPU that it previously
* was also running this VCPU.
*
* data[0] = (domain << 16) | vcpu;
*/
XDT_PROBE2(XDT_SCHED_CONTINUE_RUNNING, data[0] >> 16,
data[0] & 0xffff);
break;
/*
* Mem probes
*/
case TRC_MEM_PAGE_GRANT_MAP:
/*
* Guest mapped page grant
*
* data[0] = target domid
*/
XDT_PROBE1(XDT_MEM_PAGE_GRANT_MAP, data[0]);
break;
case TRC_MEM_PAGE_GRANT_UNMAP:
/*
* Guest unmapped page grant
*
* data[0] = target domid
*/
XDT_PROBE1(XDT_MEM_PAGE_GRANT_UNMAP, data[0]);
break;
case TRC_MEM_PAGE_GRANT_TRANSFER:
/*
* Page grant is being transferred
*
* data[0] = target domid
*/
XDT_PROBE1(XDT_MEM_PAGE_GRANT_TRANSFER, data[0]);
break;
/*
* Probes for PV domains.
*/
case TRC_PV_HYPERCALL:
/*
* Hypercall from a 32-bit PV domain.
*
* data[0] = eip
* data[1] = eax
*/
XDT_PROBE2(XDT_PV_HYPERCALL, data[0], data[1]);
break;
case TRC_PV_HYPERCALL | TRC_64_FLAG:
/*
* Hypercall from a 64-bit PV domain.
*
* data[0] = rip(0:31)
* data[1] = rip(32:63)
* data[2] = eax;
*/
rip64 = (((uint64_t)data[1]) << 32) | data[0];
XDT_PROBE2(XDT_PV_HYPERCALL, rip64, data[2]);
break;
case TRC_PV_TRAP:
/*
* Trap in a 32-bit PV domain.
*
* data[0] = eip
* data[1] = trapnr | (error_code_valid << 15)
* | (error_code << 16);
*/
XDT_PROBE4(XDT_PV_TRAP, data[0], data[1] & 0x7fff,
(data[1] >> 15) & 1, data[1] >> 16);
break;
case TRC_PV_TRAP | TRC_64_FLAG:
/*
* Trap in a 64-bit PV domain.
*
* data[0] = rip(0:31)
* data[1] = rip(32:63)
* data[2] = trapnr | (error_code_valid << 15)
* | (error_code << 16);
*/
rip64 = (((uint64_t)data[1]) << 32) | data[2];
XDT_PROBE4(XDT_PV_TRAP, rip64, data[2] & 0x7fff,
(data[2] >> 15) & 1, data[2] >> 16);
break;
case TRC_PV_PAGE_FAULT:
/*
* Page fault in a 32-bit PV domain.
*
* data[0] = eip
* data[1] = vaddr
* data[2] = error code
*/
XDT_PROBE3(XDT_PV_PAGE_FAULT, data[0], data[1], data[2]);
break;
case TRC_PV_PAGE_FAULT | TRC_64_FLAG:
/*
* Page fault in a 32-bit PV domain.
*
* data[0] = rip(0:31)
* data[1] = rip(31:63)
* data[2] = vaddr(0:31)
* data[3] = vaddr(31:63)
* data[4] = error code
*/
rip64 = (((uint64_t)data[1]) << 32) | data[0];
addr64 = (((uint64_t)data[3]) << 32) | data[2];
XDT_PROBE3(XDT_PV_PAGE_FAULT, rip64, addr64, data[4]);
break;
case TRC_PV_FORCED_INVALID_OP:
/*
* Hypervisor emulated a forced invalid op (ud2)
* in a 32-bit PV domain.
*
* data[1] = eip
*/
XDT_PROBE1(XDT_PV_FORCED_INVALID_OP, data[1]);
break;
case TRC_PV_FORCED_INVALID_OP | TRC_64_FLAG:
/*
* Hypervisor emulated a forced invalid op (ud2)
* in a 64-bit PV domain.
*
* data[1] = rip(0:31)
* data[2] = rip(31:63)
*
*/
rip64 = (((uint64_t)data[2]) << 32) | data[1];
XDT_PROBE1(XDT_PV_FORCED_INVALID_OP, rip64);
break;
case TRC_PV_EMULATE_PRIVOP:
/*
* Hypervisor emulated a privileged operation
* in a 32-bit PV domain.
*
* data[0] = eip
*/
XDT_PROBE1(XDT_PV_EMULATE_PRIVOP, data[0]);
break;
case TRC_PV_EMULATE_PRIVOP | TRC_64_FLAG:
/*
* Hypervisor emulated a privileged operation
* in a 64-bit PV domain.
*
* data[0] = rip(0:31)
* data[1] = rip(31:63)
*/
rip64 = (((uint64_t)data[1]) << 32) | data[0];
XDT_PROBE1(XDT_PV_EMULATE_PRIVOP, rip64);
break;
case TRC_PV_EMULATE_4GB:
/* unused, 32-bit hypervisor only */
break;
case TRC_PV_MATH_STATE_RESTORE:
/*
* Hypervisor restores math state after FP DNA trap.
*
* No arguments.
*/
XDT_PROBE0(XDT_PV_MATH_STATE_RESTORE);
break;
case TRC_PV_PAGING_FIXUP:
/*
* Hypervisor fixed up a page fault (e.g. it was
* a side-effect of hypervisor guest page table
* bookkeeping, and not propagated to the guest).
*
* data[0] = eip
* data[1] = vaddr
*/
XDT_PROBE2(XDT_PV_PAGING_FIXUP, data[0], data[2]);
break;
case TRC_PV_PAGING_FIXUP | TRC_64_FLAG:
/*
* Hypervisor fixed up a page fault (e.g. it was
* a side-effect of hypervisor guest page table
* bookkeeping, and not propagated to the guest).
*
* data[0] = eip(0:31)
* data[1] = eip(31:63)
* data[2] = vaddr(0:31)
* data[3] = vaddr(31:63)
*/
rip64 = (((uint64_t)data[1]) << 32) | data[0];
addr64 = (((uint64_t)data[3]) << 32) | data[2];
XDT_PROBE2(XDT_PV_PAGING_FIXUP, rip64, addr64);
break;
case TRC_PV_GDT_LDT_MAPPING_FAULT:
/*
* Descriptor table mapping fault in a 32-bit PV domain.
* data[0] = eip
* data[1] = offset
*/
XDT_PROBE2(XDT_PV_DT_MAPPING_FAULT, data[0], data[1]);
break;
case TRC_PV_GDT_LDT_MAPPING_FAULT | TRC_64_FLAG:
/*
* Descriptor table mapping fault in a 64-bit PV domain.
*
* data[0] = eip(0:31)
* data[1] = eip(31:63)
* data[2] = offset(0:31)
* data[3] = offset(31:63)
*/
rip64 = (((uint64_t)data[1]) << 32) | data[0];
val64 = (((uint64_t)data[3]) << 32) | data[2];
XDT_PROBE2(XDT_PV_DT_MAPPING_FAULT, rip64, val64);
break;
case TRC_PV_PTWR_EMULATION:
case TRC_PV_PTWR_EMULATION_PAE | TRC_64_FLAG:
/*
* Should only happen on 32-bit hypervisor; unused.
*/
break;
case TRC_PV_PTWR_EMULATION_PAE:
/*
* PTE write emulation for a 32-bit PV domain.
*
* data[0] = pte
* data[1] = addr
* data[2] = eip
*/
XDT_PROBE3(XDT_PV_PTWR_EMULATION, data[0], data[1], data[2]);
break;
case TRC_PV_PTWR_EMULATION | TRC_64_FLAG:
/*
* PTE write emulation for a 64-bit PV domain.
*
* data[0] = pte(0:31)
* data[1] = pte(32:63)
* data[2] = addr(0:31)
* data[3] = addr(32:63)
* data[4] = rip(0:31)
* data[5] = rip(32:63)
*/
pte64 = (((uint64_t)data[1]) << 32) | data[0];
addr64 = (((uint64_t)data[3]) << 32) | data[2];
rip64 = (((uint64_t)data[5]) << 32) | data[4];
XDT_PROBE3(XDT_PV_PTWR_EMULATION, pte64, addr64, rip64);
break;
/*
* HVM probes
*/
case TRC_HVM_VMENTRY:
/*
* Return to guest via vmx_launch/vmrun
*
*/
XDT_PROBE0(XDT_HVM_VMENTRY);
break;
case TRC_HVM_VMEXIT:
/*
* Entry into VMEXIT handler from 32-bit HVM domain
*
* data[0] = cpu vendor specific exit code
* data[1] = guest eip
*/
XDT_PROBE2(XDT_HVM_VMEXIT, data[0], data[1]);
break;
case TRC_HVM_VMEXIT64:
/*
* Entry into VMEXIT handler from 64-bit HVM domain
*
* data[0] = cpu vendor specific exit code
* data[1] = guest rip(0:31)
* data[2] = guest rip(32:64)
*/
rip64 = (((uint64_t)data[2]) << 32) | data[1];
XDT_PROBE2(XDT_HVM_VMEXIT, data[0], rip64);
break;
case TRC_HVM_PF_XEN64:
/*
* Pagefault in a guest that is a Xen (e.g. shadow)
* artifact, and is not injected back into the guest.
*
* data[0] = error code
* data[1] = guest VA(0:31)
* data[2] = guest VA(32:64)
*/
addr64 = (((uint64_t)data[2]) << 32) | data[1];
XDT_PROBE2(XDT_HVM_PF_XEN, data[0], addr64);
break;
case TRC_HVM_PF_XEN:
/*
* Same as above, but for a 32-bit HVM domain.
*
* data[0] = error code
* data[1] = guest VA
*/
XDT_PROBE2(XDT_HVM_PF_XEN, data[0], data[1]);
break;
case TRC_HVM_PF_INJECT:
/*
* 32-bit Xen only.
*/
break;
case TRC_HVM_PF_INJECT64:
/*
* Pagefault injected back into a guest (e.g. the shadow
* code found no mapping).
*
* data[0] = error code
* data[1] = guest VA(0:31)
* data[2] = guest VA(32:64)
*/
addr64 = (((uint64_t)data[2]) << 32) | data[1];
XDT_PROBE2(XDT_HVM_PF_INJECT, data[0], addr64);
break;
case TRC_HVM_INJ_EXC:
/*
* Exception injected into an HVM guest.
*
* data[0] = trap
* data[1] = error code
*/
XDT_PROBE2(XDT_HVM_EXC_INJECT, data[0], data[1]);
break;
case TRC_HVM_INJ_VIRQ:
/*
* Interrupt inject into an HVM guest.
*
* data[0] = vector
*/
XDT_PROBE1(XDT_HVM_VIRQ_INJECT, data[0]);
break;
case TRC_HVM_REINJ_VIRQ:
case TRC_HVM_IO_READ:
case TRC_HVM_IO_WRITE:
/* unused */
break;
case TRC_HVM_CR_READ64:
/*
* Control register read. Intel VMX only.
*
* data[0] = control register #
* data[1] = value(0:31)
* data[2] = value(32:63)
*/
val64 = (((uint64_t)data[2]) << 32) | data[1];
XDT_PROBE2(XDT_HVM_CR_READ, data[0], val64);
break;
case TRC_HVM_CR_READ:
/*
* unused (32-bit Xen only)
*/
break;
case TRC_HVM_CR_WRITE64:
/*
* Control register write. Intel VMX only.
*
* data[0] = control register #
* data[1] = value(0:31)
* data[2] = value(32:63)
*/
val64 = (((uint64_t)data[2]) << 32) | data[1];
XDT_PROBE2(XDT_HVM_CR_READ, data[0], val64);
break;
case TRC_HVM_CR_WRITE:
/*
* unused (32-bit Xen only)
*/
break;
case TRC_HVM_DR_READ:
/*
* unused.
*
* data[0] = (domid<<16 + vcpuid)
*/
break;
case TRC_HVM_DR_WRITE:
/*
* Debug register write. Not too useful; no values,
* so we ignore this.
*
* data[0] = (domid<<16 + vcpuid)
*/
break;
case TRC_HVM_MSR_READ:
/*
* MSR read.
*
* data[0] = MSR
* data[1] = value(0:31)
* data[2] = value(32:63)
*/
val64 = (((uint64_t)data[3]) << 32) | data[2];
XDT_PROBE2(XDT_HVM_MSR_READ, data[0], val64);
break;
case TRC_HVM_MSR_WRITE:
/*
* MSR write.
*
* data[0] = MSR;
* data[1] = value(0:31)
* data[2] = value(32:63)
*/
val64 = (((uint64_t)data[2]) << 32) | data[1];
XDT_PROBE2(XDT_HVM_MSR_WRITE, data[0], val64);
break;
case TRC_HVM_CPUID:
/*
* CPUID insn.
*
* data[0] = %eax (input)
* data[1] = %eax
* data[2] = %ebx
* data[3] = %ecx
* data[4] = %edx
*/
XDT_PROBE5(XDT_HVM_CPUID, data[0], data[1], data[2], data[3],
data[4]);
break;
case TRC_HVM_INTR:
/*
* VMEXIT because of an interrupt.
*/
XDT_PROBE0(XDT_HVM_INTR);
break;
case TRC_HVM_INTR_WINDOW:
/*
* VMEXIT because of an interrupt window (an interrupt
* can't be delivered immediately to a HVM guest and must
* be delayed).
*
* data[0] = vector
* data[1] = source
* data[2] = info
*/
XDT_PROBE3(XDT_HVM_INTR_WINDOW, data[0], data[1], data[2]);
break;
case TRC_HVM_NMI:
/*
* VMEXIT because of an NMI.
*/
XDT_PROBE0(XDT_HVM_NMI);
break;
case TRC_HVM_SMI:
/*
* VMEXIT because of an SMI
*/
XDT_PROBE0(XDT_HVM_SMI);
break;
case TRC_HVM_VMMCALL:
/*
* VMMCALL insn.
*
* data[0] = %eax
*/
XDT_PROBE1(XDT_HVM_VMMCALL, data[0]);
break;
case TRC_HVM_HLT:
/*
* HLT insn.
*
* data[0] = 1 if VCPU runnable, 0 if not
*/
XDT_PROBE1(XDT_HVM_HLT, data[0]);
break;
case TRC_HVM_INVLPG64:
/*
*
* data[0] = INVLPGA ? 1 : 0
* data[1] = vaddr(0:31)
* data[2] = vaddr(32:63)
*/
addr64 = (((uint64_t)data[2]) << 32) | data[1];
XDT_PROBE2(XDT_HVM_INVLPG, data[0], addr64);
break;
case TRC_HVM_INVLPG:
/*
* unused (32-bit Xen only)
*
* data[0] = (domid<<16 + vcpuid)
*/
break;
case TRC_HVM_MCE:
/*
* #MCE VMEXIT
*
*/
XDT_PROBE0(XDT_HVM_MCE);
break;
case TRC_HVM_IOPORT_READ:
case TRC_HVM_IOPORT_WRITE:
case TRC_HVM_IOMEM_READ:
case TRC_HVM_IOMEM_WRITE:
/*
* data[0] = addr(0:31)
* data[1] = addr(32:63)
* data[2] = count
* data[3] = size
*/
switch (rec->event) {
case TRC_HVM_IOPORT_READ:
eid = XDT_HVM_IOPORT_READ;
break;
case TRC_HVM_IOPORT_WRITE:
eid = XDT_HVM_IOPORT_WRITE;
break;
case TRC_HVM_IOMEM_READ:
eid = XDT_HVM_IOMEM_READ;
break;
case TRC_HVM_IOMEM_WRITE:
eid = XDT_HVM_IOMEM_WRITE;
break;
}
addr64 = (((uint64_t)data[1]) << 32) | data[0];
XDT_PROBE3(eid, addr64, data[2], data[3]);
break;
case TRC_HVM_CLTS:
/*
* CLTS insn (Intel VMX only)
*/
XDT_PROBE0(XDT_HVM_CLTS);
break;
case TRC_HVM_LMSW64:
/*
* LMSW insn.
*
* data[0] = value(0:31)
* data[1] = value(32:63)
*/
val64 = (((uint64_t)data[1]) << 32) | data[0];
XDT_PROBE1(XDT_HVM_LMSW, val64);
break;
case TRC_HVM_LMSW:
/*
* unused (32-bit Xen only)
*/
break;
/*
* Shadow page table probes (mainly used for HVM domains
* without hardware paging support).
*/
case TRC_SHADOW_NOT_SHADOW | SH_GUEST_32:
/*
* data[0] = pte(0:31)
* data[1] = pte(32:63)
* data[2] = va
* data[3] = flags
*/
pte64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE3(XDT_SHADOW_NOT_SHADOW, pte64, data[2], data[3]);
break;
case TRC_SHADOW_NOT_SHADOW | SH_GUEST_PAE:
case TRC_SHADOW_NOT_SHADOW | SH_GUEST_64:
/*
* data[0] = pte(0:31)
* data[1] = pte(32:63)
* data[2] = va(0:31)
* data[3] = va(32:63)
* data[4] = flags
*/
addr64 = ((uint64_t)data[2] << 32) | data[3];
pte64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE3(XDT_SHADOW_NOT_SHADOW, pte64, addr64, data[4]);
break;
case TRC_SHADOW_FAST_PROPAGATE | SH_GUEST_32:
/*
* data[0] = va
*/
XDT_PROBE1(XDT_SHADOW_FAST_PROPAGATE, data[0]);
break;
case TRC_SHADOW_FAST_PROPAGATE | SH_GUEST_PAE:
case TRC_SHADOW_FAST_PROPAGATE | SH_GUEST_64:
/*
* data[0] = va(0:31)
* data[1] = va(32:63)
*/
addr64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_FAST_PROPAGATE, addr64);
break;
case TRC_SHADOW_FAST_MMIO | SH_GUEST_32:
/*
* data[0] = va
*/
XDT_PROBE1(XDT_SHADOW_FAST_MMIO, data[0]);
break;
case TRC_SHADOW_FAST_MMIO | SH_GUEST_PAE:
case TRC_SHADOW_FAST_MMIO | SH_GUEST_64:
/*
* data[0] = va(0:31)
* data[1] = va(32:63)
*/
addr64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_FAST_MMIO, addr64);
break;
case TRC_SHADOW_FALSE_FAST_PATH | SH_GUEST_32:
/*
* data[0] = va
*/
XDT_PROBE1(XDT_SHADOW_FALSE_FAST_PATH, data[0]);
break;
case TRC_SHADOW_FALSE_FAST_PATH | SH_GUEST_PAE:
case TRC_SHADOW_FALSE_FAST_PATH | SH_GUEST_64:
/*
* data[0] = va(0:31)
* data[1] = va(32:63)
*/
addr64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_FALSE_FAST_PATH, addr64);
break;
case TRC_SHADOW_MMIO | SH_GUEST_32:
/*
* data[0] = va
*/
XDT_PROBE1(XDT_SHADOW_MMIO, data[0]);
break;
case TRC_SHADOW_MMIO | SH_GUEST_PAE:
case TRC_SHADOW_MMIO | SH_GUEST_64:
/*
* data[0] = va(0:31)
* data[1] = va(32:63)
*/
addr64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_MMIO, addr64);
break;
case TRC_SHADOW_FIXUP | SH_GUEST_32:
/*
* data[0] = pte(0:31)
* data[1] = pte(32:63)
* data[2] = va
* data[3] = flags
*/
pte64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE3(XDT_SHADOW_FIXUP, pte64, data[2], data[3]);
break;
case TRC_SHADOW_FIXUP | SH_GUEST_64:
case TRC_SHADOW_FIXUP | SH_GUEST_PAE:
/*
* data[0] = pte(0:31)
* data[1] = pte(32:63)
* data[2] = va(0:31)
* data[3] = va(32:63)
* data[4] = flags
*/
addr64 = ((uint64_t)data[2] << 32) | data[3];
pte64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE3(XDT_SHADOW_FIXUP, pte64, addr64, data[4]);
break;
case TRC_SHADOW_DOMF_DYING | SH_GUEST_32:
/*
* data[0] = va
*/
XDT_PROBE1(XDT_SHADOW_DOMF_DYING, data[0]);
break;
case TRC_SHADOW_DOMF_DYING | SH_GUEST_PAE:
case TRC_SHADOW_DOMF_DYING | SH_GUEST_64:
/*
* data[0] = va(0:31)
* data[1] = va(32:63)
*/
addr64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_DOMF_DYING, addr64);
break;
case TRC_SHADOW_EMULATE | SH_GUEST_32:
/*
* data[0] = pte(0:31)
* data[1] = pte(32:63)
* data[2] = val(0:31)
* data[3] = val(32:63)
* data[4] = addr
* data[5] = flags
*/
pte64 = ((uint64_t)data[1] << 32) | data[0];
val64 = ((uint64_t)data[3] << 32) | data[2];
XDT_PROBE5(XDT_SHADOW_EMULATE, pte64, val64, data[4],
data[5] & 0x7fffffff, data[5] >> 29);
break;
case TRC_SHADOW_EMULATE | SH_GUEST_PAE:
case TRC_SHADOW_EMULATE | SH_GUEST_64:
/*
* data[0] = pte(0:31)
* data[1] = pte(32:63)
* data[2] = val(0:31)
* data[3] = val(32:63)
* data[4] = addr(0:31)
* data[5] = addr(32:63)
* data[6] = flags
*/
pte64 = ((uint64_t)data[1] << 32) | data[0];
val64 = ((uint64_t)data[3] << 32) | data[2];
addr64 = ((uint64_t)data[5] << 32) | data[4];
XDT_PROBE5(XDT_SHADOW_EMULATE, pte64, val64, data[4],
data[6] & 0x7fffffff, data[6] >> 29);
break;
case TRC_SHADOW_EMULATE_UNSHADOW_USER | SH_GUEST_32:
/*
* data[0] = gfn
* data[1] = vaddr
*/
XDT_PROBE2(XDT_SHADOW_EMULATE_UNSHADOW_USER, data[0], data[1]);
break;
case TRC_SHADOW_EMULATE_UNSHADOW_USER | SH_GUEST_PAE:
case TRC_SHADOW_EMULATE_UNSHADOW_USER | SH_GUEST_64:
/*
* data[0] = gfn(0:31)
* data[1] = gfn(32:63)
* data[2] = vaddr(0:31)
* data[3] = vaddr(32:63)
*/
val64 = ((uint64_t)data[1] << 32) | data[0];
addr64 = ((uint64_t)data[3] << 32) | data[2];
XDT_PROBE2(XDT_SHADOW_EMULATE_UNSHADOW_USER, val64, addr64);
break;
case TRC_SHADOW_EMULATE_UNSHADOW_EVTINJ | SH_GUEST_32:
/*
* data[0] = gfn
* data[1] = vaddr
*/
XDT_PROBE2(XDT_SHADOW_EMULATE_UNSHADOW_EVTINJ, data[0],
data[1]);
break;
case TRC_SHADOW_EMULATE_UNSHADOW_EVTINJ | SH_GUEST_PAE:
case TRC_SHADOW_EMULATE_UNSHADOW_EVTINJ | SH_GUEST_64:
/*
* data[0] = gfn(0:31)
* data[1] = gfn(32:63)
* data[2] = vaddr(0:31)
* data[3] = vaddr(32:63)
*/
val64 = ((uint64_t)data[1] << 32) | data[0];
addr64 = ((uint64_t)data[3] << 32) | data[2];
XDT_PROBE2(XDT_SHADOW_EMULATE_UNSHADOW_EVTINJ, val64, addr64);
break;
case TRC_SHADOW_EMULATE_UNSHADOW_UNHANDLED | SH_GUEST_32:
/*
* data[0] = gfn
* data[1] = vaddr
*/
XDT_PROBE2(XDT_SHADOW_EMULATE_UNSHADOW_UNHANDLED, data[0],
data[1]);
break;
case TRC_SHADOW_EMULATE_UNSHADOW_UNHANDLED | SH_GUEST_PAE:
case TRC_SHADOW_EMULATE_UNSHADOW_UNHANDLED | SH_GUEST_64:
/*
* data[0] = gfn(0:31)
* data[1] = gfn(32:63)
* data[2] = vaddr(0:31)
* data[3] = vaddr(32:63)
*/
val64 = ((uint64_t)data[1] << 32) | data[0];
addr64 = ((uint64_t)data[3] << 32) | data[2];
XDT_PROBE2(XDT_SHADOW_EMULATE_UNSHADOW_UNHANDLED, val64,
addr64);
break;
case TRC_SHADOW_WRMAP_BF:
/*
* data[0] = gfn(0:31)
* data[1] = gfn(32:63)
*/
val64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_WRMAP_BF, val64);
break;
case TRC_SHADOW_PREALLOC_UNPIN:
/*
* data[0] = gfn(0:31)
* data[1] = gfn(32:63)
*/
val64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_PREALLOC_UNPIN, val64);
break;
case TRC_SHADOW_RESYNC_FULL:
/*
* data[0] = gmfn(0:31)
* data[1] = gmfn(32:63)
*/
val64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_RESYNC_FULL, val64);
break;
case TRC_SHADOW_RESYNC_ONLY:
/*
* data[0] = gmfn(0:31)
* data[1] = gmfn(32:63)
*/
val64 = ((uint64_t)data[1] << 32) | data[0];
XDT_PROBE1(XDT_SHADOW_RESYNC_ONLY, val64);
break;
/*
* Power management probes.
*/
case TRC_PM_FREQ_CHANGE:
/*
* data[0] = old freq
* data[1] = new freq
*/
XDT_PROBE2(XDT_PM_FREQ_CHANGE, data[0], data[1]);
break;
case TRC_PM_IDLE_ENTRY:
/*
* data[0] = C-state
* data[1] = time
*/
XDT_PROBE2(XDT_PM_IDLE_ENTRY, data[0], data[1]);
break;
case TRC_PM_IDLE_EXIT:
/*
* data[0] = C-state
* data[1] = time
*/
XDT_PROBE2(XDT_PM_IDLE_EXIT, data[0], data[1]);
break;
case TRC_LOST_RECORDS:
vcpu = data[1] >> 16;
dom = data[1] & 0xffff;
xdt_update_sched_context(cpuid, dom, vcpu);
xdt_update_domain_context(dom, vcpu);
XDT_PROBE1(XDT_TRC_LOST_RECORDS, cpuid);
tbuf.stat_dropped_recs++;
break;
default:
tbuf.stat_unknown_recs++;
break;
}
done:
rec_size = 4 + (rec->cycles_included ? 8 : 0) + (rec->extra_u32 * 4);
return (rec_size);
}
/*
* Scan all CPU buffers for the record with the lowest timestamp so
* that the probes will fire in order.
*/
static int
xdt_get_first_rec(uint_t *cpuidp, struct t_rec **recp, uint32_t *consp)
{
uint_t cpuid;
uint32_t prod, cons, offset;
struct t_rec *rec;
uint64_t minstamp = ~0ULL, stamp;
uintptr_t data;
for (cpuid = 0; cpuid < tbuf.cnt; cpuid++) {
cons = tbuf.meta[cpuid]->cons;
prod = tbuf.meta[cpuid]->prod;
membar_consumer();
if (prod == cons)
continue;
offset = cons % tbuf_data_size;
data = (uintptr_t)tbuf.data[cpuid] + offset;
rec = (struct t_rec *)data;
ASSERT((caddr_t)rec < tbuf.va + (tbuf.size * (cpuid + 1)));
/*
* All records that we know about have time cycles included.
* If this record doesn't have them, assume it's a type
* that we don't handle. Use a 0 time value, which will make
* it get handled first (it will be thrown away).
*/
if (rec->cycles_included)
stamp = (((uint64_t)rec->u.cycles.cycles_hi) << 32)
| rec->u.cycles.cycles_lo;
else
stamp = 0;
if (stamp < minstamp) {
minstamp = stamp;
*cpuidp = cpuid;
*recp = rec;
*consp = cons;
}
}
if (minstamp != ~0ULL)
return (1);
return (0);
}
/*ARGSUSED*/
static void
xdt_tbuf_scan(void *arg)
{
uint32_t bytes_done, cons;
struct t_rec *rec;
xdt_schedinfo_t *sp;
uint_t nrecs, cpuid;
for (nrecs = 0;
nrecs < xdt_max_recs && xdt_get_first_rec(&cpuid, &rec, &cons) > 0;
nrecs++) {
xdt_curpcpu = cpuid;
sp = &xdt_cpu_schedinfo[cpuid];
if (sp->curinfo_valid)
xdt_update_domain_context(sp->cur_domid,
sp->cur_vcpuid);
bytes_done = xdt_process_rec(cpuid, rec);
cons += bytes_done;
/*
* cons and prod are incremented modulo (2 * tbuf_data_size).
* See <xen/public/trace.h>.
*/
if (cons >= 2 * tbuf_data_size)
cons -= 2 * tbuf_data_size;
membar_exit();
tbuf.meta[cpuid]->cons = cons;
}
}
static void
xdt_cyclic_enable(void)
{
cyc_handler_t hdlr;
cyc_time_t when;
ASSERT(MUTEX_HELD(&cpu_lock));
hdlr.cyh_func = xdt_tbuf_scan;
hdlr.cyh_arg = NULL;
hdlr.cyh_level = CY_LOW_LEVEL;
when.cyt_interval = xdt_poll_nsec;
when.cyt_when = dtrace_gethrtime() + when.cyt_interval;
xdt_cyclic = cyclic_add(&hdlr, &when);
}
static void
xdt_probe_create(xdt_probe_t *p)
{
ASSERT(p != NULL && p->pr_mod != NULL);
if (dtrace_probe_lookup(xdt_id, p->pr_mod, NULL, p->pr_name) != 0)
return;
xdt_prid[p->evt_id] = dtrace_probe_create(xdt_id, p->pr_mod, NULL,
p->pr_name, dtrace_mach_aframes(), p);
}
/*ARGSUSED*/
static void
xdt_provide(void *arg, const dtrace_probedesc_t *desc)
{
const char *mod, *name;
int i;
if (desc == NULL) {
for (i = 0; xdt_probe[i].pr_mod != NULL; i++) {
xdt_probe_create(&xdt_probe[i]);
}
} else {
mod = desc->dtpd_mod;
name = desc->dtpd_name;
for (i = 0; xdt_probe[i].pr_mod != NULL; i++) {
int l1 = strlen(xdt_probe[i].pr_name);
int l2 = strlen(xdt_probe[i].pr_mod);
if (strncmp(name, xdt_probe[i].pr_name, l1) == 0 &&
strncmp(mod, xdt_probe[i].pr_mod, l2) == 0)
break;
}
if (xdt_probe[i].pr_mod == NULL)
return;
xdt_probe_create(&xdt_probe[i]);
}
}
/*ARGSUSED*/
static void
xdt_destroy(void *arg, dtrace_id_t id, void *parg)
{
xdt_probe_t *p = parg;
xdt_prid[p->evt_id] = 0;
}
static void
xdt_set_trace_mask(uint32_t mask)
{
xen_sysctl_tbuf_op_t tbuf_op;
/* Always need to trace scheduling, for context */
if (mask != 0)
mask |= TRC_SCHED;
tbuf_op.evt_mask = mask;
tbuf_op.cmd = XEN_SYSCTL_TBUFOP_set_evt_mask;
(void) xdt_sysctl_tbuf(&tbuf_op);
}
/*ARGSUSED*/
static int
xdt_enable(void *arg, dtrace_id_t id, void *parg)
{
xdt_probe_t *p = parg;
xen_sysctl_tbuf_op_t tbuf_op;
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(xdt_prid[p->evt_id] != 0);
xdt_probemap[p->evt_id] = xdt_prid[p->evt_id];
xdt_classinfo[p->class].cnt++;
if (xdt_classinfo[p->class].cnt == 1) {
/* set the trace mask for this class */
cur_trace_mask |= xdt_classinfo[p->class].trc_mask;
xdt_set_trace_mask(cur_trace_mask);
}
if (xdt_cyclic == CYCLIC_NONE) {
tbuf_op.cmd = XEN_SYSCTL_TBUFOP_enable;
if (xdt_sysctl_tbuf(&tbuf_op) != 0) {
cmn_err(CE_NOTE, "Couldn't enable hypervisor tracing.");
return (-1);
}
xdt_cyclic_enable();
}
return (0);
}
/*ARGSUSED*/
static void
xdt_disable(void *arg, dtrace_id_t id, void *parg)
{
xdt_probe_t *p = parg;
xen_sysctl_tbuf_op_t tbuf_op;
int i, err;
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(xdt_probemap[p->evt_id] != 0);
ASSERT(xdt_probemap[p->evt_id] == xdt_prid[p->evt_id]);
ASSERT(xdt_classinfo[p->class].cnt > 0);
/*
* We could be here in the slight window between the cyclic firing and
* a call to dtrace_probe() occurring. We need to be careful if we tear
* down any shared state.
*/
xdt_probemap[p->evt_id] = 0;
xdt_classinfo[p->class].cnt--;
if (xdt_nr_active_probes() == 0) {
cur_trace_mask = 0;
if (xdt_cyclic == CYCLIC_NONE)
return;
for (i = 0; i < xdt_ncpus; i++)
xdt_cpu_schedinfo[i].curinfo_valid = 0;
/*
* We will try to disable the trace buffers. If we fail for some
* reason we will try again, up to a count of XDT_TBUF_RETRY.
* If we still aren't successful we try to set the trace mask
* to 0 in order to prevent trace records from being written.
*/
tbuf_op.cmd = XEN_SYSCTL_TBUFOP_disable;
i = 0;
do {
err = xdt_sysctl_tbuf(&tbuf_op);
} while ((err != 0) && (++i < XDT_TBUF_RETRY));
if (err != 0) {
cmn_err(CE_NOTE,
"Couldn't disable hypervisor tracing.");
xdt_set_trace_mask(0);
} else {
cyclic_remove(xdt_cyclic);
xdt_cyclic = CYCLIC_NONE;
/*
* We don't bother making the hypercall to set
* the trace mask, since it will be reset when
* tracing is re-enabled.
*/
}
} else if (xdt_classinfo[p->class].cnt == 0) {
cur_trace_mask ^= xdt_classinfo[p->class].trc_mask;
/* other probes are enabled, so add the sub-class mask back */
cur_trace_mask |= 0xF000;
xdt_set_trace_mask(cur_trace_mask);
}
}
static dtrace_pattr_t xdt_attr = {
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_PLATFORM },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_PLATFORM },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_PLATFORM },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_PLATFORM },
};
static dtrace_pops_t xdt_pops = {
xdt_provide, /* dtps_provide() */
NULL, /* dtps_provide_module() */
xdt_enable, /* dtps_enable() */
xdt_disable, /* dtps_disable() */
NULL, /* dtps_suspend() */
NULL, /* dtps_resume() */
NULL, /* dtps_getargdesc() */
NULL, /* dtps_getargval() */
NULL, /* dtps_usermode() */
xdt_destroy /* dtps_destroy() */
};
static int
xdt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int val;
if (!DOMAIN_IS_INITDOMAIN(xen_info))
return (DDI_FAILURE);
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
/*
* We might support proper suspend/resume in the future, so,
* return DDI_FAILURE for now.
*/
return (DDI_FAILURE);
default:
return (DDI_FAILURE);
}
xdt_ncpus = xpv_nr_phys_cpus();
ASSERT(xdt_ncpus > 0);
if (ddi_create_minor_node(devi, "xdt", S_IFCHR, 0, DDI_PSEUDO, 0) ==
DDI_FAILURE || xdt_attach_trace_buffers() != 0 ||
dtrace_register("xdt", &xdt_attr, DTRACE_PRIV_KERNEL, NULL,
&xdt_pops, NULL, &xdt_id) != 0) {
if (tbuf.va != NULL)
xdt_detach_trace_buffers();
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
val = ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
"xdt_poll_nsec", XDT_POLL_DEFAULT);
xdt_poll_nsec = MAX(val, XDT_POLL_MIN);
xdt_cpu_schedinfo = (xdt_schedinfo_t *)kmem_zalloc(xdt_ncpus *
sizeof (xdt_schedinfo_t), KM_SLEEP);
xdt_init_trace_masks();
xdt_kstat_init();
xdt_devi = devi;
ddi_report_dev(devi);
return (DDI_SUCCESS);
}
static int
xdt_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
switch (cmd) {
case DDI_DETACH:
break;
case DDI_SUSPEND:
/*
* We might support proper suspend/resume in the future. So
* return DDI_FAILURE for now.
*/
return (DDI_FAILURE);
default:
return (DDI_FAILURE);
}
if (dtrace_unregister(xdt_id) != 0)
return (DDI_FAILURE);
xdt_detach_trace_buffers();
kmem_free(xdt_cpu_schedinfo, xdt_ncpus * sizeof (xdt_schedinfo_t));
if (xdt_cyclic != CYCLIC_NONE)
cyclic_remove(xdt_cyclic);
if (xdt_kstats != NULL)
kstat_delete(xdt_kstats);
xdt_devi = (void *)0;
ddi_remove_minor_node(devi, NULL);
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
xdt_info(dev_info_t *devi, ddi_info_cmd_t infocmd, void *arg, void **result)
{
int error;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
*result = xdt_devi;
error = DDI_SUCCESS;
break;
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)0;
error = DDI_SUCCESS;
break;
default:
error = DDI_FAILURE;
}
return (error);
}
static struct cb_ops xdt_cb_ops = {
nulldev, /* open(9E) */
nodev, /* close(9E) */
nodev, /* strategy(9E) */
nodev, /* print(9E) */
nodev, /* dump(9E) */
nodev, /* read(9E) */
nodev, /* write(9E) */
nodev, /* ioctl(9E) */
nodev, /* devmap(9E) */
nodev, /* mmap(9E) */
nodev, /* segmap(9E) */
nochpoll, /* chpoll(9E) */
ddi_prop_op, /* prop_op(9E) */
NULL, /* streamtab(9S) */
D_MP | D_64BIT | D_NEW /* cb_flag */
};
static struct dev_ops xdt_ops = {
DEVO_REV, /* devo_rev */
0, /* devo_refcnt */
xdt_info, /* getinfo(9E) */
nulldev, /* identify(9E) */
nulldev, /* probe(9E) */
xdt_attach, /* attach(9E) */
xdt_detach, /* detach(9E) */
nulldev, /* devo_reset */
&xdt_cb_ops, /* devo_cb_ops */
NULL, /* devo_bus_ops */
NULL, /* power(9E) */
ddi_quiesce_not_needed, /* devo_quiesce */
};
static struct modldrv modldrv = {
&mod_driverops,
"Hypervisor event tracing",
&xdt_ops
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
NULL
};
int
_init(void)
{
return (mod_install(&modlinkage));
}
int
_fini(void)
{
return (mod_remove(&modlinkage));
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
| 25.679029
| 80
| 0.649323
|
[
"vector",
"model"
] |
b26e9c2c0db610b5af8b008cdb6f2d1478570cb9
| 833
|
h
|
C
|
include/utils/DirectoryReader.h
|
dom380/IMAT3606-Coursework-2
|
36f50b25823cd3170a403a2e2ef50e3019fcd73b
|
[
"FTL",
"Zlib",
"Apache-2.0",
"MIT"
] | null | null | null |
include/utils/DirectoryReader.h
|
dom380/IMAT3606-Coursework-2
|
36f50b25823cd3170a403a2e2ef50e3019fcd73b
|
[
"FTL",
"Zlib",
"Apache-2.0",
"MIT"
] | null | null | null |
include/utils/DirectoryReader.h
|
dom380/IMAT3606-Coursework-2
|
36f50b25823cd3170a403a2e2ef50e3019fcd73b
|
[
"FTL",
"Zlib",
"Apache-2.0",
"MIT"
] | null | null | null |
#pragma once
#ifndef DIRECTORYREADER_H
#define DIRECTORYREADER_H
#include <vector>
using std::vector;
/*
Utility class to parse Directories.
*/
class DirectoryReader
{
public:
/*
Allows you to get a vector of strings for files in a directory
USAGE: getFilesInDirectory("./path/*.obj");
RETURNS: all objs in directory path.
*/
static vector<std::string> getFilesInDirectory(const char* path);
/*
Returns the current working directory as a full path.
See asset manager for relative path.
*/
static std::string getCurrentDirectory();
/*
Uses getCurrentDirectory and prints it.
*/
static void printCurrentDirectory();
/*
Prints items in a directory.
USAGE: printDirectory("./path/*.obj");
PRINTS: all objs in directory path.
*/
static void printDirectory(const char* path);
};
#endif // !DIRECTORYREADER_H
| 23.138889
| 66
| 0.733493
|
[
"vector"
] |
b27ada0fafc567e817df0dfa8b5741ee8add9b09
| 332
|
h
|
C
|
Engine/Source/Runtime/CoreUObject/Public/UObject/UObject.h
|
windystrife/UnrealEngine_NVIDIAGameWork
|
b50e6338a7c5b26374d66306ebc7807541ff815e
|
[
"MIT"
] | 1
|
2022-01-29T18:36:12.000Z
|
2022-01-29T18:36:12.000Z
|
Engine/Source/Runtime/CoreUObject/Public/UObject/UObject.h
|
windystrife/UnrealEngine_NVIDIAGameWork
|
b50e6338a7c5b26374d66306ebc7807541ff815e
|
[
"MIT"
] | null | null | null |
Engine/Source/Runtime/CoreUObject/Public/UObject/UObject.h
|
windystrife/UnrealEngine_NVIDIAGameWork
|
b50e6338a7c5b26374d66306ebc7807541ff815e
|
[
"MIT"
] | null | null | null |
// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "Object.h"
DEPRECATED(4.14, "Including UObject.h has been deprecated. Please include Object.h instead.")
inline void UObjectHeaderDeprecatedWarning()
{
}
inline void TriggerUObjectHeaderDeprecatedWarning()
{
UObjectHeaderDeprecatedWarning();
}
| 20.75
| 93
| 0.786145
|
[
"object"
] |
b2822f1f3f5c74d0c284e32456b83430c45e2bd5
| 6,109
|
h
|
C
|
Source/NXL2019_luciano/RuntimeMeshes/RT_JerseyBarrier.h
|
TheTarrasque/UnrealEngine-Paintball
|
e289bbc109c0b6f33af47f65b59f300eba8b02d9
|
[
"MIT"
] | null | null | null |
Source/NXL2019_luciano/RuntimeMeshes/RT_JerseyBarrier.h
|
TheTarrasque/UnrealEngine-Paintball
|
e289bbc109c0b6f33af47f65b59f300eba8b02d9
|
[
"MIT"
] | null | null | null |
Source/NXL2019_luciano/RuntimeMeshes/RT_JerseyBarrier.h
|
TheTarrasque/UnrealEngine-Paintball
|
e289bbc109c0b6f33af47f65b59f300eba8b02d9
|
[
"MIT"
] | null | null | null |
/*
Author: Devan Luciano
Inspiration Sources:
Author Unknown: https://wiki.unrealengine.com/index.php?title=Procedural_Mesh_Component_in_C%2B%2B:Getting_Started
SiggiG: https://github.com/SiggiG/ProceduralMeshes
Koderz: https://github.com/Koderz/RuntimeMeshComponent
Class Purpose:
The JerseyBarrier will be used to seperate the game play area. Providing obsticles the players have to go around and will provide
the players with cover from one another
Primary methods/properties:
JerseyBarrierHeight: A property that when set in the editor will trigger the generate method and will determine the wall's height
AddTriangleMesh: Will take three vectors and a Tangent (STILL NEED TO KNOW THE FORMULA For tangents!!) and will apply a mesh accordingly.
AddQuadMesh: Will take Four vectors and a Tangent (STILL NEED TO KNOW THE FORMULA For tangents!!) and will apply a mesh accordingly.
PostEditChangeProperty: Method that is triggered when a property of this actor is changed in the editor. If it is a key property then a method will be triggered
Additional Notes: I made an active effort to learn from the inspirational sources and not to copy their code. I wanted to make sure I truly understood the process
and am able to leave being able to take on the next bigger challenges. I also noticed that for the most part in these basic examples they hard coded all of it and did
not use methods like I decided to. I am sure it is because for basic shapes, it is actually less lines of code to just hard code it, even with the redundant lines.
However, I knew I wanted something scalable. Something that would allow me to create complete shapes that might have a real dynamic aspect to them.
02/03/2019: I made the decision to make these components the walls and obsticle in the game. They will still changed colors dynamically at run time, but the height
controls are more a level designer option now version an ingame gimic
Final Project Rubric elements:
Objects and Actors:
Key Properties - The Jerseybarrier height is a property that can be set from with the editor by the design team.
also there are a few other properties that can be changed/set in the editor (MaterialA, MaterialB, and DynamicMaterialInstance)
Visual Characteristics - The output of this class is an object that represents a typical jersey barrier.
Mathematical APIs - Adjusting the Jerseybarrier height property will dynamically change the actors height in the editor. Testing has
has also showed this to work at run time as well. I depreticated that feature though.
Lighting Functions- I am not quite sure what this is looking for, but my best guess says I did it.
2D Texture and Shader properties:
Basic Material- The base material is set in the editor as MaterialA, The MaterialB is designed to be the team's color and will indicate when
a player is taking cover up against a JB.
Physical Characteristics - Not sure what this is looking for, hope I did it.
Shaders - This shader/material does not use math to alter color, but could've. I just didn't want to back track from what I had done. I believe I covered this in another actor.
Shader Techniques or Macros - This actor uses a macro to trigger the runtime and editor property changes.
Commented Code File:
3D Object - I believe this is handled on line 138 of the source file.
2D Texture and Material - This is done in the source file on lines 141, 230, and 239
Shader Technique - This actor is a basic barrier and therefore using a simple color material/shader and applying it to the object with no special specifications was the best method to use
*/
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "RuntimeMeshComponent.h"
#include "RT_JerseyBarrier.generated.h"
UCLASS()
class NXL2019_LUCIANO_API ART_JerseyBarrier : public AActor
{
GENERATED_BODY()
public:
// Sets default values for this actor's properties
ART_JerseyBarrier();
virtual void PostInitializeComponents() override;
// the default radius is set to 50 but can be adjusted in the editor as well
//UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Parameters")
FVector ShapeRadius = FVector(100, 100.f, 100.f);
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh parameters", meta = (ClampMin = "100.0", ClampMax = "1000.0", UIClampMin = "100.0", UIClampMax = "1000.0"))
float JerseyBarrierHeight= 100.f;
// Where I don t set a default material it can be set within the editor
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Parameters")
UMaterialInterface* MaterialA;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Parameters")
UMaterialInterface* MaterialB;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Parameters")
UMaterialInstanceDynamic* DynamicMaterialInstance;
#if WITH_EDITOR
virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif //WITH_EDITOR
protected:
UPROPERTY(VisibleAnywhere)
USceneComponent* ThisScene;
UPROPERTY(VisibleAnywhere)
URuntimeMeshComponent* ThisMesh;
UPROPERTY(VisibleAnywhere)
UBoxComponent* ThisCollision;
virtual void PostActorCreated() override;
virtual void PostLoad() override;
void GenerateMesh();
private:
TArray<FVector> Vertices;
TArray<int32> Triangles;
TArray<FVector> Normals;
TArray<FRuntimeMeshTangent> Tangents;
TArray<FVector2D> UVs;
TArray<FColor> Colors;
void AddQuadMesh(FVector TopLeft, FVector BottomLeft, FVector TopRight, FVector BottomRight, int32& TriIndex);//when you don t know the normals or tangents, wing it
void AddQuadMesh(FVector TopLeft, FVector BottomLeft, FVector TopRight, FVector BottomRight, int32& TriIndex, FRuntimeMeshTangent Tangent);
void AddTriangleMesh(FVector Point1, FVector Point2, FVector Point, int32& TriIndex, FRuntimeMeshTangent Tangent);
void AddTriangle(int32 P1, int32 p2, int32 p3);
void AddTriangle(int32 A, int32 B, int32 C, int32 D);
virtual void NotifyActorBeginOverlap(AActor* OtherActor);
virtual void NotifyActorEndOverlap(AActor* OtherActor);
};
| 48.484127
| 189
| 0.788345
|
[
"mesh",
"object",
"3d"
] |
b289cbc5bfc6f9b79c3206733d9c1919d297af7d
| 3,861
|
h
|
C
|
HTTPServer.h
|
kytvi2p/i2pd
|
73d402525636276ac78aa92ea88535911e21928c
|
[
"BSD-3-Clause"
] | 4
|
2015-09-28T16:01:55.000Z
|
2021-04-08T19:26:50.000Z
|
HTTPServer.h
|
kytvi2p/i2pd
|
73d402525636276ac78aa92ea88535911e21928c
|
[
"BSD-3-Clause"
] | null | null | null |
HTTPServer.h
|
kytvi2p/i2pd
|
73d402525636276ac78aa92ea88535911e21928c
|
[
"BSD-3-Clause"
] | null | null | null |
#ifndef HTTP_SERVER_H__
#define HTTP_SERVER_H__
#include <sstream>
#include <thread>
#include <memory>
#include <boost/asio.hpp>
#include <boost/array.hpp>
#include "LeaseSet.h"
#include "Streaming.h"
namespace i2p
{
namespace util
{
const size_t HTTP_CONNECTION_BUFFER_SIZE = 8192;
const int HTTP_DESTINATION_REQUEST_TIMEOUT = 10; // in seconds
class HTTPConnection: public std::enable_shared_from_this<HTTPConnection>
{
protected:
struct header
{
std::string name;
std::string value;
};
struct request
{
std::string method;
std::string uri;
std::string host;
int port;
int http_version_major;
int http_version_minor;
std::vector<header> headers;
};
struct reply
{
std::vector<header> headers;
std::string content;
std::vector<boost::asio::const_buffer> to_buffers (int status);
};
public:
HTTPConnection (boost::asio::ip::tcp::socket * socket):
m_Socket (socket), m_Timer (socket->get_io_service ()),
m_Stream (nullptr), m_BufferLen (0) {};
~HTTPConnection() { delete m_Socket; }
void Receive ();
private:
void Terminate ();
void HandleReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred);
void AsyncStreamReceive ();
void HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred);
void HandleWriteReply(const boost::system::error_code& ecode);
void HandleWrite (const boost::system::error_code& ecode);
void SendReply (const std::string& content, int status = 200);
void HandleRequest (const std::string& address);
void HandleCommand (const std::string& command, std::stringstream& s);
void ShowTransports (std::stringstream& s);
void ShowTunnels (std::stringstream& s);
void ShowTransitTunnels (std::stringstream& s);
void ShowLocalDestinations (std::stringstream& s);
void ShowLocalDestination (const std::string& b32, std::stringstream& s);
void ShowSAMSessions (std::stringstream& s);
void ShowSAMSession (const std::string& id, std::stringstream& s);
void StartAcceptingTunnels (std::stringstream& s);
void StopAcceptingTunnels (std::stringstream& s);
void FillContent (std::stringstream& s);
std::string ExtractAddress ();
void ExtractParams (const std::string& str, std::map<std::string, std::string>& params);
protected:
boost::asio::ip::tcp::socket * m_Socket;
boost::asio::deadline_timer m_Timer;
std::shared_ptr<i2p::stream::Stream> m_Stream;
char m_Buffer[HTTP_CONNECTION_BUFFER_SIZE + 1], m_StreamBuffer[HTTP_CONNECTION_BUFFER_SIZE + 1];
size_t m_BufferLen;
request m_Request;
reply m_Reply;
protected:
virtual void RunRequest ();
void HandleDestinationRequest(const std::string& address, const std::string& uri);
void SendToAddress (const std::string& address, int port, const char * buf, size_t len);
void HandleDestinationRequestTimeout (const boost::system::error_code& ecode,
i2p::data::IdentHash destination, int port, const char * buf, size_t len);
void SendToDestination (std::shared_ptr<const i2p::data::LeaseSet> remote, int port, const char * buf, size_t len);
public:
static const std::string itoopieImage;
static const std::string itoopieFavicon;
};
class HTTPServer
{
public:
HTTPServer (int port);
virtual ~HTTPServer ();
void Start ();
void Stop ();
private:
void Run ();
void Accept ();
void HandleAccept(const boost::system::error_code& ecode);
private:
std::thread * m_Thread;
boost::asio::io_service m_Service;
boost::asio::io_service::work m_Work;
boost::asio::ip::tcp::acceptor m_Acceptor;
boost::asio::ip::tcp::socket * m_NewSocket;
protected:
virtual void CreateConnection(boost::asio::ip::tcp::socket * m_NewSocket);
};
}
}
#endif
| 27.776978
| 118
| 0.701373
|
[
"vector"
] |
b299105181fe1520f12aca5f08050082493828c7
| 2,320
|
h
|
C
|
src/geometry.h
|
dajones42/rmsim
|
3cfdd1e5ade0677cc83a05c86a2f62f77d5fb23e
|
[
"MIT"
] | null | null | null |
src/geometry.h
|
dajones42/rmsim
|
3cfdd1e5ade0677cc83a05c86a2f62f77d5fb23e
|
[
"MIT"
] | null | null | null |
src/geometry.h
|
dajones42/rmsim
|
3cfdd1e5ade0677cc83a05c86a2f62f77d5fb23e
|
[
"MIT"
] | null | null | null |
// misc functions for geometric calculation
//
/*
Copyright © 2021 Doug Jones
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#ifndef GEOMETRY_H
#define GEOMETRY_H
// finds the point of intersection between two line sements
char segSegInt(double* p11, double* p12, double* p21, double* p22, double* p,
double* sp=NULL, double* tp=NULL);
// finds the point of intersection between two line sements
float segAxisInt(float x1, float y1, float x2, float y2, float x);
// returns the signed area of a triangle
// positive if the points are listed in clockwise order
double triArea(double x1, double y1, double x2, double y2,
double x3, double y3);
// returns square of distance between a point and line in 2D
double lineSegDistSq(double x, double y, double x1, double y1,
double x2, double y2);
// returns square of distance between a point and line in 3D
double lineSegDistSq(double x, double y, double z,
double x1, double y1, double z1, double x2, double y2, double z2);
// returns the signed area of a triangle
inline double triArea(const double* p1, const double* p2, const double* p3)
{
return triArea(p1[0],p1[1],p2[0],p2[1],p3[0],p3[1]);
}
// returns an estimated square root
// uses a single interation of newtons method
inline float sqrtIter(float est, float sq)
{
return est<=0 ? sqrt(sq) : .5*(est+sq/est);
}
#endif
| 38.032787
| 77
| 0.763793
|
[
"3d"
] |
b299f4c4b1e814d793ced423cc8d5103ca9d9554
| 4,434
|
h
|
C
|
mindspore/ccsrc/backend/optimizer/mem_reuse/mem_copy_manager.h
|
dongkcs/mindspore
|
cd7df6dbf463ff3128e9181e9d0c779cecb81320
|
[
"Apache-2.0"
] | 2
|
2020-08-12T16:14:40.000Z
|
2020-12-04T03:05:57.000Z
|
mindspore/ccsrc/backend/optimizer/mem_reuse/mem_copy_manager.h
|
dilingsong/mindspore
|
4276050f2494cfbf8682560a1647576f859991e8
|
[
"Apache-2.0"
] | 1
|
2020-12-29T06:46:38.000Z
|
2020-12-29T06:46:38.000Z
|
mindspore/ccsrc/backend/optimizer/mem_reuse/mem_copy_manager.h
|
dilingsong/mindspore
|
4276050f2494cfbf8682560a1647576f859991e8
|
[
"Apache-2.0"
] | 1
|
2021-05-12T06:30:29.000Z
|
2021-05-12T06:30:29.000Z
|
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* 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
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINDSPORE_CCSRC_BACKEND_OPTIMIZER_MEM_REUSE_MEM_COPY_MANAGER_H_
#define MINDSPORE_CCSRC_BACKEND_OPTIMIZER_MEM_REUSE_MEM_COPY_MANAGER_H_
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <memory>
#include <utility>
#include "backend/session/kernel_graph.h"
#include "backend/kernel_compiler/kernel.h"
using HostAddress = mindspore::kernel::Address;
namespace mindspore {
namespace device {
namespace memswap {
enum class SwapKind { kDeviceToHost = 0, kHostToDevice = 1 };
struct TensorInfo {
size_t tensor_size_{0};
AnfNodePtr kernel_{nullptr};
size_t output_idx_{0};
};
struct KernelExecutionInfo {
size_t topo_order_{0};
float execution_perform_{0.0};
bool trigger_swap_out_{false};
bool trigger_swap_in_{false};
size_t swap_in_task_num_{0};
// Key: output index, value: topo orders of node users
std::map<size_t, std::vector<size_t>> node_users_map_;
// Key: output index, value: pair (host addr, dirty or not)
std::map<size_t, std::pair<HostAddress, bool>> host_addrs_;
KernelExecutionInfo() {}
explicit KernelExecutionInfo(size_t topo_order) : KernelExecutionInfo(topo_order, 0.0, false, false, 0) {}
KernelExecutionInfo(size_t topo_order, float execution_perform, bool trigger_swap_out, bool trigger_swap_in,
size_t swap_in_task_num)
: topo_order_(topo_order),
execution_perform_(execution_perform),
trigger_swap_out_(trigger_swap_out),
trigger_swap_in_(trigger_swap_in),
swap_in_task_num_(swap_in_task_num) {}
};
struct MemSwapInfo {
SwapKind swap_kind_;
// Topo order of kernel need be swapped
size_t topo_order_;
size_t output_idx_{0};
// Record the swapping out position of swapping in tensor
size_t swap_out_pos_;
};
struct SwapInfoComp {
bool operator()(const MemSwapInfo &a, const MemSwapInfo &b) {
int swap_kind_a = static_cast<int>(a.swap_kind_);
int swap_kind_b = static_cast<int>(b.swap_kind_);
if (swap_kind_a < swap_kind_b) {
return true;
} else if (swap_kind_a > swap_kind_b) {
return false;
}
if (a.swap_out_pos_ < b.swap_out_pos_) {
return true;
} else if (a.swap_out_pos_ > b.swap_out_pos_) {
return false;
}
if (a.topo_order_ < b.topo_order_) {
return true;
} else if (a.topo_order_ > b.topo_order_) {
return false;
}
return a.output_idx_ < b.output_idx_;
}
};
class MemCopyManager {
public:
MemCopyManager() = default;
virtual ~MemCopyManager() = default;
virtual void Init() {}
virtual void AddMemSwapOutTask(const DeviceAddressPtr &device_address, const HostAddress &host_addr) {}
virtual void AddMemSwapInTask(const DeviceAddressPtr &device_address, const HostAddress &host_addr, bool profiling,
float *cost_time) {}
virtual void AddMemSwapOutTaskMock(const DeviceAddressPtr &device_address) {}
virtual void AddMemSwapInTaskMock(const DeviceAddressPtr &device_address) {}
virtual bool SyncMemCopyStream(SwapKind swap_kind) { return true; }
virtual DeviceAddressPtr UpdateSwapOutQueue() { return nullptr; }
virtual DeviceAddressPtr UpdateSwapInQueue() { return nullptr; }
virtual DeviceAddressPtr UpdateSwapOutQueueMock() { return nullptr; }
virtual DeviceAddressPtr UpdateSwapInQueueMock() { return nullptr; }
virtual bool AllocHostPinnedMem(size_t size, void **addr) const { return true; }
virtual void FreeHostPinnedMem(void *addr) const {}
virtual void ClearSwapQueue() {}
virtual void ClearSwapQueueMock() {}
};
using MemCopyManagerPtr = std::shared_ptr<MemCopyManager>;
using MemSwapInfoSet = std::set<MemSwapInfo, SwapInfoComp>;
} // namespace memswap
} // namespace device
} // namespace mindspore
#endif // MINDSPORE_CCSRC_BACKEND_OPTIMIZER_MEM_REUSE_MEM_COPY_MANAGER_H_
| 31.671429
| 117
| 0.737709
|
[
"vector"
] |
b29d692fbd39141b752986358463522f7cbec3a1
| 7,176
|
c
|
C
|
software/elf-loader/vpi_wrapper.c
|
QueenField/PU-WB-OR1K
|
5d04f13681a955540dbfb7d376f13c808c718b63
|
[
"MIT"
] | 3
|
2020-02-10T21:32:30.000Z
|
2021-06-25T03:51:52.000Z
|
software/elf-loader/vpi_wrapper.c
|
QueenField/PU-WB-OR1K
|
5d04f13681a955540dbfb7d376f13c808c718b63
|
[
"MIT"
] | null | null | null |
software/elf-loader/vpi_wrapper.c
|
QueenField/PU-WB-OR1K
|
5d04f13681a955540dbfb7d376f13c808c718b63
|
[
"MIT"
] | 2
|
2020-06-11T00:56:36.000Z
|
2021-06-25T03:51:53.000Z
|
/*
* VPI wrapper for elf-loader
*
* Copyright (C) 2015 Olof Kindgren <[email protected]>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <stdlib.h>
#include <ctype.h>
#include <vpi_user.h>
#include "elf-loader.h"
//install a callback on simulation reset which calls setup
void setup_reset_callbacks(void);
//install a callback on simulation compilation finish
void setup_endofcompile_callbacks(void);
//install a callback on simulation finish
void setup_finish_callbacks(void);
//callback function which closes and clears the socket file descriptors
// on simulation reset
void sim_reset_callback(void);
void sim_endofcompile_callback(void);
void sim_finish_callback(void);
uint8_t *bin_file;
int size;
void elf_load_file(void) {
vpiHandle func_h, args_iter, arg_h;
struct t_vpi_value argval;
char *elf_file_name;
func_h = vpi_handle(vpiSysTfCall, NULL);
args_iter = vpi_iterate(vpiArgument, func_h);
if(!bin_file) {
arg_h = vpi_scan(args_iter);
argval.format = vpiStringVal;
vpi_get_value(arg_h, &argval);
elf_file_name = argval.value.str;
while(isspace(*elf_file_name))
elf_file_name++;
bin_file = load_elf_file(elf_file_name, &size);
if(bin_file)
vpi_printf("elf-loader: %s was loaded\n", elf_file_name);
else
vpi_printf("Error: Failed to load elf file from \"%s\"\n", elf_file_name);
}
//vpi_printf("elf_load_file done\n");
}
void elf_get_size(void) {
vpiHandle func_h;
struct t_vpi_value argval;
if(!bin_file) {
vpi_printf("Error: $elf_load_file must be called first\n");
return;
}
func_h = vpi_handle(vpiSysTfCall, NULL);
argval.format = vpiIntVal;
argval.value.integer = size;
vpi_put_value(func_h, &argval, NULL, vpiNoDelay);
//vpi_printf("elf_get_size done\n");
}
void elf_read_32(void) {
vpiHandle func_h, arg_h, args_iter;
struct t_vpi_value argval;
unsigned int address;
unsigned int data;
//vpi_printf("elf_read_32 start\n");
if(!bin_file) {
vpi_printf("Error: $elf_load_file must be called first\n");
return;
}
func_h = vpi_handle(vpiSysTfCall, NULL);
args_iter = vpi_iterate(vpiArgument, func_h);
// Grab the value of the first argument
arg_h = vpi_scan(args_iter);
argval.format = vpiIntVal;
vpi_get_value(arg_h, &argval);
address = argval.value.integer;
data = read_32(bin_file, address);
argval.value.integer = data;
vpi_put_value(func_h, &argval, NULL, vpiNoDelay);
vpi_free_object(args_iter);
//vpi_printf("elf_read_32 done\n");
}
void elf_read_16(void) {
vpiHandle func_h, arg_h, args_iter;
struct t_vpi_value argval;
unsigned int address;
unsigned short data;
if(!bin_file) {
vpi_printf("Error: $elf_load_file must be called first\n");
return;
}
func_h = vpi_handle(vpiSysTfCall, NULL);
args_iter = vpi_iterate(vpiArgument, func_h);
// Grab the value of the first argument
arg_h = vpi_scan(args_iter);
argval.format = vpiIntVal;
vpi_get_value(arg_h, &argval);
address = argval.value.integer;
data = read_16(bin_file, address);
argval.value.integer = data;
vpi_put_value(func_h, &argval, NULL, vpiNoDelay);
vpi_free_object(args_iter);
//vpi_printf("elf_read_16 done\n");
}
void setup_user_functions(void) {
s_vpi_systf_data task_data_s;
p_vpi_systf_data task_data_p = &task_data_s;
task_data_p->type = vpiSysTask;
task_data_p->sysfunctype = vpiIntFunc;
task_data_p->tfname = "$elf_load_file";
task_data_p->calltf = (void *)elf_load_file;
task_data_p->sizetf = 0;
task_data_p->compiletf = 0;
vpi_register_systf(task_data_p);
task_data_p->type = vpiSysFunc;
task_data_p->tfname = "$elf_get_size";
task_data_p->calltf = (void *)elf_get_size;
task_data_p->compiletf = 0;
vpi_register_systf(task_data_p);
task_data_p->type = vpiSysFunc;
task_data_p->tfname = "$elf_read_32";
task_data_p->calltf = (void *)elf_read_32;
task_data_p->compiletf = 0;
vpi_register_systf(task_data_p);
task_data_p->type = vpiSysFunc;
task_data_p->tfname = "$elf_read_16";
task_data_p->calltf = (void *)elf_read_16;
task_data_p->compiletf = 0;
vpi_register_systf(task_data_p);
}
void setup_reset_callbacks(void)
{
// here we setup and install callbacks for
// the setup and management of connections to
// the simulator upon simulation start and
// reset
static s_vpi_time time_s = {vpiScaledRealTime, 0, 0, 0.0};
static s_vpi_value value_s = {vpiBinStrVal, {}};
static s_cb_data cb_data_s =
{
cbEndOfReset, // or start of simulation - initing socket fds etc
(void *)sim_reset_callback,
NULL,
&time_s,
&value_s,
0,
0
};
cb_data_s.obj = NULL; /* trigger object */
cb_data_s.user_data = NULL;
// actual call to register the callback
vpi_register_cb(&cb_data_s);
}
void sim_reset_callback(void)
{
// nothing to do!
return;
}
void setup_endofcompile_callbacks(void)
{
// here we setup and install callbacks for
// simulation finish
static s_vpi_time time_s = {vpiScaledRealTime, 0, 0, 0.0};
static s_vpi_value value_s = {vpiBinStrVal, {}};
static s_cb_data cb_data_s =
{
cbEndOfCompile, // end of compile
(void *)sim_endofcompile_callback,
NULL,
&time_s,
&value_s,
0,
0
};
cb_data_s.obj = NULL; /* trigger object */
cb_data_s.user_data = NULL;
// actual call to register the callback
vpi_register_cb(&cb_data_s);
}
void sim_endofcompile_callback(void)
{
return;
}
void setup_finish_callbacks(void)
{
// here we setup and install callbacks for
// simulation finish
static s_vpi_time time_s = {vpiScaledRealTime, 0, 0, 0.0};
static s_vpi_value value_s = {vpiBinStrVal, {}};
static s_cb_data cb_data_s =
{
cbEndOfSimulation, // end of simulation
(void *)sim_finish_callback,
NULL,
&time_s,
&value_s,
0,
0
};
cb_data_s.obj = NULL; /* trigger object */
cb_data_s.user_data = NULL;
// actual call to register the callback
vpi_register_cb(&cb_data_s);
}
void sim_finish_callback(void)
{
free(bin_file);
return;
}
void (*vlog_startup_routines[ ] ) (void) = {
#ifdef CDS_VPI
// this installs a callback on simulator reset - something which
// icarus does not do, so we only do it for cadence currently
setup_reset_callbacks,
#endif
setup_endofcompile_callbacks,
setup_finish_callbacks,
setup_user_functions,
0 // last entry must be 0
};
| 24.325424
| 80
| 0.710006
|
[
"object"
] |
c32805df7ecfa3d5657a9b61ab6147c1fd88ea2b
| 5,120
|
h
|
C
|
SimVascular-master/Code/Source/sv/Mesh/TetGenAdapt/sv_TetGenAdapt.h
|
mccsssk2/SimVascularPM3_March2020
|
3cce6cc7be66545bea5dc3915a2db50a3892bf04
|
[
"BSD-3-Clause"
] | null | null | null |
SimVascular-master/Code/Source/sv/Mesh/TetGenAdapt/sv_TetGenAdapt.h
|
mccsssk2/SimVascularPM3_March2020
|
3cce6cc7be66545bea5dc3915a2db50a3892bf04
|
[
"BSD-3-Clause"
] | null | null | null |
SimVascular-master/Code/Source/sv/Mesh/TetGenAdapt/sv_TetGenAdapt.h
|
mccsssk2/SimVascularPM3_March2020
|
3cce6cc7be66545bea5dc3915a2db50a3892bf04
|
[
"BSD-3-Clause"
] | null | null | null |
/* Copyright (c) Stanford University, The Regents of the University of
* California, and others.
*
* All Rights Reserved.
*
* See Copyright-SimVascular.txt for additional details.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @file sv_TetGenAdapt.h
* @brief Class provides implementations of the TetGen adaption
*
* This is derived from the SolidModel class and provides implementations
* of functions to be able to import a solid using vtkReaders, extract
* the boundaries of the solid, and mesh the solid with TetGen.
*
* @author Adam Updegrove
* @author [email protected]
* @author UC Berkeley
* @author shaddenlab.berkeley.edu
*/
#ifndef __CVTETGENADAPT_H
#define __CVTETGENADAPT_H
#include "SimVascular.h"
#include "svTetGenAdaptorExports.h"
#include "sv_AdaptObject.h"
//#include "sv_RepositoryData.h"
#ifdef SV_USE_ZLIB
#ifdef SV_USE_SYSTEM_ZLIB
#include <zlib.h>
#else
#include "simvascular_zlib.h"
#endif
#else
#include <stdlib.h>
#define gzopen fopen
#define gzprintf fprintf
#define gzFile FILE*
#define gzclose fclose
#endif
// Some elementary notes on abstract base classes (ABC's)
// ------------------------------------------------------
// ABC's provide a means for defining an *interface*. Since (by
// definition) they contain pure methods, objects of these
// classes can not be instantiated. Clients of ABC's are interested
// in using the abstract interface, but can not work with the objects
// themselves. Instead, clients instantiate concrete classes derived
// from the ABC. And then, to use the abstraction, clients use
// *pointers* or *references* to the ABC. See Meyers' Effective C++,
// Item 34.
//
class SV_EXPORT_TETGEN_ADAPTOR cvTetGenAdapt: public cvAdaptObject {
typedef struct AdaptOptions {
int poly_;
int strategy_;
int metric_option_;
double ratio_;
double hmax_;
double hmin_;
int instep_;
int outstep_;
int step_incr_;
double sphere_[5];
} AdaptOptions;
public:
cvTetGenAdapt();
cvTetGenAdapt( const cvTetGenAdapt& Adapt);
~cvTetGenAdapt();
cvAdaptObject *Copy() const;
int Copy( const cvAdaptObject& src);
#ifdef SV_USE_TCL
int CreateInternalMeshObject(Tcl_Interp *interp,char *meshFileName,
char *solidFileName);
#endif
#ifdef SV_USE_PYTHON
int CreateInternalMeshObject(char *meshFileName,
char *solidFileName);
#endif
int SetMeshObject(cvMeshObject* meshobj) {meshobject_=meshobj; return SV_OK;}
//Setup Operations
int LoadModel(char *fileName);
int LoadModel(vtkPolyData *pd);
int LoadMesh(char *fileName);
int LoadMesh(vtkUnstructuredGrid* ug);
int LoadSolutionFromFile(char *fileName);
int LoadYbarFromFile(char *fileName);
int LoadAvgSpeedFromFile(char *fileName);
int LoadHessianFromFile(char *fileName);
int ReadSolutionFromMesh();
int ReadYbarFromMesh();
int ReadAvgSpeedFromMesh();
//Setup Operations
int SetAdaptOptions(char *flag,double value);
int CheckOptions();
int SetMetric(char *input,int option, int strategy);
int SetupMesh();
//Adapt Operations
int RunAdaptor();
int PrintStats();
//Post Operations
int GetAdaptedMesh();
int TransferSolution();
int TransferRegions();
//Write Operations
int WriteAdaptedModel(char *fileName);
int WriteAdaptedModelFace(int faceid,char *fileName);
int WriteAdaptedMesh(char *fileName);
int WriteAdaptedSolution(char *fileName);
private:
cvMeshObject *meshobject_;
vtkUnstructuredGrid *inmesh_;
vtkPolyData *insurface_mesh_;
vtkUnstructuredGrid *outmesh_;
vtkPolyData *outsurface_mesh_;
double *sol_;
double *ybar_;
double *avgspeed_;
double *hessians_;
double *errormetric_;
AdaptOptions options;
};
#endif //__CVTETGEN_ADAPT_H
| 30.295858
| 79
| 0.737109
|
[
"mesh",
"solid"
] |
c33e329df0a52b9b10c63c10e221569a0fd0c8e3
| 3,986
|
h
|
C
|
Classes/NULDBDB_private.h
|
bgulanowski/NULevelDB
|
107434b08bcbdcda0eea4569a55918578fc56ddf
|
[
"Unlicense"
] | 89
|
2015-01-08T08:57:53.000Z
|
2020-11-30T22:26:44.000Z
|
Classes/NULDBDB_private.h
|
bgulanowski/NULevelDB
|
107434b08bcbdcda0eea4569a55918578fc56ddf
|
[
"Unlicense"
] | 6
|
2015-05-27T07:10:26.000Z
|
2018-01-23T12:12:05.000Z
|
Classes/NULDBDB_private.h
|
bgulanowski/NULevelDB
|
107434b08bcbdcda0eea4569a55918578fc56ddf
|
[
"Unlicense"
] | 38
|
2015-03-18T11:29:18.000Z
|
2022-03-30T08:31:30.000Z
|
//
// NULDBDB_private.h
// NULevelDB
//
// Created by Brent Gulanowski on 11-11-04.
// Copyright (c) 2011 Nulayer Inc. All rights reserved.
//
#import "NULDBDB.h"
#import "NULDBSlice.h"
#import "NULDBWriteBatch.h"
#import "NULDBUtilities.h"
#include <leveldb/db.h>
#include <leveldb/slice.h>
#include <leveldb/options.h>
#include <leveldb/comparator.h>
#include <leveldb/write_batch.h>
extern int logging;
using namespace leveldb;
@interface NULDBSlice ()
+ (id)objectWithSlice:(Slice&)slice type:(NULDBSliceType)sliceType;
+ (id)objectWithSlice:(Slice&)slice key:(Slice&)keySlice type:(NULDBSliceType *)type;
+ (BOOL)getSlice:(Slice *)slice forObject:(id)object type:(NULDBSliceType)sliceType;
- (id)initWithSlice:(Slice&)slice key:(Slice&)key;
- (id)initWithSlice:(Slice&)slice type:(NULDBSliceType)sliceType;
- (void)getSlice:(Slice *)slice;
@end
@interface NULDBWriteBatch () {
WriteBatch *writeBatch;
}
@property (readonly) WriteBatch *writeBatch;
- (void)close;
@end
@interface NULDBDB () {
DB *db;
ReadOptions readOptions;
WriteOptions writeOptions;
Slice *classIndexKey;
size_t bufferSize;
}
@end
@interface NULDBDB (ErrorConstructing)
+ (NSError *)errorForStatus:(Status *)status;
@end
static inline BOOL NULDBStoreValueForKey(DB *db, WriteOptions &writeOptions, Slice &key, Slice &value, NSError **error) {
Status status = db->Put(writeOptions, key, value);
if(!status.ok()) {
if(NULL != error)
*error = [NULDBDB errorForStatus:&status];
else
NSLog(@"Failed to store value in database: %s", status.ToString().c_str());
}
return status.ok();
}
inline BOOL NULDBLoadValueForKey(DB *db, ReadOptions &options, Slice &key, id *retValue, BOOL isString, NSError **error) {
std::string tempValue;
Status status = db->Get(options, key, &tempValue);
assert(NULL != retValue);
if(!status.IsNotFound()) {
if(!status.ok()) {
if(NULL != error) {
NSDictionary *userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
[NSString stringWithUTF8String:status.ToString().c_str()], NSLocalizedDescriptionKey,
// NSLocalizedString(@"", @""), NSLocalizedRecoverySuggestionErrorKey,
nil];
*error = [NSError errorWithDomain:NULDBErrorDomain code:2 userInfo:userInfo];
}
else {
NSLog(@"Failed to load value from database: %s", status.ToString().c_str());
}
*retValue = nil;
return NO;
}
else {
Slice value = tempValue;
if(isString)
*retValue = NULDBStringFromSlice(value);
else
*retValue = NULDBDataFromSlice(value);
}
}
else
*retValue = nil;
if(NULL != error)
*error = nil;
return YES;
}
inline BOOL NULDBDeleteValueForKey(DB *db, WriteOptions &options, Slice &key, NSError **error) {
Status status = db->Delete(options, key);
if(!status.ok() && !status.IsNotFound()) {
if(NULL != error) {
NSDictionary *userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
[NSString stringWithUTF8String:status.ToString().c_str()], NSLocalizedDescriptionKey,
// NSLocalizedString(@"", @""), NSLocalizedRecoverySuggestionErrorKey,
nil];
*error = [NSError errorWithDomain:NULDBErrorDomain code:3 userInfo:userInfo];
}
else {
NSLog(@"Failed to delete value in database: %s", status.ToString().c_str());
}
return NO;
}
return YES;
}
| 28.269504
| 153
| 0.578274
|
[
"object"
] |
c33fbd2f517807e026dd34fda8477943db93396d
| 277
|
h
|
C
|
MyComponentEngine/MainCamera.h
|
0ddarri/ComponentEngine
|
0641589c695f54c5c6bc940a1769c5cbdc772aea
|
[
"MIT"
] | null | null | null |
MyComponentEngine/MainCamera.h
|
0ddarri/ComponentEngine
|
0641589c695f54c5c6bc940a1769c5cbdc772aea
|
[
"MIT"
] | 1
|
2022-03-30T08:27:58.000Z
|
2022-03-30T08:27:58.000Z
|
MyComponentEngine/MainCamera.h
|
0ddarri/ComponentEngine
|
0641589c695f54c5c6bc940a1769c5cbdc772aea
|
[
"MIT"
] | null | null | null |
#pragma once
#include "Singleton.h"
#include "Camera.h"
#include "GameObject.h"
static class MainCamera : public GameObject
{
private:
protected:
public:
MainCamera();
Camera* camera;
virtual void Update(float dt);
virtual void Render();
virtual void Release();
};
| 12.043478
| 43
| 0.718412
|
[
"render"
] |
c34393cb6c630a09f2dac5a55f85b793439a7f1e
| 3,532
|
h
|
C
|
hazytl/include/hazy/vector/dot-inl.h
|
zuevmaxim/hogwildpp
|
40a035e5342df58b338c16bdcd94b9f20e38174e
|
[
"Apache-2.0"
] | 36
|
2016-10-10T23:56:25.000Z
|
2021-04-20T16:24:05.000Z
|
hazytl/include/hazy/vector/dot-inl.h
|
zuevmaxim/hogwildpp
|
40a035e5342df58b338c16bdcd94b9f20e38174e
|
[
"Apache-2.0"
] | null | null | null |
hazytl/include/hazy/vector/dot-inl.h
|
zuevmaxim/hogwildpp
|
40a035e5342df58b338c16bdcd94b9f20e38174e
|
[
"Apache-2.0"
] | 8
|
2017-01-12T21:15:51.000Z
|
2022-02-14T07:04:47.000Z
|
// Copyright 2012 Chris Re, Victor Bittorf
//
// 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
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// The Hazy Project, http://research.cs.wisc.edu/hazy/
// Author : Victor Bittorf (bittorf [at] cs.wisc.edu)
#ifndef HAZY_VECTOR_DOT_INL_H
#define HAZY_VECTOR_DOT_INL_H
#include <cmath>
#include "hazy/vector/dot.h"
// See hazy/vector/dot.h for documentation
namespace hazy {
namespace vector {
template <typename T, typename Vec>
void inline MatrixVectorMultiply(FVector<SVector<T> > const &mat,
Vec const &vec,
FVector<T> &out) {
// Note: Assume mat is padded with zeros
out.size = mat.size;
for (size_t i = 0; i < mat.size; i++) {
out.values[i] = Dot(vec, mat.values[i]);
}
}
template <typename float_u, typename float_v>
float_u inline Dot(FVector<float_u> const& u, SVector<float_v> const& v) {
float_u p = 0.0;
float_u const * const /*__restrict__*/ uvals = u.values;
float_v const * const /*__restrict__*/ vvals = v.values;
int const * const /*__restrict__*/ vidx = v.index;
for (size_t i = v.size; i-- > 0; ) {
p += uvals[vidx[i]] * vvals[i];
}
return p;
}
template <typename float_u, typename float_v>
float_u inline AddAndDot(FVector<float_u> const& u1, FVector<float_u> const& u2, SVector<float_v> const& v) {
float_u p = 0.0;
float_u const * const /*__restrict__*/ u1vals = u1.values;
float_u const * const /*__restrict__*/ u2vals = u2.values;
float_v const * const /*__restrict__*/ vvals = v.values;
int const * const /*__restrict__*/ vidx = v.index;
for (size_t i = v.size; i-- > 0; ) {
int const idx = vidx[i];
p += (u1vals[idx] + u2vals[idx]) * vvals[i];
}
return p;
}
template <typename float_u, typename float_v>
float_u inline Dot(FVector<float_u> const &u, FVector<float_v> const &v) {
float_u p = 0.0;
float_u const * const /*__restrict__*/ uvals = u.values;
float_v const * const /*__restrict__*/ vvals = v.values;
for (size_t i = v.size; i-- > 0; ) {
p += uvals[i] * vvals[i];
}
return p;
}
template <typename float_u, typename float_v>
float_u inline AddAndDot(FVector<float_u> const &u1, FVector<float_u> const &u2, FVector<float_v> const &v) {
float_u p = 0.0;
float_u const * const /*__restrict__*/ u1vals = u1.values;
float_u const * const /*__restrict__*/ u2vals = u2.values;
float_v const * const /*__restrict__*/ vvals = v.values;
for (size_t i = v.size; i-- > 0; ) {
p += (u1vals[i] + u2vals[i]) * vvals[i];
}
return p;
}
template <typename float_u, typename float_v>
float_u inline Dot(SVector<float_u> const& x, SVector<float_v> const& y) {
long xi = (long)x.size - 1;
long yi = (long)y.size - 1;
float_u ret = 0.0;
while(xi >= 0 && yi >= 0) {
int diff = x.index[xi] - static_cast<int>(y.index[yi]);
if(diff == 0) {
ret += x.values[xi]*y.values[yi];
xi--; yi--;
} else {
if(diff > 0) {xi--;} else { yi--; }
}
}
return ret;
}
} // namespace vector
} // namespace hazy
#endif
| 31.81982
| 109
| 0.649207
|
[
"vector"
] |
c351a85dff22700aa44d3b551fcad90356bfafb1
| 3,672
|
h
|
C
|
sltl/src/core/semantic.h
|
cheneryc/sltl
|
f7afe936cc218332b077b0ec14cb4c69a51af908
|
[
"MIT"
] | null | null | null |
sltl/src/core/semantic.h
|
cheneryc/sltl
|
f7afe936cc218332b077b0ec14cb4c69a51af908
|
[
"MIT"
] | 3
|
2019-02-17T22:35:37.000Z
|
2019-02-17T22:41:49.000Z
|
sltl/src/core/semantic.h
|
cheneryc/sltl
|
f7afe936cc218332b077b0ec14cb4c69a51af908
|
[
"MIT"
] | null | null | null |
#pragma once
#include <utility>
#include <exception>
#include <cstdlib>
namespace sltl
{
namespace core
{
enum class semantic : unsigned short
{
none = 0,
system,
position, // For built-in behaviour use semantic_system::position
depth, // For built-in behaviour use semantic_system::depth
normal,
texcoord,
colour, // For built-in behaviour use semantic_system::target
material,
transform,
camera,
light,
user,
count
};
// semantic_system::position - gl_Position/gl_FragCoord or SV_Position
// semantic_system::depth - gl_FragDepth or SV_Depth
// semantic_system::target - (layout(location=N) out your_var_name;) or SV_Target
enum class semantic_system : unsigned char
{
none = 0,
position = static_cast<std::underlying_type<semantic>::type>(semantic::count),
depth,
target,
count
};
enum class semantic_transform : unsigned char
{
none = 0,
model = static_cast<std::underlying_type<semantic_system>::type>(semantic_system::count),
modelview,
modelviewproj,
modelviewproj_inverse,
modelviewproj_inversetrans,
view,
viewproj,
proj,
normal, // mat3x3 - modelviewproj_inversetrans
count
};
typedef unsigned short semantic_index_t;
template<typename T>
struct semantic_index_limits;
template<>
struct semantic_index_limits<semantic_system>
{
constexpr static semantic_index_t max()
{
return 15U;
}
};
class semantic_pair
{
public:
semantic_pair(semantic s = semantic::none, semantic_index_t index = 0U) : _semantic(s), _index(index) {}
semantic_pair(const semantic_pair& pair) : _semantic(pair._semantic), _index(pair._index) {}
// Non-assignable
semantic_pair& operator=(semantic_pair&&) = delete;
semantic_pair& operator=(const semantic_pair&) = delete;
const semantic _semantic;
const semantic_index_t _index;
static const semantic_pair none;
};
template<semantic S, semantic_index_t N>
struct semantic_fail : std::false_type {};
namespace detail
{
constexpr auto to_underlying_value(semantic_system s) -> std::underlying_type<semantic_system>::type
{
return (static_cast<std::underlying_type<semantic_system>::type>(s) -
static_cast<std::underlying_type<semantic>::type>(semantic::count)) + 1;
}
constexpr auto to_underlying_value(semantic_transform s) -> std::underlying_type<semantic_transform>::type
{
return (static_cast<std::underlying_type<semantic_transform>::type>(s) -
static_cast<std::underlying_type<semantic_system>::type>(semantic_system::count)) + 1;
}
constexpr semantic_index_t to_semantic_index(semantic_system s, semantic_index_t n)
{
// Each system semantic is allocated 16 indices (4 bits)
// position (1) -> 0 - 15
// depth (2) -> 16 - 31
// target (3) -> 32 - 47
return s != semantic_system::none ? ((to_underlying_value(s) - 1U) << 4) + n : throw std::exception();//TODO: exception type and message
}
constexpr semantic_index_t to_semantic_index(semantic_transform s)
{
return s != semantic_transform::none ? (to_underlying_value(s) - 1) : throw std::exception();//TODO: exception type and message
}
inline std::pair<semantic_system, semantic_index_t> to_semantic_system_pair(semantic_index_t n)
{
const div_t div_result = div(n, 16);
return {
static_cast<semantic_system>(div_result.quot + static_cast<std::underlying_type<semantic>::type>(semantic::count)),
static_cast<semantic_index_t>(div_result.rem)
};
}
}
}
}
| 28.030534
| 142
| 0.685185
|
[
"model",
"transform"
] |
c3558a571009ade8422bb707361af964d54cde64
| 806
|
c
|
C
|
src/rava_core_object.c
|
frinknet/rava
|
ab32622c1efeb504144fc95d77a7456e2a935109
|
[
"MIT"
] | 1
|
2021-03-19T05:34:24.000Z
|
2021-03-19T05:34:24.000Z
|
src/rava_core_object.c
|
frinknet/rava
|
ab32622c1efeb504144fc95d77a7456e2a935109
|
[
"MIT"
] | null | null | null |
src/rava_core_object.c
|
frinknet/rava
|
ab32622c1efeb504144fc95d77a7456e2a935109
|
[
"MIT"
] | null | null | null |
#include "rava.h"
#include "rava_core_object.h"
void ravaL_object_init(rava_state_t* state, rava_object_t* self)
{
QUEUE_INIT(&self->rouse);
QUEUE_INIT(&self->queue);
self->state = state;
self->data = NULL;
self->flags = 0;
self->count = 0;
self->buf.base = NULL;
self->buf.len = 0;
}
void ravaL_object_close_cb(uv_handle_t* handle)
{
rava_object_t* self = container_of(handle, rava_object_t, h);
TRACE("object closed %p\n", self);
self->flags |= RAVA_OCLOSED;
self->state = NULL;
ravaL_cond_signal(&self->rouse);
}
void ravaL_object_close(rava_object_t* self)
{
if (!ravaL_object_is_closing(self)) {
TRACE("object closing %p, type: %i\n", self, self->h.handle.type);
self->flags |= RAVA_OCLOSING;
uv_close(&self->h.handle, ravaL_object_close_cb);
}
}
| 20.15
| 70
| 0.681141
|
[
"object"
] |
c35753accc490dfc76d6c77730b5a20a5b51a647
| 3,105
|
c
|
C
|
d/shadow/room/city/cguild/ranger/rooms/hall1.c
|
Dbevan/SunderingShadows
|
6c15ec56cef43c36361899bae6dc08d0ee907304
|
[
"MIT"
] | 13
|
2019-07-19T05:24:44.000Z
|
2021-11-18T04:08:19.000Z
|
d/shadow/room/city/cguild/ranger/rooms/hall1.c
|
Dbevan/SunderingShadows
|
6c15ec56cef43c36361899bae6dc08d0ee907304
|
[
"MIT"
] | 4
|
2021-03-15T18:56:39.000Z
|
2021-08-17T17:08:22.000Z
|
d/shadow/room/city/cguild/ranger/rooms/hall1.c
|
Dbevan/SunderingShadows
|
6c15ec56cef43c36361899bae6dc08d0ee907304
|
[
"MIT"
] | 13
|
2019-09-12T06:22:38.000Z
|
2022-01-31T01:15:12.000Z
|
#include <std.h>
#include "../ranger.h"
inherit ROOM ;
void create(){
object ob;
::create();
set_terrain(WOOD_BUILDING);
set_travel(DIRT_ROAD);
set_property("light",2);
set_property("indoors",1);
set_property("no teleport",1);
set_name("Inside the World Tree");
set_short("%^RESET%^%^GREEN%^Inside the World Tree%^RESET%^");
set_long("%^RESET%^%^GREEN%^Inside the World Tree%^RESET%^\n"
"%^RESET%^%^ORANGE%^You find yourself standing within the base of what seems to be an impossibly large "
"%^GREEN%^oak tree%^ORANGE%^. Easily as large as a hall, this inner area is roughly circular and bordered on "
"all sides by rough walls of %^RED%^wood %^ORANGE%^and %^BOLD%^%^BLACK%^bark%^RESET%^%^ORANGE%^. Gnarled "
"roots snake their way into the earth beneath your feet, which is hard-packed from the passage of many feet. "
"%^RED%^Wooden slats%^ORANGE%^, almost like tree limbs, grow outwards from the inside of the trunk, forming a "
"circular pathway of stairs that leads up around the edge of the room to an unseen area above, cut off from "
"view by the flat plane of wood that serves as the roof to this section. Softly glowing orbs of %^GREEN%^vi"
"%^CYAN%^rid%^GREEN%^ian li%^CYAN%^gh%^GREEN%^t %^ORANGE%^shed a gentle, natural radiance about the otherwise "
"enclosed and darkened room. The only other way out appears to be a split between some of the tree's thick "
"roots, leading out to the %^CYAN%^fresh air %^ORANGE%^beyond.\n%^RESET%^");
set_smell("default","The sweet smell of fresh air and greenery surrounds you.");
set_listen("default","The quiet surroundings are occasionally interrupted by the soft creak of wood.");
set_items(([
({"walls","wood","bark","tree","trunk","stairs","limbs","slats","pathway"}):"%^RESET%^%^ORANGE%^The "
"sturdy trunk of a %^GREEN%^massive oak tree %^ORANGE%^forms this room, enclosed on all sides by %^RED%^rough-"
"barked wood%^ORANGE%^. Wooden slats, much like tree limbs, have grown outwards from the walls to provide a "
"circular stairway that leads up into rooms above you.%^RESET%^",
({"earth","ground","roots"}):"%^RESET%^%^ORANGE%^Thick gnarled roots snake their way into the %^BOLD%^"
"%^BLACK%^hard-packed earth %^RESET%^%^ORANGE%^beneath your feet. At one point, a gap split between them "
"seems big enough to escape through, into the %^CYAN%^open air %^ORANGE%^beyond.%^RESET%^",
({"orbs","light","radiance"}):"%^RESET%^%^ORANGE%^Around the walls, softly glowing orbs of %^GREEN%^vi"
"%^CYAN%^rid%^GREEN%^ian li%^CYAN%^gh%^GREEN%^t %^ORANGE%^shed a gentle radiance upon the room itself."
"%^RESET%^",
]));
set_exits(([
"out":RROOM"path3",
"up":RROOM"hall2",
]));
ob=new(BBOARD);
ob->set_name("board");
ob->set_id(({"board","notice board","ranger board"}));
ob->set_board_id("ranger_guild");
ob->set_max_posts(30);
ob->set_location(RROOM"hall1");
ob->set_short("%^YELLOW%^Ranger's notice board%^RESET%^");
ob->set_long("%^RESET%^%^ORANGE%^A wooden board lies upon the distant wall of the room, pinned with a few "
"notices.%^RESET%^");
}
| 55.446429
| 111
| 0.682448
|
[
"object"
] |
c35efe0cbd902a552c51639fd3572f7d58262a04
| 2,653
|
h
|
C
|
GrannyViewer/iris/renderer/DynamicObjects.h
|
zerodowned/Iris1_DeveloperTools
|
0b5510bb46824d8939846f73c7e63ed7eecf827d
|
[
"DOC"
] | 1
|
2019-02-08T18:03:28.000Z
|
2019-02-08T18:03:28.000Z
|
GrannyViewer/iris/renderer/DynamicObjects.h
|
SiENcE/Iris1_DeveloperTools
|
0b5510bb46824d8939846f73c7e63ed7eecf827d
|
[
"DOC"
] | null | null | null |
GrannyViewer/iris/renderer/DynamicObjects.h
|
SiENcE/Iris1_DeveloperTools
|
0b5510bb46824d8939846f73c7e63ed7eecf827d
|
[
"DOC"
] | 7
|
2015-03-11T22:06:23.000Z
|
2019-12-21T09:49:57.000Z
|
//
// File: DynamicObjects.h
// Created by: Alexander Oster - [email protected]
//
/*****
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*****/
#ifndef _DYNAMICOBJECTS_H_
#define _DYNAMICOBJECTS_H_
#ifdef WIN32
#include <windows.h>
#endif
#include "SDL/SDL.h"
#include <map>
#include "Fade.h"
#define DYNAMICTYPE_WORLD 0
#define DYNAMICTYPE_CONTAINER 1
#define DYNAMICTYPE_EQUIPMENT 2
class cDynamicObject {
private:
public:
Uint32 id;
int x, y, z;
int model;
int itemcount;
int incrcounter;
Uint8 direction;
Uint16 dye;
Uint8 flag;
bool clip;
int type;
Uint8 alpha;
Uint32 parent;
float sphere[5];
cFader * fader;
cDynamicObject ();
~ cDynamicObject ();
};
typedef std::map<Uint32, cDynamicObject *> dynamiclist_t;
class cDynamicObjectList
{
private:
dynamiclist_t dynamiclist;
int m_roof_z;
cDynamicObject * Add (Uint32 id);
public:
cDynamicObjectList ();
~cDynamicObjectList ();
void Clear (void);
cDynamicObject * AddContainerContent (Uint32 id, Uint16 model, Uint16 dye, Uint32 parent, int x, int y, int itemcount);
cDynamicObject * AddCharEquip (Uint32 id, Uint16 model, Uint16 dye, Uint32 parent);
cDynamicObject * AddWorldItem (Uint32 id, Uint16 model, Uint16 dye, int x, int y, int z, int itemcount, int incrcounter, int direction, int flag);
cDynamicObject * Get (unsigned int id);
void Delete (unsigned int id);
dynamiclist_t * GetList(void) { return &dynamiclist; }
int GetCount(void) { return dynamiclist.size(); }
int UpdateFader(int min_z, Uint8 alpha, cFader * fader, bool below);
void ResetFader(cFader * fader);
void setRoofZ(int z) { m_roof_z = z; }
int GetRoofHeight(int x, int y, int z);
void OnAdd(void (*callback) (cDynamicObject * object));
void OnDelete(void (*callback) (cDynamicObject * object));
protected:
void (*callback_OnAdd) (cDynamicObject * object);
void (*callback_OnDelete) (cDynamicObject * object);
};
extern cDynamicObjectList * pDynamicObjectList;
#endif //_DYNAMICOBJECTS_H_
| 25.509615
| 147
| 0.735394
|
[
"object",
"model"
] |
c380aee91e5fe54d068add4369de056fc358efcf
| 2,070
|
h
|
C
|
noticias/include/casarosada.h
|
miglesias91/medios-digitales
|
3c237d939bb694502ce6d4f89a3fa44a66acd1ac
|
[
"MIT"
] | null | null | null |
noticias/include/casarosada.h
|
miglesias91/medios-digitales
|
3c237d939bb694502ce6d4f89a3fa44a66acd1ac
|
[
"MIT"
] | null | null | null |
noticias/include/casarosada.h
|
miglesias91/medios-digitales
|
3c237d939bb694502ce6d4f89a3fa44a66acd1ac
|
[
"MIT"
] | null | null | null |
#pragma once
// feed
#include <feed/include/rss.h>
// noticias
#include <noticias/include/portal.h>
namespace medios {
namespace feed {
class rss_casarosada : public medios::feed::rss {
public:
rss_casarosada(const std::string & uri, const std::string & seccion, const std::unordered_map<std::string, std::string> & subcategorias) : medios::feed::rss(uri, seccion, subcategorias) {};
virtual ~rss_casarosada() {};
protected:
virtual bool parsear(const std::string & contenido_xml, std::vector<historia*> & historias,
const herramientas::utiles::Fecha & desde = herramientas::utiles::Fecha(0, 0, 0),
const herramientas::utiles::Fecha & hasta = herramientas::utiles::Fecha::getFechaActual()) {
pugi::xml_document xml_feed;
pugi::xml_parse_result resultado = xml_feed.load_string(contenido_xml.c_str());
uint32_t cantidad_total_de_historias = 0;
uint32_t cantidad_de_historias_descargadas = 0;
for (pugi::xml_node item : this->historias_xml(xml_feed)) {
historia * nueva = new historia();
this->parsear_historia(item, nueva);
if (desde <= nueva->fecha() && nueva->fecha() <= hasta) {
nueva->html(nueva->contenido());
historias.push_back(nueva);
cantidad_total_de_historias++;
}
else {
delete nueva;
}
}
return true;
}
};
}
}
namespace medios {
namespace noticias {
class casarosada : public portal {
public:
casarosada();
virtual ~casarosada();
virtual std::string web();
virtual portal * clon();
virtual bool extraer_contenido_de_html(const std::string & contenido_html, std::string * contenido);
protected:
};
};
};
| 31.846154
| 202
| 0.545411
|
[
"vector"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.