void BlockLocalPositionEstimator::updateSSStates() { // derivative of velocity is accelerometer acceleration // (in input matrix) - bias (in body frame) _A(X_vx, X_bx) = -_R_att(0, 0); _A(X_vx, X_by) = -_R_att(0, 1); _A(X_vx, X_bz) = -_R_att(0, 2); _A(X_vy, X_bx) = -_R_att(1, 0); _A(X_vy, X_by) = -_R_att(1, 1); _A(X_vy, X_bz) = -_R_att(1, 2); _A(X_vz, X_bx) = -_R_att(2, 0); _A(X_vz, X_by) = -_R_att(2, 1); _A(X_vz, X_bz) = -_R_att(2, 2); }
/** @brief plugin initialization function, called by main program @param mode flags enumerating what sort of init to perform @return Plugin*, with refcount 1 if @a mode included runtime setup and that succeeded */ Plugin *init_plugin (E2PInit mode) { const gchar *aname2 = _("selmatchpart"); PLUGINIT_INTRO PLUGINIT_NUMBERED_ALLOCATE(2) PLUGINIT_NUMBERED_ACTION(1,_A(7),_("selmatch"),_e2p_select_same, _("_Select same"), _("Select items whose whole name matches a selected item in the other pane"), "plugin_"ANAME E2ICONTB) PLUGINIT_NUMBERED_ACTION(2,_A(7),aname2,_e2p_select_like, _("Select _like"), _("Select items whose name partially matches a selected item in the other pane"), NULL) //if the above included init, and it succeeded, more init needed if (iface.refcount == 1) { E2_OptionSetupExtra ex; gchar *group = g_strconcat(_C(34),".",_C(27),":",aname2,NULL); //_("plugins.options:selmatchpart" memset (&ex, 0, sizeof (E2_OptionSetupExtra)); ex.exbool = TRUE; E2_OptionSet *set = e2_plugins_option_register (E2_OPTION_TYPE_BOOL, "selmatch-start", group, _("match to first separator"), _("If enabled, name matching stops at the first instance of any specified separator, otherwise, at the last instance"), NULL, &ex, E2_OPTION_FLAG_FREEGROUP | E2_OPTION_FLAG_ADVANCED); //because plugins are loaded after config data, config options need to //get any data from unknown-options data e2_option_transient_value_get (set); ex.exstr = "."; set = e2_plugins_option_register (E2_OPTION_TYPE_STR, "selmatch-separators", group, _("separator character(s)"), _("String comprising all chars considered to be a 'separator'"), NULL, &ex, E2_OPTION_FLAG_ADVANCED); e2_option_transient_value_get (set); } PLUGINIT_NUMBERED_END }
void probe_fini (void *arg) { _A((void *)arg == (void *)&__filehash_probe_mutex); /* * Destroy mutex. */ (void) pthread_mutex_destroy (&__filehash_probe_mutex); return; }
void BlockLocalPositionEstimator::initSS() { initP(); // dynamics matrix _A.setZero(); // derivative of position is velocity _A(X_x, X_vx) = 1; _A(X_y, X_vy) = 1; _A(X_z, X_vz) = 1; // input matrix _B.setZero(); _B(X_vx, U_ax) = 1; _B(X_vy, U_ay) = 1; _B(X_vz, U_az) = 1; // update components that depend on current state updateSSStates(); updateSSParams(); }
/// \brief Update the design variable. void MatrixTransformation::updateImplementation(const double * dp, int size) { static_cast<void>(size); // used depending on NDEBUG SM_ASSERT_EQ_DBG(aslam::Exception, size, _UpdateDimension , "Incorrect update size"); _A_a = _A; Eigen::Matrix3d dA; int j=0; for (int i=0; i<9; i++){ _A(i%3,floor(static_cast<double>(i/3))) += _UpdatePattern(i%3,floor(static_cast<double>(i/3)))*dp[j]; if (_UpdatePattern(i%3,floor(static_cast<double>(i/3)))==1){j++; } } }
Parser::Parser(const vector<Production>& productions, const string& parserTablePath) : BasicParser(productions), parserTablePath(parserTablePath) { #ifdef _DEBUG stream.open("ParserResult.txt", fstream::out | fstream::binary); #endif // String Begin Rule quotationMarks = Rule('\"', &context); Rule ruleString = quotationMarks + *!quotationMarks + quotationMarks; ruleString.buildDFA(); ruleString.setShowName("\"{String}\""); Production::Item itemString(ruleString); // String End // Digit Start Rule _0('0', &context); Rule _9('9', &context); Rule _0_9 = _0 - _9; Rule ruleDigit = +_0_9; ruleDigit.buildDFA(); ruleDigit.setShowName("\"{Digit}\""); Production::Item itemDigit(ruleDigit); // Digit End // Real Start Rule _point('.', &context); Rule ruleReal = *_0_9 + _point + +_0_9; ruleReal.buildDFA(); ruleReal.setShowName("\"{Real}\""); Production::Item itemReal(ruleReal); // Real End // Letter Start Rule _('_', &context); Rule _a('a', &context); Rule _z('z', &context); Rule _A('A', &context); Rule _Z('Z', &context); Rule _a_z = _a - _z; Rule _A_Z = _A - _Z; Rule ruleLetter = ((+_ + ruleDigit) | (+(_ | _a_z | _A_Z))) + *(_ | ruleDigit | _a_z | _A_Z); ruleLetter.buildDFA(); ruleLetter.setShowName("\"{Letter}\""); Production::Item itemLetter(ruleLetter); // Letter End vts.push_back(pair<string, Production::Item>("{String}", itemString)); vts.push_back(pair<string, Production::Item>("{Digit}", itemDigit)); vts.push_back(pair<string, Production::Item>("{Real}", itemReal)); vts.push_back(pair<string, Production::Item>("{Letter}", itemLetter)); }
void genPredModel::init(double paramA, double paramB) { rowA = 3; colA = 3; Matrix _A(3,3); Matrix _B(3,3); Matrix _H(3,3); A = _A; B = _B; H = _H; A.zero(); B.zero(); H.zero(); }
void probe_fini (void *arg) { _A((void *)arg == (void *)&__file_probe_mutex); if (!SEXP_emptyp(&gr_lastpath)) SEXP_free_r(&gr_lastpath); /* * Destroy mutex. */ (void) pthread_mutex_destroy (&__file_probe_mutex); return; }
SEXP_t *SEXP_list_new_rv (SEXP_t *sexp_mem, SEXP_t *memb, va_list alist) { SEXP_val_t v_dsc; SEXP_t *s_ptr[32]; size_t s_cur; uint8_t b_exp; s_cur = 0; s_ptr[s_cur] = memb; while (s_ptr[s_cur] != NULL) { _A(s_cur < (sizeof s_ptr / sizeof (SEXP_t *))); SEXP_VALIDATE(s_ptr[s_cur]); s_ptr[++s_cur] = va_arg (alist, SEXP_t *); } if (SEXP_val_new (&v_dsc, sizeof (void *) + sizeof (uint16_t), SEXP_VALTYPE_LIST) != 0) { /* TODO: handle this */ return (NULL); } if (s_cur > 0) { for (b_exp = 0; (size_t)(1 << b_exp) < s_cur; ++b_exp); SEXP_LCASTP(v_dsc.mem)->offset = 0; SEXP_LCASTP(v_dsc.mem)->b_addr = (void *)SEXP_rawval_lblk_new (b_exp); if (SEXP_rawval_lblk_fill ((uintptr_t)SEXP_LCASTP(v_dsc.mem)->b_addr, s_ptr, s_cur) != ((uintptr_t)SEXP_LCASTP(v_dsc.mem)->b_addr)) { /* TODO: handle this */ return (NULL); } } else { SEXP_LCASTP(v_dsc.mem)->offset = 0; SEXP_LCASTP(v_dsc.mem)->b_addr = NULL; } SEXP_init(sexp_mem); sexp_mem->s_type = NULL; sexp_mem->s_valp = v_dsc.ptr; SEXP_VALIDATE(sexp_mem); return (sexp_mem); }
LipmConstHeightPlanner::LipmConstHeightPlanner(double z, double dt) : _height(z) , _dt(dt) , _lqr(LqrController<2,1>()) { _Q.setIdentity(); _R.setIdentity(); _Q *= 1e-6; _A(0,0) = 1; _A(0,1) = _dt; _A(1,0) = _dt*GRAVITY/_height; _A(1,1) = 1; _B(0,0) = 0; _B(1,0) = -_dt*GRAVITY/_height; _lqr.setQ(_Q); _lqr.setR(_R); _lqr.infTimeLQR(_A, _B); _K = _lqr.getK(); _Quu_inv = (_B.transpose()*_lqr.getV()*_B + _R).inverse(); }
static SEAP_cmdrec_t *Stable_get (Stable_t *t, SEAP_cmdcode_t c) { Stable_rec_t *t_r; size_t i; _A(t != NULL); t_r = &(t->t_recs[c % t->t_size]); for (i = 0; i < t_r->c_size; ++i) if (t_r->c_recs[i]->code == c) return (t_r->c_recs[i]); return (NULL); }
static Stable_t *Stable_new (size_t capacity) { Stable_t *t; size_t i; _A(capacity > 0 && capacity < SEAP_COMMAND_BACKENDS_MAXCAPACITY); t = malloc(sizeof(Stable_t)); t->t_size = Stable_prime_gt (capacity); t->t_recs = calloc(t->t_size, sizeof(Stable_rec_t)); for (i = 0; i < t->t_size; ++i) t->t_recs[i].c_recs = NULL; return (t); }
void Matrix3x3::SVD(double* U, double* s, double* VT, const double* A) { #ifndef OPEN3DMOTION_LINEAR_ALGEBRA_EIGEN long three(3); Matrix3x3 Acpy(A); long lwork(256); double work[256]; long info(0); // use lapack routine // - note U and VT are swapped // - this is because of the fortran column-major // ordering for matrices - it turns out that // using a row major matrix here corresponds to // swapping U and VT dgesvd_( "A", // all of U "A", // all of VT &three, // rows &three, // cols Acpy, // input/output matrix &three, // leading dimension of Acpy s, // singular values VT, // left orthonormal matrix &three, // leading dimension of left U, // right orthonormal matrix &three, // leading dimension of right work, // workspace &lwork, // size of workspace &info); // returned error codes #else Eigen::Map< const Eigen::Matrix<double, 3, 3, Eigen::RowMajor> > _A(A, 3, 3); Eigen::Map< Eigen::Matrix<double, 3, 3, Eigen::RowMajor> > _U(U, 3, 3); Eigen::Map< Eigen::Matrix<double, 3, 3, Eigen::RowMajor> > _VT(VT, 3, 3); Eigen::Map< Eigen::Matrix<double, 3, 1> > _s(s, 3, 1); Eigen::JacobiSVD< Eigen::Matrix<double, 3, 3, Eigen::RowMajor> > svd(_A, Eigen::ComputeFullU | Eigen::ComputeFullV); _U = svd.matrixU(); _VT = svd.matrixV().transpose(); _s = svd.singularValues(); #endif }
static uint16_t Stable_prime_gt (uint16_t n) { size_t w, s; w = (sizeof Stable_primes) / sizeof (uint16_t); s = 0; while (w > 0) { if (n > Stable_primes[s + w/2]) { s += w/2 + 1; w = w - w/2 - 1; } else if (n < Stable_primes[s + w/2]) { w = w/2; } else break; } _A(s + w/2 < (sizeof Stable_primes) / sizeof (uint16_t)); return (Stable_primes[s + w/2]); }
linVelModel::linVelModel() { valid = true; type = "constVelocity"; rowA = 2; colA = 2; printf("initialisation matrix A,B,H with main dimension %d \n", rowA, colA); Matrix _A(2,2); Matrix _B(2,1); Matrix _H(2,2); A = _A; B = _B; H = _H; A.zero(); B.zero(); H.zero(); A(0,0) = 1; A(1,1) = 1; B(0,0) = 0.01; H(1,1) = 1; }
int eigen_decomposition(const dgematrix &A, dgematrix & P, dgematrix &D) { int N= A.n; vector<double> wr, wi; vector<dcovector > vr, vi; dgematrix _A(A); int i,j; if(A.n != A.m) { cerr<<"BFilt :: Matrix must be square"<<endl; return 1; } D.resize(N,N); P.resize(N,N); if(_A.dgeev(wr,wi,vr,vi)) return 1; P.zero(); for(j=0; j<P.m; j++) { for(i=0; i<P.n; i++) { P(i,j) = vr[j](i); } } D.zero(); for(i=0;i<N;i++) { if(wi[i] != 0) { cerr<<"BFilt :: Matrix must be real"<<endl; return 1; } D(i,i) = wr[i]; } return 0; }
int matvec(int nx, int ny, real* A, real* x, real* y) { #if defined(_OPENACC) size_t szarray = (size_t)nx * ny; #pragma acc kernels loop independent present(A[0:szarray], x[0:nx], y[0:ny]) #endif #if defined(_OPENMP) || defined(_MIC) #pragma omp parallel for #endif for (int j = 0; j < ny; j++) { y[j] = 0; #if defined(_OPENACC) #pragma acc loop seq #endif for (int i = 0; i < nx; i++) { y[j] += _A(A, i, j) * x[i]; } } return 0; }
/* find the cathode sheath thickness in m */ double _d ( long plasmatype, double Ti, double Nn, double gamma, double j ) { double d, dtilde, relerr, abserr, dtildemin, dtildemax, Pdmin, P; long IFLAG; arg_t arg; /* d=0.01; dd=1e-8; do { res= (j-_j(Ti,Nn,gamma,d)) ; dddj=dd/(_j(Ti,Nn,gamma,d+dd)-_j(Ti,Nn,gamma,d)); d=max(0.01,d+dd); dd=dddj*res; printf("d=%E j=%E res=%E\n",d,j,res); } while(fabs(res/j)>1e-10); */ arg.gamma = gamma; arg.Nn = Nn; arg.Ti = Ti; arg.j = j; arg.plasmatype = plasmatype; dtildemin = 1.0 / ebar; dtildemax = 2000.0; relerr = 1e-10; abserr = 1e-100; dtilde = EXM_find_root_zero_in ( &_jres, &arg, dtildemin, dtildemax, relerr, abserr, &IFLAG ); if ( IFLAG != 1 ) printf ( "a root for dtilde has not been found (IFLAG=%ld)\n", IFLAG ); P = Nn * Ti * kB / 133.0; /* Torr */ Pdmin = ebar / _A ( plasmatype ) * ( 1.0 / gamma + 1.0 ); /* Torr cm */ d = dtilde * Pdmin / P * 0.01; return ( d ); }
int wave13pt(int nx, int ny, int ns, const real c0, const real c1, const real c2, real* w0, real* w1, real* w2) { int i, j, k; unsigned int szarray = (unsigned int)nx * ny * ns; #pragma acc data present(w0[0:szarray], w1[0:szarray], w2[0:szarray]) { #pragma acc kernels { #pragma acc loop independent vector(2) for (k = 2; k < ns - 2; k++) { #pragma acc loop independent gang(31) vector(4) for (j = 2; j < ny - 2; j++) { #pragma acc loop independent gang(2) vector(64) for (i = 2; i < nx - 2; i++) { _A(w2, k, j, i) = c0 * _A(w1, k, j, i) - _A(w0, k, j, i) + c1 * ( _A(w1, k, j, i+1) + _A(w1, k, j, i-1) + _A(w1, k, j+1, i) + _A(w1, k, j-1, i) + _A(w1, k+1, j, i) + _A(w1, k-1, j, i)) + c2 * ( _A(w1, k, j, i+2) + _A(w1, k, j, i-2) + _A(w1, k, j+2, i) + _A(w1, k, j-2, i) + _A(w1, k+2, j, i) + _A(w1, k-2, j, i)); } } } } } return 0; }
FE_TMPL std::complex<float> FE_SYS::_I(int n,int m,glm::vec3 x){ glm::vec3 s = cart2sph(x); return std::pow(std::complex<float>(0,-1),-std::abs(m)) * _A(n,m) * std::pow(s.x,n) * _Y(n,m,s.y,s.z); }
// first element is NOT filled right now, doesn't matter, BRK will fill that position. // Now, fill used entries with actual jump addresses. #include "jump_table.h" blr } // ----------------------------------------------------------------------- // This functions loads the PC with the address stored at 0xFFFC // and clears registers which effectively resets the CPU. asm void N6502::_Reset() { li r4,0 // init registers stb r4,_A(r3) stb r4,_X(r3) stb r4,_Y(r3) stw r4,_CycleBK(r3) stw r4,_IntReq(r3) li r5,R_FLAG|Z_FLAG stb r5,_F(r3) li r6,0xFF stb r6,_SP(r3) li r9,0 lwz r7,_MEM_X(r3) // load PC with reset vector ori r9,r9,RESET_VECTOR lwz r7,ROMSeg4_Ind(r7) lhbrx r8,r9,r7 sth r8,_PC(r3)
int probe_main (probe_ctx *ctx, void *mutex) { SEXP_t *path, *filename, *behaviors; SEXP_t *filepath, *attribute_, *probe_in; int err; struct cbargs cbargs; OVAL_FTS *ofts; OVAL_FTSENT *ofts_ent; if (mutex == NULL) return PROBE_EINIT; _A(mutex == &__file_probe_mutex); probe_in = probe_ctx_getobject(ctx); path = probe_obj_getent (probe_in, "path", 1); filename = probe_obj_getent (probe_in, "filename", 1); behaviors = probe_obj_getent (probe_in, "behaviors", 1); filepath = probe_obj_getent (probe_in, "filepath", 1); attribute_ = probe_obj_getent (probe_in, "attribute_name", 1); /* we want either path+filename or filepath */ if (((path == NULL || filename == NULL) && filepath == NULL) || attribute_ == NULL) { SEXP_free (behaviors); SEXP_free (path); SEXP_free (filename); SEXP_free (filepath); SEXP_free (attribute_); return PROBE_ENOELM; } probe_filebehaviors_canonicalize(&behaviors); switch (pthread_mutex_lock (&__file_probe_mutex)) { case 0: break; default: dI("Can't lock mutex(%p): %u, %s.", &__file_probe_mutex, errno, strerror (errno)); SEXP_free(path); SEXP_free(filename); SEXP_free(filepath); SEXP_free(behaviors); SEXP_free(attribute_); return PROBE_EFATAL; } cbargs.ctx = ctx; cbargs.error = 0; cbargs.attr_ent = attribute_; if ((ofts = oval_fts_open(path, filename, filepath, behaviors)) != NULL) { while ((ofts_ent = oval_fts_read(ofts)) != NULL) { file_cb(ofts_ent->path, ofts_ent->file, &cbargs); oval_ftsent_free(ofts_ent); } oval_fts_close(ofts); } err = 0; SEXP_free(path); SEXP_free(filename); SEXP_free(filepath); SEXP_free(behaviors); SEXP_free(attribute_); switch (pthread_mutex_unlock (&__file_probe_mutex)) { case 0: break; default: dI("Can't unlock mutex(%p): %u, %s.", &__file_probe_mutex, errno, strerror (errno)); return PROBE_EFATAL; } return err; }
value_t GeometricCGVariant::solve(const TTOperator *_Ap, TTTensor &_x, const TTTensor &_b, size_t _numSteps, value_t _convergenceEpsilon, PerformanceData &_perfData) const { const TTOperator &_A = *_Ap; static const Index i,j; size_t stepCount=0; TTTensor residual; TTTangentVector gradient; value_t gradientNorm = 1.0; value_t lastResidual=1e100; value_t currResidual=1e100; value_t normB = frob_norm(_b); if (_Ap != nullptr) { _perfData << "Conjugated Gradients for ||A*x - b||^2, x.dimensions: " << _x.dimensions << '\n' << "A.ranks: " << _A.ranks() << '\n'; if (assumeSymmetricPositiveDefiniteOperator) { _perfData << " with symmetric positive definite Operator A\n"; } } else { _perfData << "Conjugated Gradients for ||x - b||^2, x.dimensions: " << _x.dimensions << '\n'; } _perfData << "x.ranks: " << _x.ranks() << '\n' << "b.ranks: " << _b.ranks() << '\n' << "maximum number of steps: " << _numSteps << '\n' << "convergence epsilon: " << _convergenceEpsilon << '\n'; _perfData.start(); auto calculateResidual = [&]()->value_t { if (_Ap != nullptr) { residual(i&0) = _b(i&0) - _A(i/2,j/2)*_x(j&0); } else { residual = _b - _x; } return frob_norm(residual);//normB; }; auto updateGradient = [&]() { if (assumeSymmetricPositiveDefiniteOperator || (_Ap == nullptr)) { gradient = TTTangentVector(_x, residual); } else { TTTensor grad; grad(i&0) = (*_Ap)(j/2,i/2) * residual(j&0); // grad = A^T * (b - Ax) gradient = TTTangentVector(_x, grad); } gradientNorm = gradient.frob_norm(); }; currResidual = calculateResidual(); _perfData.add(stepCount, currResidual, _x); updateGradient(); TTTangentVector direction = gradient; value_t alpha = 1; while ((_numSteps == 0 || stepCount < _numSteps) && currResidual/normB > _convergenceEpsilon && std::abs(lastResidual-currResidual)/normB > _convergenceEpsilon && std::abs(1-currResidual/lastResidual)/normB > _convergenceEpsilon) { stepCount += 1; size_t stepFlags = 0; // check the derivative along the current direction value_t derivative = gradient.scalar_product(direction) / direction.frob_norm(); // if movement in the given direction would increase the residual rather than decrease it, perform one steepest descent step instead if (derivative <= 0) { direction = gradient; derivative = gradient.frob_norm(); alpha = 1; stepFlags |= 1; } line_search(_x, alpha, direction, derivative, currResidual, retraction, calculateResidual, 0.8); _perfData.add(stepCount, currResidual, _x, stepFlags); // direction(i&0) = residual(i&0) + beta * direction(i&0); TTTangentVector oldDirection(direction); vectorTransport(_x, oldDirection); value_t oldGradNorm = gradientNorm; updateGradient(); double beta = gradientNorm / oldGradNorm ;// Fletcher-Reeves update direction = gradient; direction += oldDirection * beta; } return currResidual; }
static void doBranch( axp_ins opcode, pointer lbl, uint reg ) { opcode = _Opcode( opcode ) | _A( reg ); OutReloc( lbl, OWL_RELOC_BRANCH_REL, 0 ); ObjBytes( &opcode, sizeof( opcode ) ); }
int probe_main (probe_ctx *ctx, void *mutex) { SEXP_t *path, *filename, *behaviors, *filepath, *probe_in; OVAL_FTS *ofts; OVAL_FTSENT *ofts_ent; oval_schema_version_t over; if (mutex == NULL) { return (PROBE_EINIT); } _A(mutex == &__filehash_probe_mutex); probe_in = probe_ctx_getobject(ctx); path = probe_obj_getent (probe_in, "path", 1); filename = probe_obj_getent (probe_in, "filename", 1); behaviors = probe_obj_getent (probe_in, "behaviors", 1); filepath = probe_obj_getent (probe_in, "filepath", 1); over = probe_obj_get_platform_schema_version(probe_in); /* we want either path+filename or filepath */ if ( (path == NULL || filename == NULL) && filepath==NULL ) { SEXP_free (behaviors); SEXP_free (path); SEXP_free (filename); SEXP_free (filepath); return (PROBE_ENOELM); } probe_filebehaviors_canonicalize(&behaviors); switch (pthread_mutex_lock (&__filehash_probe_mutex)) { case 0: break; default: dI("Can't lock mutex(%p): %u, %s.", &__filehash_probe_mutex, errno, strerror (errno)); SEXP_free (behaviors); SEXP_free (path); SEXP_free (filename); SEXP_free (filepath); return (PROBE_EFATAL); } if ((ofts = oval_fts_open(path, filename, filepath, behaviors)) != NULL) { while ((ofts_ent = oval_fts_read(ofts)) != NULL) { filehash_cb(ofts_ent->path, ofts_ent->file, ctx, over); oval_ftsent_free(ofts_ent); } oval_fts_close(ofts); } SEXP_free (behaviors); SEXP_free (path); SEXP_free (filename); SEXP_free (filepath); switch (pthread_mutex_unlock (&__filehash_probe_mutex)) { case 0: break; default: dI("Can't unlock mutex(%p): %u, %s.", &__filehash_probe_mutex, errno, strerror (errno)); return (PROBE_EFATAL); } return 0; }
* We use this table twice; once with bootstrap page table, and once * with kernel's page table which we build up in initarm(). * * Since we map these registers into the bootstrap page table using * pmap_devmap_bootstrap() which calls pmap_map_chunk(), we map * registers segment-aligned and segment-rounded in order to avoid * using the 2nd page tables. */ #define _A(a) ((a) & ~L1_S_OFFSET) #define _S(s) (((s) + L1_S_SIZE - 1) & ~(L1_S_SIZE-1)) static const struct pmap_devmap devmap[] = { { /* Map the Texas Instruments Peripheral Bus VA==PA */ .pd_va = _A(OMAP_TIPB_PBASE), .pd_pa = _A(OMAP_TIPB_PBASE), .pd_size = _S(OMAP_TIPB_SIZE), .pd_prot = VM_PROT_READ|VM_PROT_WRITE, .pd_cache = PTE_NOCACHE }, {0} }; #undef _A #undef _S /* * u_int initarm(...) * * Initial entry point on startup. This gets called before main() is
int main (int argc, char *argv[]) { char *input; size_t inlen; SEXP_psetup_t *psetup; SEXP_pstate_t *pstate; SEXP_t *s_exp; setbuf (stdout, NULL); setbuf (stdin, NULL); psetup = SEXP_psetup_new (); pstate = NULL; if (argc == 1) { while (!feof (stdin)) { input = NULL; inlen = 0; #if defined(__FreeBSD__) input = fgetln (stdin, &inlen); #elif defined(__linux__) || defined(__GLIBC__) getline (&input, &inlen, stdin); #elif defined(__SVR4) && defined(__sun) getline (&input, &inlen, stdin); #else # error "FIXME" #endif s_exp = SEXP_parse (psetup, input, inlen, &pstate); if (s_exp != NULL) { _A(pstate == NULL); print_sexp (s_exp); SEXP_free (s_exp); } /* FIXME: getline/fgetln leak */ } } else { int i; for (i = 0; i < (argc - 1); ++i) { s_exp = SEXP_parse (psetup, argv[i + 1], strlen (argv[i + 1]), &pstate); if (s_exp != NULL) { _A(pstate == NULL); print_sexp (s_exp); SEXP_free (s_exp); } } if (pstate != NULL) return (1); } SEXP_psetup_free (psetup); return (0); }
void e2_action_option_actions_register () { E2_Action action = {g_strconcat(_A(9),".",_A(85),NULL),_e2_action_option_set,FALSE,E2_ACTION_TYPE_ITEM,0,NULL,NULL}; e2_action_register (&action); }
struct pv_addr msgbufpv; struct pv_addr irqstack; struct pv_addr undstack; struct pv_addr abtstack; struct pv_addr kernelstack; #define _A(a) ((a) & ~L1_S_OFFSET) #define _S(s) (((s) + L1_S_SIZE - 1) & ~(L1_S_SIZE-1)) /* Static device mappings. */ static const struct arm_devmap_entry s3c24x0_devmap[] = { /* * Map the devices we need early on. */ { _A(S3C24X0_CLKMAN_BASE), _A(S3C24X0_CLKMAN_PA_BASE), _S(S3C24X0_CLKMAN_SIZE), VM_PROT_READ|VM_PROT_WRITE, PTE_NOCACHE, }, { _A(S3C24X0_GPIO_BASE), _A(S3C24X0_GPIO_PA_BASE), _S(S3C2410_GPIO_SIZE), VM_PROT_READ|VM_PROT_WRITE, PTE_NOCACHE, }, { _A(S3C24X0_INTCTL_BASE), _A(S3C24X0_INTCTL_PA_BASE),
* Since we map these registers into the bootstrap page table using * pmap_devmap_bootstrap() which calls pmap_map_chunk(), we map * registers segment-aligned and segment-rounded in order to avoid * using the 2nd page tables. */ #define _A(a) ((a) & ~L1_S_OFFSET) #define _S(s) (((s) + L1_S_SIZE - 1) & ~(L1_S_SIZE-1)) static const struct pmap_devmap devmap[] = { { /* * Map all of core area, this gets us everything and * it's only 3MB. */ .pd_va = _A(AWIN_CORE_VBASE), .pd_pa = _A(AWIN_CORE_PBASE), .pd_size = _S(AWIN_CORE_SIZE), .pd_prot = VM_PROT_READ|VM_PROT_WRITE, .pd_cache = PTE_NOCACHE }, { /* * Map all 1MB of SRAM area. */ .pd_va = _A(AWIN_SRAM_VBASE), .pd_pa = _A(AWIN_SRAM_PBASE), .pd_size = _S(AWIN_SRAM_SIZE), .pd_prot = VM_PROT_READ|VM_PROT_WRITE, .pd_cache = PTE_CACHE },