/*
* Effect rendering functions.
*/
void RenderEffect(int frameNumber) {
PixBufT *canvas = R_("Canvas");
UVMapT *uvmap = R_("Map");
PixBufT *comp = R_("Component");
PixBufT *shades = R_("Shades");
uint8_t *cfunc = R_("ColFunc");
int du = 2 * frameNumber;
int dv = 4 * frameNumber;
{
int i;
for (i = 0; i < 256; i++) {
uint8_t v = i + du;
if (v >= 128)
cfunc[i] = ~v * 2;
else
cfunc[i] = v * 2;
}
}
PixBufSetBlitMode(comp, BLIT_COLOR_FUNC);
PixBufSetColorFunc(comp, cfunc);
PROFILE (PixBufBlitWithColorFunc)
PixBufBlit(shades, 0, 0, comp, NULL);
UVMapSetOffset(uvmap, du, dv);
PROFILE (UVMapRenderFast)
UVMapRender(uvmap, canvas);
c2p1x1_8_c5_bm(canvas->data, GetCurrentBitMap(), WIDTH, HEIGHT, 0, 0);
}
void KalmanFilter::init(Eigen::Vector3f jerk_std,
Eigen::Vector3f measur_std,
float delta_t,
Eigen::Matrix<float, 9, 1> x_k1,
Eigen::Matrix<float, 9, 9> init_cov)
{
x_k_n_ = x_k1;
P_k_n_ = init_cov;
H_.fill(0.);
H_(0,0) = 1.;
H_(1,1) = 1.;
H_(2,2) = 1.;
R_.fill(0.);
R_(0,0) = pow(measur_std(0),2);
R_(1,1) = pow(measur_std(1),2);
R_(2,2) = pow(measur_std(2),2);
sigma_jerk_ = Eigen::Matrix3f::Zero();
sigma_jerk_(0,0) = pow(jerk_std(0),2);
sigma_jerk_(1,1) = pow(jerk_std(1),2);
sigma_jerk_(2,2) = pow(jerk_std(2),2);
if (delta_t <=0)
delta_t_ = 1/30; // We aim for 30 FPS
else
delta_t_ = delta_t;
delta_change();
}
/*
* Set up resources.
*/
void AddInitialResources() {
ResAdd("Canvas", NewPixBuf(PIXBUF_CLUT, WIDTH, HEIGHT));
ResAdd("Scene", NewScene());
#if 0
ResAdd("Mesh", NewMeshFromFile("data/shattered_ball.robj"));
ResAdd("ColorMap", NewPixBufFromFile("data/shattered_ball_cmap.8"));
ResAddPngImage("ColorMap", "Palette", "data/wecan_logo_cmap.png");
ResAdd("Palette", NewPaletteFromFile("data/shattered_ball_cmap.pal"));
#else
ResAdd("Mesh", NewMeshFromFile("data/wecan_logo.robj"));
#endif
{
MeshT *mesh = R_("Mesh");
CalculateSurfaceNormals(mesh);
NormalizeMeshSize(mesh);
MeshApplyPalette(mesh, R_("Palette"));
}
SceneAddObject(R_("Scene"), NewSceneObject("Object", R_("Mesh")));
RenderMode = RENDER_GOURAUD_SHADING;
RenderAllFaces = false;
}
void RenderMesh(int frameNumber_) {
PixBufT *canvas = R_("Canvas");
SceneT *scene = R_("Scene");
float frameNumber = frameNumber_;
float s = sin(frameNumber * 3.14159265f / 90.0f) + 1.0f;
{
MatrixStack3D *ms = GetObjectTranslation(scene, "Object");
StackReset(ms);
PushScaling3D(ms, 0.75f + 0.5f * s, 0.75f + 0.5f * s, 0.75f + 0.5f * s);
PushRotation3D(ms, 0, (float)(-frameNumber * 2), frameNumber);
PushTranslation3D(ms, 0.0f, 0.0f, -2.0f);
}
PixBufClear(canvas);
#if 0
RenderFlatShading = true;
PixBufSetColorMap(canvas, R_("ColorMap"), -32);
#endif
PROFILE(RenderScene)
RenderScene(scene, canvas);
c2p1x1_8_c5_bm(canvas->data, GetCurrentBitMap(), WIDTH, HEIGHT, 0, 0);
}
//----------------------------------------------------------------------
// univariate slice sampling to set each element
void CS::draw_one() {
double oldr = R_(i_, j_);
double logp_star = logp(R_(i_, j_));
double u = logp_star - rexp_mt(rng(), 1);
find_limits();
if (lo_ >= hi_) {
set_r(0);
return;
}
// const double eps(100*std::numeric_limits<double>::epsilon());
const double eps(1e-6);
check_limits(oldr, eps);
while (1) {
double cand = runif_mt(rng(), lo_, hi_);
double logp_cand = logp(cand);
if (logp_cand > u) { // found something inside slice
set_r(cand);
return;
} else { // contract slice
if (cand > oldr) {
hi_ = cand;
} else {
lo_ = cand;
}
}
if (fabs(hi_ - lo_) < eps) {
set_r(hi_);
return;
}
}
}
void eqnsys<nr_type_t>::factorize_qrh (void) {
int c, r, k, pivot;
nr_type_t f, t;
nr_double_t s, MaxPivot;
delete R; R = new tvector<nr_type_t> (N);
for (c = 0; c < N; c++) {
// compute column norms and save in work array
nPvt[c] = euclidian_c (c);
cMap[c] = c; // initialize permutation vector
}
for (c = 0; c < N; c++) {
// put column with largest norm into pivot position
MaxPivot = nPvt[c]; pivot = c;
for (r = c + 1; r < N; r++) {
if ((s = nPvt[r]) > MaxPivot) {
pivot = r;
MaxPivot = s;
}
}
if (pivot != c) {
A->exchangeCols (pivot, c);
Swap (int, cMap[pivot], cMap[c]);
Swap (nr_double_t, nPvt[pivot], nPvt[c]);
}
// compute householder vector
if (c < N) {
nr_type_t a, b;
s = euclidian_c (c, c + 1);
a = A_(c, c);
b = -sign (a) * xhypot (a, s); // Wj
t = xhypot (s, a - b); // || Vi - Wi ||
R_(c) = b;
// householder vector entries Ui
A_(c, c) = (a - b) / t;
for (r = c + 1; r < N; r++) A_(r, c) /= t;
}
else {
R_(c) = A_(c, c);
}
// apply householder transformation to remaining columns
for (r = c + 1; r < N; r++) {
for (f = 0, k = c; k < N; k++) f += cond_conj (A_(k, c)) * A_(k, r);
for (k = c; k < N; k++) A_(k, r) -= 2.0 * f * A_(k, c);
}
// update norms of remaining columns too
for (r = c + 1; r < N; r++) {
nPvt[r] = euclidian_c (r, c + 1);
}
}
}
double operator()(double r){
R_(i,j) = r;
R_(j,i) = r;
double ans = R_.det();
if(isnan(ans)){
std::ostringstream err;
err << "Illegal determinant in random_cor: R = " << std::endl
<< R_ << std::endl;
report_error(err.str());
}
return ans;
}
void eqnsys<nr_type_t>::factorize_svd (void) {
int i, j, l;
nr_type_t t;
// allocate space for vectors and matrices
delete R; R = new tvector<nr_type_t> (N);
delete T; T = new tvector<nr_type_t> (N);
delete V; V = new tmatrix<nr_type_t> (N);
delete S; S = new tvector<nr_double_t> (N);
delete E; E = new tvector<nr_double_t> (N);
// bidiagonalization through householder transformations
for (i = 0; i < N; i++) {
T_(i) = householder_left (i);
if (i < N - 1) R_(i) = householder_right (i);
}
// copy over the real valued bidiagonal values
for (i = 0; i < N; i++) S_(i) = real (A_(i, i));
for (E_(0) = 0, i = 1; i < N; i++) E_(i) = real (A_(i - 1, i));
// backward accumulation of right-hand householder transformations
// yields the V' matrix
for (l = N, i = N - 1; i >= 0; l = i--) {
if (i < N - 1) {
if ((t = R_(i)) != 0.0) {
householder_apply_right_extern (i, cond_conj (t));
}
else for (j = l; j < N; j++) // cleanup this row
V_(i, j) = V_(j, i) = 0.0;
}
V_(i, i) = 1.0;
}
// backward accumulation of left-hand householder transformations
// yields the U matrix in place of the A matrix
for (l = N, i = N - 1; i >= 0; l = i--) {
for (j = l; j < N; j++) // cleanup upper row
A_(i, j) = 0.0;
if ((t = T_(i)) != 0.0) {
householder_apply_left (i, cond_conj (t));
for (j = l; j < N; j++) A_(j, i) *= -t;
}
else for (j = l; j < N; j++) // cleanup this column
A_(j, i) = 0.0;
A_(i, i) = 1.0 - t;
}
// S and E contain diagonal and super-diagonal, A contains U, V'
// calculated; now diagonalization can begin
diagonalize_svd ();
}
/*
* Set up effect function.
*/
void SetupEffect() {
UVMapT *uvmap = R_("Map");
PixBufT *shades = R_("Shades");
LoadPalette(R_("TexturePal"));
UVMapGenerate4(uvmap);
UVMapSetTexture(uvmap, R_("Texture"));
uvmap->lightMap = shades;
PixBufSetColorMap(shades, R_("ColorMap"));
ResAdd("Component", NewPixBufWrapper(WIDTH, HEIGHT, uvmap->map.fast.u));
StartProfiling();
}
/*
* Main loop.
*/
void MainLoop() {
LoopEventT event = LOOP_CONTINUE;
SetVBlankCounter(0);
do {
int frameNumber = GetVBlankCounter();
if (event != LOOP_CONTINUE) {
CanvasFill(R_("Canvas"), 0);
if (event == LOOP_NEXT)
effect = (effect + 1) % lastEffect;
if (event == LOOP_PREV) {
effect--;
if (effect < 0)
effect += lastEffect;
}
}
RenderVector(frameNumber);
RenderChunky(frameNumber);
RenderFrameNumber(frameNumber);
DisplaySwap();
} while ((event = ReadLoopEvent()) != LOOP_EXIT);
}
void RenderEffect(int frameNumber) {
PixBufT *canvas = R_("Canvas");
PROFILE(Fire)
RenderFire(canvas);
PROFILE(C2P)
c2p1x1_8_c5_bm(canvas->data, GetCurrentBitMap(), WIDTH, HEIGHT, 0, 0);
}
bool
TextureSystemImpl::environment(TextureHandle* texture_handle,
Perthread* thread_info, TextureOptBatch& options,
Tex::RunMask mask, const float* R,
const float* dRdx, const float* dRdy,
int nchannels, float* result, float* dresultds,
float* dresultdt)
{
// (FIXME) CHEAT! Texture points individually
TextureOpt opt;
opt.firstchannel = options.firstchannel;
opt.subimage = options.subimage;
opt.subimagename = options.subimagename;
opt.swrap = (TextureOpt::Wrap)options.swrap;
opt.twrap = (TextureOpt::Wrap)options.twrap;
opt.mipmode = (TextureOpt::MipMode)options.mipmode;
opt.interpmode = (TextureOpt::InterpMode)options.interpmode;
opt.anisotropic = options.anisotropic;
opt.conservative_filter = options.conservative_filter;
opt.fill = options.fill;
opt.missingcolor = options.missingcolor;
bool ok = true;
Tex::RunMask bit = 1;
for (int i = 0; i < Tex::BatchWidth; ++i, bit <<= 1) {
float r[4], drds[4], drdt[4]; // temp result
if (mask & bit) {
opt.sblur = options.sblur[i];
opt.tblur = options.tblur[i];
opt.swidth = options.swidth[i];
opt.twidth = options.twidth[i];
Imath::V3f R_(R[i], R[i + Tex::BatchWidth],
R[i + 2 * Tex::BatchWidth]);
Imath::V3f dRdx_(dRdx[i], dRdx[i + Tex::BatchWidth],
dRdx[i + 2 * Tex::BatchWidth]);
Imath::V3f dRdy_(dRdy[i], dRdy[i + Tex::BatchWidth],
dRdy[i + 2 * Tex::BatchWidth]);
if (dresultds) {
ok &= environment(texture_handle, thread_info, opt, R_, dRdx_,
dRdy_, nchannels, r, drds, drdt);
for (int c = 0; c < nchannels; ++c) {
result[c * Tex::BatchWidth + i] = r[c];
dresultds[c * Tex::BatchWidth + i] = drds[c];
dresultdt[c * Tex::BatchWidth + i] = drdt[c];
}
} else {
ok &= environment(texture_handle, thread_info, opt, R_, dRdx_,
dRdy_, nchannels, r);
for (int c = 0; c < nchannels; ++c) {
result[c * Tex::BatchWidth + i] = r[c];
}
}
}
}
return ok;
}
void eqnsys<nr_type_t>::substitute_svd (void) {
int c, r;
nr_type_t f;
// calculate U'B
for (c = 0; c < N; c++) {
f = 0.0;
// non-zero result only if S is non-zero
if (S_(c) != 0.0) {
for (r = 0; r < N; r++) f += cond_conj (U_(r, c)) * B_(r);
// this is the divide by S
f /= S_(c);
}
R_(c) = f;
}
// matrix multiply by V to get the final solution
for (r = 0; r < N; r++) {
for (f = 0.0, c = 0; c < N; c++) f += cond_conj (V_(c, r)) * R_(c);
X_(r) = f;
}
}
cv::Point2d PinholeCameraModel::unrectifyPoint(const cv::Point2d& uv_rect) const
{
assert( initialized() );
if (cache_->distortion_state == NONE)
return uv_rect;
if (cache_->distortion_state == UNKNOWN)
throw Exception("Cannot call unrectifyPoint when distortion is unknown.");
assert(cache_->distortion_state == CALIBRATED);
/// @todo Make this just call projectPixelTo3dRay followed by cv::projectPoints. But
/// cv::projectPoints requires 32-bit float, which is annoying.
// Formulae from docs for cv::initUndistortRectifyMap,
// http://opencv.willowgarage.com/documentation/cpp/camera_calibration_and_3d_reconstruction.html
// x <- (u - c'x) / f'x
// y <- (v - c'y) / f'y
// c'x, f'x, etc. (primed) come from "new camera matrix" P[0:3, 0:3].
double x = (uv_rect.x - cx() - Tx()) / fx();
double y = (uv_rect.y - cy() - Ty()) / fy();
// [X Y W]^T <- R^-1 * [x y 1]^T
double X = R_(0,0)*x + R_(1,0)*y + R_(2,0);
double Y = R_(0,1)*x + R_(1,1)*y + R_(2,1);
double W = R_(0,2)*x + R_(1,2)*y + R_(2,2);
// x' <- X/W, y' <- Y/W
double xp = X / W;
double yp = Y / W;
// x'' <- x'(1+k1*r^2+k2*r^4+k3*r^6) + 2p1*x'*y' + p2(r^2+2x'^2)
// y'' <- y'(1+k1*r^2+k2*r^4+k3*r^6) + p1(r^2+2y'^2) + 2p2*x'*y'
// where r^2 = x'^2 + y'^2
double r2 = xp*xp + yp*yp;
double r4 = r2*r2;
double r6 = r4*r2;
double a1 = 2*xp*yp;
double k1 = D_(0,0), k2 = D_(0,1), p1 = D_(0,2), p2 = D_(0,3), k3 = D_(0,4);
double barrel_correction = 1 + k1*r2 + k2*r4 + k3*r6;
if (D_.cols == 8)
barrel_correction /= (1.0 + D_(0,5)*r2 + D_(0,6)*r4 + D_(0,7)*r6);
double xpp = xp*barrel_correction + p1*a1 + p2*(r2+2*(xp*xp));
double ypp = yp*barrel_correction + p1*(r2+2*(yp*yp)) + p2*a1;
// map_x(u,v) <- x''fx + cx
// map_y(u,v) <- y''fy + cy
// cx, fx, etc. come from original camera matrix K.
return cv::Point2d(xpp*K_(0,0) + K_(0,2), ypp*K_(1,1) + K_(1,2));
}
void RenderVector(int frameNumber) {
CanvasT *canvas = R_("Canvas");
PointT *toDraw = R_("TriangleToDraw");
MatrixStack2D *ms = R_("ms2d");
float s = sin(frameNumber * 3.14159265f / 22.5f);
float c = cos(frameNumber * 3.14159265f / 45.0f);
StackReset(ms);
PushTranslation2D(ms, -1.5f, -1.5f);
PushScaling2D(ms, 20.0f + 10.0f * s, 20.0f + 10.0f * s);
PushRotation2D(ms, (float)(frameNumber * -3));
PushTranslation2D(ms, (float)(WIDTH/2) + c * (WIDTH/4), (float)(HEIGHT/2));
Transform2D(R_("CrossToDraw"), R_("Cross"), 12, GetMatrix2D(ms, 0));
if (effect == 0) {
CanvasFill(canvas, 0);
DrawPolyLine(canvas, R_("CrossToDraw"), 12, TRUE);
}
StackReset(ms);
PushTranslation2D(ms, 5.0f, 10.0f);
PushScaling2D(ms, 2.5f, 2.5f);
PushRotation2D(ms, (float)(frameNumber*5*c));
PushTranslation2D(ms, WIDTH/2 + c * 50, HEIGHT/2 + s * 20);
Transform2D(R_("TriangleToDraw"), R_("Triangle"), 3, GetMatrix2D(ms, 0));
frameNumber &= 255;
if (frameNumber < 128)
canvas->fg_col = frameNumber * 2;
else
canvas->fg_col = (255 - frameNumber) * 2;
if (effect == 1) {
DrawTriangle(canvas,
toDraw[0].x, toDraw[0].y,
toDraw[1].x, toDraw[1].y,
toDraw[2].x, toDraw[2].y);
}
if (effect == 2) {
DrawEllipse(canvas,
toDraw[1].x, toDraw[1].y,
30 + c * 15, 30 + s * 15);
}
}
void eqnsys<nr_type_t>::substitute_qrh (void) {
int c, r;
nr_type_t f;
// form the new right hand side Q'B
for (c = 0; c < N - 1; c++) {
// scalar product u_k^T * B
for (f = 0, r = c; r < N; r++) f += cond_conj (A_(r, c)) * B_(r);
// z - 2 * f * u_k
for (r = c; r < N; r++) B_(r) -= 2.0 * f * A_(r, c);
}
// backward substitution in order to solve RX = Q'B
for (r = N - 1; r >= 0; r--) {
f = B_(r);
for (c = r + 1; c < N; c++) f -= A_(r, c) * X_(cMap[c]);
if (abs (R_(r)) > std::numeric_limits<nr_double_t>::epsilon())
X_(cMap[r]) = f / R_(r);
else
X_(cMap[r]) = 0;
}
}
//QUAT2MAT - Convert a quaternion to a 3x3 rotation matrix
MatrixXf Lu::quat2mat(Vector4f q){
float a = q[1];
float b = q[2];
float c = q[3];
float d = q[4];
MatrixXf R_(3,3);
R_<< a*a+b*b-c*c-d*d, 2*(b*c-a*d), 2*(b*d+a*c),
2*(b*c+a*d), a*a+c*c-b*b-d*d, 2*(c*d-a*b),
2*(b*d-a*c), 2*(c*d+a*b), a*a+d*d-b*b-c*c;
return R_;
}
//----------------------------------------------------------------------
// driver function to draw a single element of the correlation
// matrix conditional on the variances.
void SepStratSampler::draw_R(int i, int j){
i_ = i;
j_ = j;
double oldr = R_(i,j);
double slice = logp_slice_R(oldr) - rexp();
find_limits();
double rcand = runif(lo_, hi_);
while(logp_slice_R(rcand) < slice && hi_ > lo_){
if(rcand > oldr) hi_ = rcand;
else lo_ = rcand;
rcand = runif(lo_,hi_);
}
set_R(rcand);
}
/*
* Tear down demo.
*/
void KillDemo() {
UnlinkPalettes(R_("11.pal"));
UnlinkPalettes(R_("texture-1.pal"));
UnlinkPalettes(R_("texture-2.pal"));
UnlinkPalettes(R_("texture-3.pal"));
UnlinkPalettes(R_("texture-4.pal"));
UnlinkPalettes(R_("texture-5.pal"));
AudioStreamStop(TheMusic);
MemUnref(TheMusic);
MemUnref(TheCanvas);
}
MatrixXf Camera::getXMatrix() const{
MatrixXf X(4,4);
const Vector3f t = getTranslationVector();
for (unsigned int i = 0; i < 3; i++){
for (unsigned int j = 0; j < 3; j++){
X(i,j) = R_(i,j);
}
}
for (unsigned int i = 0; i < 3; i++){
X(i,3) = t(i);
X(3,i) = 0;
}
X(3,3) = 1;
return X;
}
/*
* Set up effect function.
*/
void SetupEffect() {
PaletteT *palette = R_("Palette");
RGB *colors = palette->colors;
int i;
/* create a suitable fire palette, this is crucial for a good effect */
/* black to blue, blue to red, red to yellow, yellow to white*/
for (i = 0; i < 32; i++) {
/* black to blue, 32 values*/
colors[i].b = i << 1;
/* blue to red, 32 values*/
colors[i + 32].r = i << 3;
colors[i + 32].b = 64 - (i << 1);
/*red to yellow, 32 values*/
colors[i + 64].r = 255;
colors[i + 64].g = i << 3;
/* yellow to white, 162 */
colors[i + 96].r = 255;
colors[i + 96].g = 255;
colors[i + 96].b = i << 2;
colors[i + 128].r = 255;
colors[i + 128].g = 255;
colors[i + 128].b = 64 + (i << 2);
colors[i + 160].r = 255;
colors[i + 160].g = 255;
colors[i + 160].b = 128 + (i << 2);
colors[i + 192].r = 255;
colors[i + 192].g = 255;
colors[i + 192].b = 192 + i;
colors[i + 224].r = 255;
colors[i + 224].g = 255;
colors[i + 224].b = 224 + i;
}
LoadPalette(palette);
StartProfiling();
}
// Return the 3x3 rotation matrix described by a set of Roll, Pitch and Yaw
// angles.
MatrixXf Lu::rpyMat (Vector3f angs){
double cosA = cos (angs[2]);
double sinA = sin (angs[2]);
double cosB = cos (angs[1]);
double sinB = sin (angs[1]);
double cosC = cos (angs[0]);
double sinC = sin (angs[0]);
double cosAsinB = cosA * sinB;
double sinAsinB = sinA * sinB;
//R = [ cosA.*cosB cosAsinB.*sinC-sinA.*cosC cosAsinB.*cosC+sinA.*sinC ;
// sinA.*cosB sinAsinB.*sinC+cosA.*cosC sinAsinB.*cosC-cosA.*sinC ;
// -sinB cosB.*sinC cosB.*cosC ];
MatrixXf R_(3,3);
R_<< cosA*cosB,cosAsinB*sinC-sinA*cosC , cosAsinB*cosC+sinA*sinC , sinA*cosB, sinAsinB*sinC+cosA*cosC, sinAsinB*cosC-cosA*sinC, -sinB, cosB*sinC, cosB*cosC;
return R_;
}
//----------------------------------------------------------------------
void CS::set_r(double r) {
R_(i_, j_) = r;
R_(j_, i_) = r;
}
/*
* Set up effect function.
*/
void SetupEffect() {
CanvasFill(R_("Canvas"), 0);
}
void RenderChunky(int frameNumber) {
c2p1x1_8_c5_bm(GetCanvasPixelData(R_("Canvas")),
GetCurrentBitMap(), WIDTH, HEIGHT, 0, 0);
}
_(R32G32_FLOAT , __V_),
_(R32G32B32_FLOAT , __V_),
_(R32G32B32A32_FLOAT , __V_), //SRV_),
};
#undef _
#undef ____
#define R_(a,b) [PIPE_FORMAT_##a] = { \
.hw = NV30_3D_RT_FORMAT_COLOR_##b, \
}
#define Z_(a,b) [PIPE_FORMAT_##a] = { \
.hw = NV30_3D_RT_FORMAT_ZETA_##b, \
}
const struct nv30_format
nv30_format_table[PIPE_FORMAT_COUNT] = {
R_(B5G5R5X1_UNORM , X1R5G5B5 ),
R_(B5G6R5_UNORM , R5G6B5 ),
R_(B8G8R8X8_UNORM , X8R8G8B8 ),
R_(B8G8R8A8_UNORM , A8R8G8B8 ),
Z_(Z16_UNORM , Z16 ),
Z_(X8Z24_UNORM , Z24S8 ),
Z_(S8_UINT_Z24_UNORM , Z24S8 ),
R_(R16G16B16A16_FLOAT, A16B16G16R16_FLOAT),
R_(R32G32B32A32_FLOAT, A32B32G32R32_FLOAT),
R_(R32_FLOAT , R32_FLOAT ),
};
#define _(a,b,c) [PIPE_FORMAT_##a] = { \
.hw = NV30_3D_VTXFMT_TYPE_##b | ((c) << NV30_3D_VTXFMT_SIZE__SHIFT) \
}
const struct nv30_vtxfmt
void
SessionImpl::RegisterFileType (/*[in]*/ FileType fileType)
{
if (fileType.Get() >= fileTypes.size())
{
fileTypes.resize (FileType::E_N_D);
}
if (fileTypes[fileType.Get()].fileType == fileType.Get())
{
// already registered
return;
}
switch (fileType.Get())
{
case FileType::AFM:
RegisterFileType (
FileType::AFM,
"afm",
0,
".afm",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_AFM_DIR)),
P2_("AFMFONTS", "TEXFONTS"));
break;
case FileType::BASE:
RegisterFileType (
FileType::BASE,
"base",
"METAFONT",
".base",
P2_(CURRENT_DIRECTORY, s_(MIKTEX_PATH_BASE_DIR)),
"");
break;
case FileType::BIB:
RegisterFileType (
FileType::BIB,
"bib",
"BibTeX",
".bib",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/bib")),
P2_("BIBINPUTS", "TEXBIB"));
break;
case FileType::BST:
RegisterFileType (
FileType::BST,
"bst",
"BibTeX",
".bst",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/{bst,csf}")),
"BSTINPUTS");
break;
case FileType::CID:
RegisterFileType (
FileType::CID,
"cid maps",
0,
P2_(".cid", ".cidmap"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CIDMAP_DIR)),
"FONTCIDMAPS");
break;
case FileType::CLUA:
RegisterFileType (
FileType::CLUA,
"clua",
0,
P2_(".dll", ".so"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}/lua")),
"CLUAINPUTS");
break;
case FileType::CNF:
RegisterFileType (
FileType::CNF,
"cnf",
0,
".cnf",
S_(MIKTEX_PATH_WEB2C_DIR),
"TEXMFCNF");
break;
case FileType::CMAP:
RegisterFileType (
FileType::CMAP,
"cmap files",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CMAP_DIR)),
P2_("CMAPFONTS", "TEXFONTS"));
break;
case FileType::CWEB:
RegisterFileType (
FileType::CWEB,
"cweb",
"CWeb",
".w",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CWEB_DIR)),
"CWEBINPUTS");
break;
case FileType::DB:
RegisterFileType (
FileType::DB,
"ls-R",
0,
"",
"",
"TEXMFDBS");
break;
case FileType::DVI:
RegisterFileType (
FileType::DVI,
"dvi",
0,
".dvi",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_DOC_DIR)),
"");
break;
case FileType::DVIPSCONFIG:
RegisterFileType (
FileType::DVIPSCONFIG,
"dvips config",
"Dvips",
"",
R_(MIKTEX_PATH_DVIPS_DIR),
"TEXCONFIG");
break;
case FileType::ENC:
RegisterFileType (
FileType::ENC,
"enc",
0,
".enc",
P6_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_ENC_DIR),
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR)),
P2_("ENCFONTS", "TEXFONTS"));
break;
case FileType::EXE:
#if defined(MIKTEX_WINDOWS)
case FileType::WindowsCommandScriptFile:
#endif
{
string extensions;
#if defined(MIKTEX_WINDOWS)
if (! Utils::GetEnvironmentString("PATHEXT", extensions)
|| extensions.empty())
{
extensions = P3_(".com",".exe", ".bat");
}
#elif defined(MIKTEX_EXE_FILE_SUFFIX)
extensions = MIKTEX_EXE_FILE_SUFFIX;
#endif
string exePath;
PathName userBinDir = GetSpecialPath(SpecialPath::UserInstallRoot);
userBinDir += MIKTEX_PATH_BIN_DIR;
userBinDir.Canonicalize ();
if (! IsAdminMode()
&& ! Utils::Contains(exePath.c_str(),
userBinDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += userBinDir.Get();
}
PathName commonBinDir = GetSpecialPath(SpecialPath::CommonInstallRoot);
commonBinDir += MIKTEX_PATH_BIN_DIR;
commonBinDir.Canonicalize ();
if (! Utils::Contains(exePath.c_str(),
commonBinDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += commonBinDir.Get();
}
string str;
if (Utils::GetEnvironmentString(MIKTEX_ENV_BIN_DIR, str))
{
PathName binDir = str;
binDir.Canonicalize ();
if (! Utils::Contains(exePath.c_str(),
binDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += binDir.Get();
}
}
PathName myLocation = GetMyLocation(true);
if (! Utils::Contains(exePath.c_str(),
myLocation.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += myLocation.Get();
}
if (fileType.Get() == FileType::EXE)
{
RegisterFileType (
FileType::EXE,
"exe",
0,
extensions.c_str(),
exePath.c_str(),
"");
}
#if defined(MIKTEX_WINDOWS)
else if (fileType.Get() == FileType::WindowsCommandScriptFile)
{
RegisterFileType (
FileType::WindowsCommandScriptFile,
"Windows command script file",
0,
P2_(".bat", ".cmd"),
P_(R_(MIKTEX_PATH_SCRIPT_DIR), exePath.c_str()),
"");
}
#endif
break;
}
case FileType::FEA:
RegisterFileType (
FileType::FEA,
"font feature files",
0,
".fea",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_FEATURE_DIR)),
"FONTFEATURES");
break;
case FileType::FMT:
RegisterFileType (
FileType::FMT,
"fmt",
"TeX",
".fmt",
P2_(CURRENT_DIRECTORY, s_(MIKTEX_PATH_FMT_DIR "/{$engine,}")),
"");
break;
case FileType::GF:
RegisterFileType (
FileType::GF,
"gf",
0,
".gf",
// <todo>
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
// <todo/>
P3_("GFFONTS", "GLYPHFONTS", "TEXFONTS"));
break;
case FileType::GLYPHFONT:
RegisterFileType (
FileType::GLYPHFONT,
"bitmap font",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
P2_("GLYPHFONTS", "TEXFONTS"));
break;
case FileType::GRAPHICS:
RegisterFileType (
FileType::GRAPHICS,
"graphic/figure",
0,
P3_(".eps", ".epsi",".png"),
P4_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_TEX_DIR)),
P2_("TEXPICTS", "TEXINPUTS"));
break;
case FileType::HBF:
RegisterFileType (
FileType::HBF,
"hbf",
0,
".hbf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_HBF_DIR),
R_(MIKTEX_PATH_TYPE1_DIR)),
"");
break;
case FileType::IST:
RegisterFileType (
FileType::IST,
"ist",
"MakeIndex",
".ist",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MAKEINDEX_DIR)),
P2_("TEXINDEXSTYLE", "INDEXSTYLE"));
break;
case FileType::LIG:
RegisterFileType (
FileType::LIG,
"lig files",
0,
".lig",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_LIG_DIR)),
"TEXFONTS");
break;
case FileType::LUA:
RegisterFileType (
FileType::LUA,
"lua",
0,
P7_(".lua", ".luatex", ".luc", ".luctex", ".texlua", ".texluc", ".tlu"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}/{lua,}"),
GetFileTypeInfo(FileType::TEX).searchPath.c_str()),
"LUAINPUTS");
break;
case FileType::MAP:
RegisterFileType (
FileType::MAP,
"map",
0,
".map",
P6_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_MAP_DIR "/{$progname,pdftex,dvips,}"),
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR)),
P2_("TEXFONTMAPS", "TEXFONTS"));
break;
case FileType::MEM:
RegisterFileType (
FileType::MEM,
"mem",
"MetaPost",
".mem",
CURRENT_DIRECTORY,
"");
break;
case FileType::MF:
RegisterFileType (
FileType::MF,
"mf",
"METAFONT",
".mf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_METAFONT_DIR),
R_(MIKTEX_PATH_FONT_SOURCE_DIR)),
"MFINPUTS");
break;
case FileType::MFPOOL:
RegisterFileType (
FileType::MFPOOL,
"mfpool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("MFPOOL", "TEXMFINI"));
break;
case FileType::MFT:
RegisterFileType (
FileType::MFT,
"mft",
0,
".mft",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MFT_DIR)),
"MFTINPUTS");
break;
case FileType::MISCFONT:
RegisterFileType (
FileType::MISCFONT,
"misc fonts",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MISCFONTS_DIR)),
P2_("MISCFONTS","TEXFONTS"));
break;
case FileType::MLBIB:
RegisterFileType (
FileType::MLBIB,
"mlbib",
0,
P2_(".mlbib", ".bib"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/bib/{mlbib,}")),
P3_("MLBIBINPUTS", "BIBINPUTS", "TEXBIB"));
break;
case FileType::MLBST:
RegisterFileType (
FileType::MLBST,
"mlbst",
0,
".bst",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/{mlbst,bst}")),
P2_( "MLBSTINPUTS", "BSTINPUTS"));
break;
case FileType::MP:
RegisterFileType (
FileType::MP,
"mp",
"MetaPost",
".mp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_METAPOST_DIR)),
"MPINPUTS");
break;
case FileType::MPPOOL:
RegisterFileType (
FileType::MPPOOL,
"mppool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("MPPOOL", "TEXMFINI"));
break;
case FileType::MPSUPPORT:
RegisterFileType (
FileType::MPSUPPORT,
"MetaPost support",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MPSUPPORT_DIR)),
"MPSUPPORT");
break;
case FileType::OCP:
RegisterFileType (
FileType::OCP,
"ocp",
"Omega",
".ocp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OCP_DIR)),
"OCPINPUTS");
break;
case FileType::OFM:
RegisterFileType (
FileType::OFM,
"ofm",
"Omega",
P2_(".ofm", ".tfm"),
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OFM_DIR),
R_(MIKTEX_PATH_TFM_DIR)),
P2_("OFMFONTS", "TEXFONTS"));
break;
case FileType::OPL:
RegisterFileType (
FileType::OPL,
"opl",
0,
".opl",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OPL_DIR)),
P2_("OPLFONTS", "TEXFONTS"));
break;
case FileType::OTP:
RegisterFileType (
FileType::OTP,
"otp",
"otp2ocp",
".otp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OTP_DIR)),
"OTPINPUTS");
break;
case FileType::OTF:
RegisterFileType (
FileType::OTF,
"opentype fonts",
0,
".otf",
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OPENTYPE_DIR),
GetLocalFontDirectories().c_str()),
P2_("OPENTYPEFONTS", "TEXFONTS"));
break;
case FileType::OVF:
RegisterFileType (
FileType::OVF,
"ovf",
0,
".ovf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OVF_DIR),
R_(MIKTEX_PATH_VF_DIR)),
P2_("OVFFONTS", "TEXFONTS"));
break;
case FileType::OVP:
RegisterFileType (
FileType::OVP,
"ovp",
0,
".ovp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OVP_DIR)),
P2_("OVPFONTS", "TEXFONTS"));
break;
case FileType::PDFTEXCONFIG:
RegisterFileType (
FileType::PDFTEXCONFIG,
"pdftex config",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_PDFTEX_DIR "/{$progname,}")),
"PDFTEXCONFIG");
break;
case FileType::PERLSCRIPT:
RegisterFileType (
FileType::PERLSCRIPT,
"perlscript",
0,
".pl",
P8_(R_(MIKTEX_PATH_SCRIPT_DIR),
R_(MIKTEX_PATH_CONTEXT_DIR),
R_(MIKTEX_PATH_MIKTEX_DIR),
R_(MIKTEX_PATH_NTS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_PSUTILS_DIR),
R_(MIKTEX_PATH_SOURCE_DIR),
R_(MIKTEX_PATH_TEX_DIR)),
"");
break;
case FileType::PK:
RegisterFileType (
FileType::PK,
"pk",
0,
".pk",
// <todo>
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
// </todo>
"");
break;
case FileType::PROGRAMBINFILE:
RegisterFileType (
FileType::PROGRAMBINFILE,
"other binary files",
0,
"",
P2_(CURRENT_DIRECTORY, R_("/$progname")),
"");
break;
case FileType::PROGRAMTEXTFILE:
RegisterFileType (
FileType::PROGRAMTEXTFILE,
"other text files",
0,
"",
P2_(CURRENT_DIRECTORY, R_("/$progname")),
"");
break;
case FileType::PSHEADER:
RegisterFileType (
FileType::PSHEADER,
"PostScript header",
0,
P2_(".pro", ".enc"),
P10_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR),
R_(MIKTEX_PATH_ENC_DIR),
R_(MIKTEX_PATH_TYPE1_DIR),
R_(MIKTEX_PATH_TYPE42_DIR),
R_(MIKTEX_PATH_TYPE3_DIR),
"$psfontdirs"),
P2_("TEXPSHEADERS", "PSHEADERS"));
break;
case FileType::SCRIPT:
RegisterFileType (
FileType::SCRIPT,
"texmfscripts",
0,
"",
R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}"),
"TEXMFSCRIPTS");
break;
case FileType::SFD:
RegisterFileType (
FileType::SFD,
"subfont definition files",
0,
".sfd",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SFD_DIR)),
P2_("SFDFONTS", "TEXFONTS"));
break;
case FileType::TCX:
RegisterFileType (
FileType::TCX,
"tcx",
0,
".tcx",
P3_(CURRENT_DIRECTORY,
S_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
S_(MIKTEX_PATH_WEB2C_DIR)),
"");
break;
case FileType::TEX:
RegisterFileType (
FileType::TEX,
"tex",
"TeX",
".tex",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TEX_DIR "/{$progname,generic,}")),
"TEXINPUTS");
break;
case FileType::TEXPOOL:
RegisterFileType (
FileType::TEXPOOL,
"texpool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("TEXPOOL", "TEXMFINI"));
break;
case FileType::TEXSOURCE:
RegisterFileType (
FileType::TEXSOURCE,
"TeX system sources",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SOURCE_DIR)),
"TEXSOURCES");
break;
case FileType::TEXSYSDOC:
RegisterFileType (
FileType::TEXSYSDOC,
"TeX system documentation",
0,
#if defined(MIKTEX_WINDOWS)
P6_(".chm", ".dvi", ".html", ".txt", ".pdf", ".ps"),
#else
P5_(".dvi", ".html", ".txt", ".pdf", ".ps"),
#endif
P2_(R_(MIKTEX_PATH_MIKTEX_DOC_DIR),
R_(MIKTEX_PATH_DOC_DIR)),
"TEXDOCS");
break;
case FileType::TFM:
RegisterFileType (
FileType::TFM,
"tfm",
0,
".tfm",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TFM_DIR)),
P2_("TFMFONTS", "TEXFONTS"));
break;
case FileType::TROFF:
RegisterFileType (
FileType::TROFF,
"troff fonts",
0,
"",
"",
"TRFONTS");
break;
case FileType::TTF:
RegisterFileType (
FileType::TTF,
"truetype fonts",
0,
P2_(".ttf", ".ttc"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_TRUETYPE_DIR),
GetLocalFontDirectories().c_str()),
P2_("TTFONTS", "TEXFONTS"));
break;
case FileType::TYPE1:
RegisterFileType (
FileType::TYPE1,
"type1 fonts",
0,
P2_(".pfb", ".pfa"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_TYPE1_DIR),
GetLocalFontDirectories().c_str()),
P5_("T1FONTS", "T1INPUTS", "TEXFONTS", "TEXPSHEADERS", "PSHEADERS"));
break;
case FileType::TYPE42:
RegisterFileType (
FileType::TYPE42,
"type42 fonts",
0,
#if defined(MIKTEX_WINDOWS)
".t42",
#else
P2_(".t42", ".T42"),
#endif
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TYPE42_DIR)),
P2_("T42FONTS", "TEXFONTS"));
break;
case FileType::VF:
RegisterFileType (
FileType::VF,
"vf",
0,
".vf",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_VF_DIR)),
P2_("VFFONTS", "TEXFONTS"));
break;
case FileType::WEB:
RegisterFileType (
FileType::WEB,
"web",
0,
".web",
R_(MIKTEX_PATH_WEB_DIR),
"WEBINPUTS");
break;
case FileType::WEB2C:
RegisterFileType (
FileType::WEB2C,
"web2c files",
0,
"",
R_(MIKTEX_PATH_WEB2C_DIR),
"");
break;
default:
UNEXPECTED_CONDITION ("SessionImpl::RegisterFileType");
}
}
#include "ast-walk.h"
#include "ast-ids-priv.h"
#include "ast-formatters.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static const char *flags_names[] = {
#define R_(X) [AST_WALK_##X] = #X,
R_(BEFORE_CHILDREN)
R_(AFTER_CHILDREN)
R_(BETWEEN_CHILDREN)
#undef R_
};
static const char *meta_names[] = {
#define R_(X) [META_IS_##X] = #X,
R_(INVALID)
R_(NODE)
R_(ID)
R_(CHOICE)
R_(PRIV)
R_(BASIC)
#undef R_
};
struct mydata {
int indent;
};
/*
* Set up effect function.
*/
void SetupEffect() {
PixBufClear(R_("Canvas"));
LoadPalette(R_("Palette"));
StartProfiling();
}
int
main(
int argc,
char **argv)
{
DECLARE("AST_URGENT", AST_URGENT);
DECLARE("AST_BSD", AST_BSD);
/* Simple Lock structure */
DECLARE("SLOCK_ILK", offsetof(usimple_lock_t, interlock));
#if MACH_LDEBUG
DECLARE("SLOCK_TYPE", offsetof(usimple_lock_t, lock_type));
DECLARE("SLOCK_PC", offsetof(usimple_lock_t, debug.lock_pc));
DECLARE("SLOCK_THREAD", offsetof(usimple_lock_t, debug.lock_thread));
DECLARE("SLOCK_DURATIONH",offsetof(usimple_lock_t, debug.duration[0]));
DECLARE("SLOCK_DURATIONL",offsetof(usimple_lock_t, debug.duration[1]));
DECLARE("USLOCK_TAG", USLOCK_TAG);
#endif /* MACH_LDEBUG */
/* Mutex structure */
DECLARE("MUTEX_OWNER", offsetof(lck_mtx_t *, lck_mtx_owner));
DECLARE("MUTEX_PTR", offsetof(lck_mtx_t *, lck_mtx_ptr));
DECLARE("MUTEX_STATE", offsetof(lck_mtx_t *, lck_mtx_state));
#ifdef __i386__
DECLARE("MUTEX_TYPE", offsetof(lck_mtx_ext_t *, lck_mtx_deb.type));
DECLARE("MUTEX_PC", offsetof(lck_mtx_ext_t *, lck_mtx_deb.pc));
DECLARE("MUTEX_THREAD", offsetof(lck_mtx_ext_t *, lck_mtx_deb.thread));
DECLARE("MUTEX_ATTR", offsetof(lck_mtx_ext_t *, lck_mtx_attr));
DECLARE("MUTEX_ATTR_DEBUG", LCK_MTX_ATTR_DEBUG);
DECLARE("MUTEX_ATTR_DEBUGb", LCK_MTX_ATTR_DEBUGb);
DECLARE("MUTEX_ATTR_STAT", LCK_MTX_ATTR_STAT);
DECLARE("MUTEX_ATTR_STATb", LCK_MTX_ATTR_STATb);
DECLARE("MUTEX_TAG", MUTEX_TAG);
#endif
DECLARE("MUTEX_IND", LCK_MTX_TAG_INDIRECT);
DECLARE("MUTEX_EXT", LCK_MTX_PTR_EXTENDED);
DECLARE("MUTEX_ITAG", offsetof(lck_mtx_t *, lck_mtx_tag));
DECLARE("MUTEX_PTR", offsetof(lck_mtx_t *, lck_mtx_ptr));
DECLARE("MUTEX_ASSERT_OWNED", LCK_MTX_ASSERT_OWNED);
DECLARE("MUTEX_ASSERT_NOTOWNED",LCK_MTX_ASSERT_NOTOWNED);
DECLARE("GRP_MTX_STAT_UTIL", offsetof(lck_grp_t *, lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_util_cnt));
DECLARE("GRP_MTX_STAT_MISS", offsetof(lck_grp_t *, lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_miss_cnt));
DECLARE("GRP_MTX_STAT_WAIT", offsetof(lck_grp_t *, lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_wait_cnt));
/* x86 only */
DECLARE("MUTEX_DESTROYED", LCK_MTX_TAG_DESTROYED);
/* Per-mutex statistic element */
DECLARE("MTX_ACQ_TSC", offsetof(lck_mtx_ext_t *, lck_mtx_stat));
/* Mutex group statistics elements */
DECLARE("MUTEX_GRP", offsetof(lck_mtx_ext_t *, lck_mtx_grp));
/*
* The use of this field is somewhat at variance with the alias.
*/
DECLARE("GRP_MTX_STAT_DIRECT_WAIT", offsetof(lck_grp_t *, lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_held_cnt));
DECLARE("GRP_MTX_STAT_HELD_MAX", offsetof(lck_grp_t *, lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_held_max));
/* Reader writer lock types */
DECLARE("RW_SHARED", LCK_RW_TYPE_SHARED);
DECLARE("RW_EXCL", LCK_RW_TYPE_EXCLUSIVE);
DECLARE("TH_RECOVER", offsetof(thread_t, recover));
DECLARE("TH_CONTINUATION", offsetof(thread_t, continuation));
DECLARE("TH_KERNEL_STACK", offsetof(thread_t, kernel_stack));
DECLARE("TASK_MACH_EXC_PORT",
offsetof(task_t, exc_actions[EXC_MACH_SYSCALL].port));
DECLARE("TASK_SYSCALLS_MACH", offsetof(struct task *, syscalls_mach));
DECLARE("TASK_SYSCALLS_UNIX", offsetof(struct task *, syscalls_unix));
DECLARE("TASK_VTIMERS", offsetof(struct task *, vtimers));
/* These fields are being added on demand */
DECLARE("ACT_MACH_EXC_PORT",
offsetof(thread_t, exc_actions[EXC_MACH_SYSCALL].port));
DECLARE("ACT_TASK", offsetof(thread_t, task));
DECLARE("ACT_AST", offsetof(thread_t, ast));
DECLARE("ACT_PCB", offsetof(thread_t, machine.pcb));
DECLARE("ACT_SPF", offsetof(thread_t, machine.specFlags));
DECLARE("ACT_MAP", offsetof(thread_t, map));
DECLARE("ACT_PCB_ISS", offsetof(thread_t, machine.xxx_pcb.iss));
DECLARE("ACT_PCB_IDS", offsetof(thread_t, machine.xxx_pcb.ids));
#if NCOPY_WINDOWS > 0
DECLARE("ACT_COPYIO_STATE", offsetof(thread_t, machine.copyio_state));
DECLARE("WINDOWS_CLEAN", WINDOWS_CLEAN);
#endif
DECLARE("MAP_PMAP", offsetof(vm_map_t, pmap));
#define IEL_SIZE (sizeof(struct i386_exception_link *))
DECLARE("IEL_SIZE", IEL_SIZE);
DECLARE("IKS_SIZE", sizeof(struct x86_kernel_state));
/*
* KSS_* are offsets from the top of the kernel stack (cpu_kernel_stack)
*/
#if defined(__i386__)
DECLARE("KSS_EBX", IEL_SIZE + offsetof(struct x86_kernel_state *, k_ebx));
DECLARE("KSS_ESP", IEL_SIZE + offsetof(struct x86_kernel_state *, k_esp));
DECLARE("KSS_EBP", IEL_SIZE + offsetof(struct x86_kernel_state *, k_ebp));
DECLARE("KSS_EDI", IEL_SIZE + offsetof(struct x86_kernel_state *, k_edi));
DECLARE("KSS_ESI", IEL_SIZE + offsetof(struct x86_kernel_state *, k_esi));
DECLARE("KSS_EIP", IEL_SIZE + offsetof(struct x86_kernel_state *, k_eip));
#elif defined(__x86_64__)
DECLARE("KSS_RBX", IEL_SIZE + offsetof(struct x86_kernel_state *, k_rbx));
DECLARE("KSS_RSP", IEL_SIZE + offsetof(struct x86_kernel_state *, k_rsp));
DECLARE("KSS_RBP", IEL_SIZE + offsetof(struct x86_kernel_state *, k_rbp));
DECLARE("KSS_R12", IEL_SIZE + offsetof(struct x86_kernel_state *, k_r12));
DECLARE("KSS_R13", IEL_SIZE + offsetof(struct x86_kernel_state *, k_r13));
DECLARE("KSS_R14", IEL_SIZE + offsetof(struct x86_kernel_state *, k_r14));
DECLARE("KSS_R15", IEL_SIZE + offsetof(struct x86_kernel_state *, k_r15));
DECLARE("KSS_RIP", IEL_SIZE + offsetof(struct x86_kernel_state *, k_rip));
#else
#error Unsupported architecture
#endif
DECLARE("PCB_FPS", offsetof(pcb_t, ifps));
DECLARE("PCB_ISS", offsetof(pcb_t, iss));
DECLARE("DS_DR0", offsetof(struct x86_debug_state32 *, dr0));
DECLARE("DS_DR1", offsetof(struct x86_debug_state32 *, dr1));
DECLARE("DS_DR2", offsetof(struct x86_debug_state32 *, dr2));
DECLARE("DS_DR3", offsetof(struct x86_debug_state32 *, dr3));
DECLARE("DS_DR4", offsetof(struct x86_debug_state32 *, dr4));
DECLARE("DS_DR5", offsetof(struct x86_debug_state32 *, dr5));
DECLARE("DS_DR6", offsetof(struct x86_debug_state32 *, dr6));
DECLARE("DS_DR7", offsetof(struct x86_debug_state32 *, dr7));
DECLARE("DS64_DR0", offsetof(struct x86_debug_state64 *, dr0));
DECLARE("DS64_DR1", offsetof(struct x86_debug_state64 *, dr1));
DECLARE("DS64_DR2", offsetof(struct x86_debug_state64 *, dr2));
DECLARE("DS64_DR3", offsetof(struct x86_debug_state64 *, dr3));
DECLARE("DS64_DR4", offsetof(struct x86_debug_state64 *, dr4));
DECLARE("DS64_DR5", offsetof(struct x86_debug_state64 *, dr5));
DECLARE("DS64_DR6", offsetof(struct x86_debug_state64 *, dr6));
DECLARE("DS64_DR7", offsetof(struct x86_debug_state64 *, dr7));
DECLARE("FP_VALID", offsetof(struct x86_fpsave_state *,fp_valid));
DECLARE("SS_FLAVOR", offsetof(x86_saved_state_t *, flavor));
DECLARE("SS_32", x86_SAVED_STATE32);
DECLARE("SS_64", x86_SAVED_STATE64);
#define R_(x) offsetof(x86_saved_state_t *, ss_32.x)
DECLARE("R32_CS", R_(cs));
DECLARE("R32_SS", R_(ss));
DECLARE("R32_DS", R_(ds));
DECLARE("R32_ES", R_(es));
DECLARE("R32_FS", R_(fs));
DECLARE("R32_GS", R_(gs));
DECLARE("R32_UESP", R_(uesp));
DECLARE("R32_EBP", R_(ebp));
DECLARE("R32_EAX", R_(eax));
DECLARE("R32_EBX", R_(ebx));
DECLARE("R32_ECX", R_(ecx));
DECLARE("R32_EDX", R_(edx));
DECLARE("R32_ESI", R_(esi));
DECLARE("R32_EDI", R_(edi));
DECLARE("R32_TRAPNO", R_(trapno));
DECLARE("R32_ERR", R_(err));
DECLARE("R32_EFLAGS", R_(efl));
DECLARE("R32_EIP", R_(eip));
DECLARE("R32_CR2", R_(cr2));
DECLARE("ISS32_SIZE", sizeof (x86_saved_state32_t));
#define R64_(x) offsetof(x86_saved_state_t *, ss_64.x)
DECLARE("R64_FS", R64_(fs));
DECLARE("R64_GS", R64_(gs));
DECLARE("R64_R8", R64_(r8));
DECLARE("R64_R9", R64_(r9));
DECLARE("R64_R10", R64_(r10));
DECLARE("R64_R11", R64_(r11));
DECLARE("R64_R12", R64_(r12));
DECLARE("R64_R13", R64_(r13));
DECLARE("R64_R14", R64_(r14));
DECLARE("R64_R15", R64_(r15));
DECLARE("R64_RBP", R64_(rbp));
DECLARE("R64_RAX", R64_(rax));
DECLARE("R64_RBX", R64_(rbx));
DECLARE("R64_RCX", R64_(rcx));
DECLARE("R64_RDX", R64_(rdx));
DECLARE("R64_RSI", R64_(rsi));
DECLARE("R64_RDI", R64_(rdi));
DECLARE("R64_V_ARG6", R64_(v_arg6));
DECLARE("R64_V_ARG7", R64_(v_arg7));
DECLARE("R64_V_ARG8", R64_(v_arg8));
DECLARE("R64_CS", R64_(isf.cs));
DECLARE("R64_SS", R64_(isf.ss));
DECLARE("R64_RSP", R64_(isf.rsp));
DECLARE("R64_TRAPNO", R64_(isf.trapno));
DECLARE("R64_TRAPFN", R64_(isf.trapfn));
DECLARE("R64_ERR", R64_(isf.err));
DECLARE("R64_RFLAGS", R64_(isf.rflags));
DECLARE("R64_RIP", R64_(isf.rip));
DECLARE("R64_CR2", R64_(cr2));
DECLARE("ISS64_OFFSET", R64_(isf));
DECLARE("ISS64_SIZE", sizeof (x86_saved_state64_t));
#define ISF64_(x) offsetof(x86_64_intr_stack_frame_t *, x)
DECLARE("ISF64_TRAPNO", ISF64_(trapno));
DECLARE("ISF64_TRAPFN", ISF64_(trapfn));
DECLARE("ISF64_ERR", ISF64_(err));
DECLARE("ISF64_RIP", ISF64_(rip));
DECLARE("ISF64_CS", ISF64_(cs));
DECLARE("ISF64_RFLAGS", ISF64_(rflags));
DECLARE("ISF64_RSP", ISF64_(rsp));
DECLARE("ISF64_SS", ISF64_(ss));
DECLARE("ISF64_SIZE", sizeof(x86_64_intr_stack_frame_t));
DECLARE("ISC32_OFFSET", offsetof(x86_saved_state_compat32_t *, isf64));
#define ISC32_(x) offsetof(x86_saved_state_compat32_t *, isf64.x)
DECLARE("ISC32_TRAPNO", ISC32_(trapno));
DECLARE("ISC32_TRAPFN", ISC32_(trapfn));
DECLARE("ISC32_ERR", ISC32_(err));
DECLARE("ISC32_RIP", ISC32_(rip));
DECLARE("ISC32_CS", ISC32_(cs));
DECLARE("ISC32_RFLAGS", ISC32_(rflags));
DECLARE("ISC32_RSP", ISC32_(rsp));
DECLARE("ISC32_SS", ISC32_(ss));
DECLARE("NBPG", I386_PGBYTES);
DECLARE("PAGE_SIZE", I386_PGBYTES);
DECLARE("PAGE_MASK", I386_PGBYTES-1);
DECLARE("PAGE_SHIFT", 12);
DECLARE("NKPT", NKPT);
#ifdef __i386__
DECLARE("KPTDI", KPTDI);
#endif
DECLARE("VM_MIN_ADDRESS", VM_MIN_ADDRESS);
DECLARE("VM_MAX_ADDRESS", VM_MAX_ADDRESS);
DECLARE("KERNELBASE", VM_MIN_KERNEL_ADDRESS);
DECLARE("LINEAR_KERNELBASE", LINEAR_KERNEL_ADDRESS);
DECLARE("KERNEL_STACK_SIZE", KERNEL_STACK_SIZE);
#ifdef __i386__
DECLARE("KERNEL_UBER_BASE_HI32", KERNEL_UBER_BASE_HI32);
#endif
DECLARE("ASM_COMM_PAGE32_BASE_ADDRESS", _COMM_PAGE32_BASE_ADDRESS);
DECLARE("ASM_COMM_PAGE32_START_ADDRESS", _COMM_PAGE32_START_ADDRESS);
DECLARE("ASM_COMM_PAGE_SCHED_GEN", _COMM_PAGE_SCHED_GEN);
DECLARE("PDESHIFT", PDESHIFT);
DECLARE("PTEMASK", PTEMASK);
DECLARE("PTEINDX", PTEINDX);
DECLARE("INTEL_PTE_PFN", INTEL_PTE_PFN);
DECLARE("INTEL_PTE_VALID", INTEL_PTE_VALID);
DECLARE("INTEL_PTE_WRITE", INTEL_PTE_WRITE);
DECLARE("INTEL_PTE_PS", INTEL_PTE_PS);
DECLARE("INTEL_PTE_USER", INTEL_PTE_USER);
DECLARE("INTEL_PTE_INVALID", INTEL_PTE_INVALID);
DECLARE("NPGPTD", NPGPTD);
#if defined(__x86_64__)
DECLARE("INITPT_SEG_BASE",INITPT_SEG_BASE);
DECLARE("INITGDT_SEG_BASE",INITGDT_SEG_BASE);
DECLARE("SLEEP_SEG_BASE",SLEEP_SEG_BASE);
DECLARE("PROT_MODE_GDT_SIZE",PROT_MODE_GDT_SIZE);
DECLARE("KERNEL_PML4_INDEX",KERNEL_PML4_INDEX);
#endif
DECLARE("IDTSZ", IDTSZ);
DECLARE("GDTSZ", GDTSZ);
DECLARE("LDTSZ", LDTSZ);
DECLARE("KERNEL_DS", KERNEL_DS);
DECLARE("USER_CS", USER_CS);
DECLARE("USER_DS", USER_DS);
DECLARE("KERNEL32_CS", KERNEL32_CS);
DECLARE("KERNEL64_CS", KERNEL64_CS);
DECLARE("USER64_CS", USER64_CS);
DECLARE("KERNEL_TSS", KERNEL_TSS);
DECLARE("KERNEL_LDT", KERNEL_LDT);
#ifdef __i386__
DECLARE("DF_TSS", DF_TSS);
DECLARE("MC_TSS", MC_TSS);
#if MACH_KDB
DECLARE("DEBUG_TSS", DEBUG_TSS);
#endif /* MACH_KDB */
DECLARE("CPU_DATA_GS", CPU_DATA_GS);
#endif /* __i386__ */
DECLARE("SYSENTER_CS", SYSENTER_CS);
DECLARE("SYSENTER_TF_CS",SYSENTER_TF_CS);
DECLARE("SYSENTER_DS", SYSENTER_DS);
DECLARE("SYSCALL_CS", SYSCALL_CS);
#ifdef __i386__
DECLARE("USER_WINDOW_SEL", USER_WINDOW_SEL);
DECLARE("PHYS_WINDOW_SEL", PHYS_WINDOW_SEL);
#endif
DECLARE("CPU_THIS",
offsetof(cpu_data_t *, cpu_this));
DECLARE("CPU_ACTIVE_THREAD",
offsetof(cpu_data_t *, cpu_active_thread));
DECLARE("CPU_ACTIVE_STACK",
offsetof(cpu_data_t *, cpu_active_stack));
DECLARE("CPU_KERNEL_STACK",
offsetof(cpu_data_t *, cpu_kernel_stack));
DECLARE("CPU_INT_STACK_TOP",
offsetof(cpu_data_t *, cpu_int_stack_top));
#if MACH_RT
DECLARE("CPU_PREEMPTION_LEVEL",
offsetof(cpu_data_t *, cpu_preemption_level));
#endif /* MACH_RT */
DECLARE("CPU_HIBERNATE",
offsetof(cpu_data_t *, cpu_hibernate));
DECLARE("CPU_INTERRUPT_LEVEL",
offsetof(cpu_data_t *, cpu_interrupt_level));
DECLARE("CPU_SIMPLE_LOCK_COUNT",
offsetof(cpu_data_t *,cpu_simple_lock_count));
DECLARE("CPU_NUMBER_GS",
offsetof(cpu_data_t *,cpu_number));
DECLARE("CPU_RUNNING",
offsetof(cpu_data_t *,cpu_running));
DECLARE("CPU_MCOUNT_OFF",
offsetof(cpu_data_t *,cpu_mcount_off));
DECLARE("CPU_PENDING_AST",
offsetof(cpu_data_t *,cpu_pending_ast));
DECLARE("CPU_DESC_TABLEP",
offsetof(cpu_data_t *,cpu_desc_tablep));
DECLARE("CPU_DESC_INDEX",
offsetof(cpu_data_t *,cpu_desc_index));
DECLARE("CDI_GDT",
offsetof(cpu_desc_index_t *,cdi_gdt));
DECLARE("CDI_IDT",
offsetof(cpu_desc_index_t *,cdi_idt));
DECLARE("CPU_PROCESSOR",
offsetof(cpu_data_t *,cpu_processor));
DECLARE("CPU_INT_STATE",
offsetof(cpu_data_t *, cpu_int_state));
DECLARE("CPU_INT_EVENT_TIME",
offsetof(cpu_data_t *, cpu_int_event_time));
#ifdef __i386__
DECLARE("CPU_HI_ISS",
offsetof(cpu_data_t *, cpu_hi_iss));
#endif
DECLARE("CPU_TASK_CR3",
offsetof(cpu_data_t *, cpu_task_cr3));
DECLARE("CPU_ACTIVE_CR3",
offsetof(cpu_data_t *, cpu_active_cr3));
DECLARE("CPU_KERNEL_CR3",
offsetof(cpu_data_t *, cpu_kernel_cr3));
#ifdef __x86_64__
DECLARE("CPU_TLB_INVALID",
offsetof(cpu_data_t *, cpu_tlb_invalid));
#endif
DECLARE("CPU_IS64BIT",
offsetof(cpu_data_t *, cpu_is64bit));
DECLARE("CPU_TASK_MAP",
offsetof(cpu_data_t *, cpu_task_map));
DECLARE("TASK_MAP_32BIT", TASK_MAP_32BIT);
DECLARE("TASK_MAP_64BIT", TASK_MAP_64BIT);
#ifdef __i386__
DECLARE("TASK_MAP_64BIT_SHARED", TASK_MAP_64BIT_SHARED);
#endif
DECLARE("CPU_UBER_USER_GS_BASE",
offsetof(cpu_data_t *, cpu_uber.cu_user_gs_base));
DECLARE("CPU_UBER_ISF",
offsetof(cpu_data_t *, cpu_uber.cu_isf));
DECLARE("CPU_UBER_TMP",
offsetof(cpu_data_t *, cpu_uber.cu_tmp));
DECLARE("CPU_UBER_ARG_STORE",
offsetof(cpu_data_t *, cpu_uber_arg_store));
DECLARE("CPU_UBER_ARG_STORE_VALID",
offsetof(cpu_data_t *, cpu_uber_arg_store_valid));
DECLARE("CPU_NANOTIME",
offsetof(cpu_data_t *, cpu_nanotime));
DECLARE("CPU_DR7",
offsetof(cpu_data_t *, cpu_dr7));
DECLARE("hwIntCnt", offsetof(cpu_data_t *,cpu_hwIntCnt));
DECLARE("enaExpTrace", enaExpTrace);
DECLARE("enaExpTraceb", enaExpTraceb);
DECLARE("enaUsrFCall", enaUsrFCall);
DECLARE("enaUsrFCallb", enaUsrFCallb);
DECLARE("enaUsrPhyMp", enaUsrPhyMp);
DECLARE("enaUsrPhyMpb", enaUsrPhyMpb);
DECLARE("enaDiagSCs", enaDiagSCs);
DECLARE("enaDiagSCsb", enaDiagSCsb);
DECLARE("enaDiagEM", enaDiagEM);
DECLARE("enaDiagEMb", enaDiagEMb);
DECLARE("enaNotifyEM", enaNotifyEM);
DECLARE("enaNotifyEMb", enaNotifyEMb);
DECLARE("dgLock", offsetof(struct diagWork *, dgLock));
DECLARE("dgFlags", offsetof(struct diagWork *, dgFlags));
DECLARE("dgMisc1", offsetof(struct diagWork *, dgMisc1));
DECLARE("dgMisc2", offsetof(struct diagWork *, dgMisc2));
DECLARE("dgMisc3", offsetof(struct diagWork *, dgMisc3));
DECLARE("dgMisc4", offsetof(struct diagWork *, dgMisc4));
DECLARE("dgMisc5", offsetof(struct diagWork *, dgMisc5));
DECLARE("INTEL_PTE_KERNEL", INTEL_PTE_VALID|INTEL_PTE_WRITE);
DECLARE("PDESHIFT", PDESHIFT);
DECLARE("PDESIZE", PDESIZE);
DECLARE("PTESIZE", PTESIZE);
#ifdef __i386__
DECLARE("PTDPTDI", PTDPTDI);
DECLARE("APTDPTDI", APTDPTDI);
DECLARE("HIGH_MEM_BASE", HIGH_MEM_BASE);
DECLARE("HIGH_IDT_BASE", pmap_index_to_virt(HIGH_FIXED_IDT));
#endif
DECLARE("KERNELBASEPDE",
(LINEAR_KERNEL_ADDRESS >> PDESHIFT) *
sizeof(pt_entry_t));
DECLARE("TSS_ESP0", offsetof(struct i386_tss *, esp0));
DECLARE("TSS_SS0", offsetof(struct i386_tss *, ss0));
DECLARE("TSS_LDT", offsetof(struct i386_tss *, ldt));
DECLARE("TSS_PDBR", offsetof(struct i386_tss *, cr3));
DECLARE("TSS_LINK", offsetof(struct i386_tss *, back_link));
DECLARE("K_TASK_GATE", ACC_P|ACC_PL_K|ACC_TASK_GATE);
DECLARE("K_TRAP_GATE", ACC_P|ACC_PL_K|ACC_TRAP_GATE);
DECLARE("U_TRAP_GATE", ACC_P|ACC_PL_U|ACC_TRAP_GATE);
DECLARE("K_INTR_GATE", ACC_P|ACC_PL_K|ACC_INTR_GATE);
DECLARE("U_INTR_GATE", ACC_P|ACC_PL_U|ACC_INTR_GATE);
DECLARE("K_TSS", ACC_P|ACC_PL_K|ACC_TSS);
/*
* usimple_lock fields
*/
DECLARE("USL_INTERLOCK", offsetof(usimple_lock_t, interlock));
DECLARE("INTSTACK_SIZE", INTSTACK_SIZE);
DECLARE("KADDR", offsetof(struct boot_args *, kaddr));
DECLARE("KSIZE", offsetof(struct boot_args *, ksize));
DECLARE("MEMORYMAP", offsetof(struct boot_args *, MemoryMap));
DECLARE("DEVICETREEP", offsetof(struct boot_args *, deviceTreeP));
DECLARE("RNT_TSC_BASE",
offsetof(rtc_nanotime_t *, tsc_base));
DECLARE("RNT_NS_BASE",
offsetof(rtc_nanotime_t *, ns_base));
DECLARE("RNT_SCALE",
offsetof(rtc_nanotime_t *, scale));
DECLARE("RNT_SHIFT",
offsetof(rtc_nanotime_t *, shift));
DECLARE("RNT_GENERATION",
offsetof(rtc_nanotime_t *, generation));
/* values from kern/timer.h */
#ifdef __LP64__
DECLARE("TIMER_ALL", offsetof(struct timer *, all_bits));
#else
DECLARE("TIMER_LOW", offsetof(struct timer *, low_bits));
DECLARE("TIMER_HIGH", offsetof(struct timer *, high_bits));
DECLARE("TIMER_HIGHCHK", offsetof(struct timer *, high_bits_check));
#endif
#if !STAT_TIME
DECLARE("TIMER_TSTAMP",
offsetof(struct timer *, tstamp));
DECLARE("THREAD_TIMER",
offsetof(struct processor *, processor_data.thread_timer));
#endif
DECLARE("KERNEL_TIMER",
offsetof(struct processor *, processor_data.kernel_timer));
DECLARE("SYSTEM_TIMER",
offsetof(struct thread *, system_timer));
DECLARE("USER_TIMER",
offsetof(struct thread *, user_timer));
DECLARE("SYSTEM_STATE",
offsetof(struct processor *, processor_data.system_state));
DECLARE("USER_STATE",
offsetof(struct processor *, processor_data.user_state));
DECLARE("IDLE_STATE",
offsetof(struct processor *, processor_data.idle_state));
DECLARE("CURRENT_STATE",
offsetof(struct processor *, processor_data.current_state));
DECLARE("OnProc", OnProc);
#if CONFIG_DTRACE
DECLARE("LS_LCK_MTX_LOCK_ACQUIRE", LS_LCK_MTX_LOCK_ACQUIRE);
DECLARE("LS_LCK_MTX_TRY_SPIN_LOCK_ACQUIRE", LS_LCK_MTX_TRY_SPIN_LOCK_ACQUIRE);
DECLARE("LS_LCK_MTX_UNLOCK_RELEASE", LS_LCK_MTX_UNLOCK_RELEASE);
DECLARE("LS_LCK_MTX_TRY_LOCK_ACQUIRE", LS_LCK_MTX_TRY_LOCK_ACQUIRE);
DECLARE("LS_LCK_RW_LOCK_SHARED_ACQUIRE", LS_LCK_RW_LOCK_SHARED_ACQUIRE);
DECLARE("LS_LCK_RW_DONE_RELEASE", LS_LCK_RW_DONE_RELEASE);
DECLARE("LS_LCK_MTX_EXT_LOCK_ACQUIRE", LS_LCK_MTX_EXT_LOCK_ACQUIRE);
DECLARE("LS_LCK_MTX_TRY_EXT_LOCK_ACQUIRE", LS_LCK_MTX_TRY_EXT_LOCK_ACQUIRE);
DECLARE("LS_LCK_MTX_EXT_UNLOCK_RELEASE", LS_LCK_MTX_EXT_UNLOCK_RELEASE);
DECLARE("LS_LCK_RW_LOCK_EXCL_ACQUIRE", LS_LCK_RW_LOCK_EXCL_ACQUIRE);
DECLARE("LS_LCK_RW_LOCK_SHARED_TO_EXCL_UPGRADE", LS_LCK_RW_LOCK_SHARED_TO_EXCL_UPGRADE);
DECLARE("LS_LCK_RW_TRY_LOCK_EXCL_ACQUIRE", LS_LCK_RW_TRY_LOCK_EXCL_ACQUIRE);
DECLARE("LS_LCK_RW_TRY_LOCK_SHARED_ACQUIRE", LS_LCK_RW_TRY_LOCK_SHARED_ACQUIRE);
DECLARE("LS_LCK_MTX_LOCK_SPIN_ACQUIRE", LS_LCK_MTX_LOCK_SPIN_ACQUIRE);
#endif
return (0);
}
