/** Appliquer les contraintes d'unicite etendue sur les lignes et colones de la grille */
int contrainte_theocycle_ligne_colones(GRILLE g, PILE_CASE *p){
int i,j,add_p=0;
CASE* table[DIM],*table_2[DIM];
for (i=0;i<DIM;i++){
for (j=0;j<DIM;j++){
table[j]=GR(i,j); /** Ligne de cases */
table_2[j]=GR(j,i); /** Colone de cases */
}
add_p|=theocycle_table(table,p)|theocycle_table(table_2,p); /* On note si la pile a etee changee ou non */
}
return add_p;
}
void show_argb(void)
{
int i, j;
double d = 0.0;
double dd = 0.01;
if (_qdgdfv_argb_screen == NULL)
return;
for (;;) {
for (j = 0; j < _qdgdfv_screen_y_size; j++) {
for (i = 0; i < _qdgdfv_screen_x_size; i++) {
int c = (RD(i, j, d) << 16) |
(GR(i, j, d) << 8) |
(BL(i, j, d) << 0);
_qdgdfv_argb_screen[i + j * _qdgdfv_screen_x_size] = c;
}
}
d += dd;
if (d > 5.0 || d < -5.0)
dd = -dd;
qdgdfv_input_poll();
qdgdfv_dump_argb_screen();
if (_qdgdfv_key_escape)
break;
}
while (_qdgdfv_key_escape)
qdgdfv_input_poll();
}
void pixel_write(int i, int j) {
static unsigned char color[3];
color[0] = RD(i,j)&255;
color[1] = GR(i,j)&255;
color[2] = BL(i,j)&255;
fwrite(color, 1, 3, fp);
}
void GEMENI_charsent() {
unsigned long r = s->log[s->lc];
if (UCA0IFG & UCTXIFG) {
s->nch++;
switch (s->nch) {
case 1:
UCA0TXBUF = SL(r) << 5 |TL(r)<<4|KL(r)<<3|PL(r)<<2|WL(r)<<1|HL(r);
break;
case 2:
UCA0TXBUF = RL(r)<<6 | AL(r)<<5 | OL(r)<<4 | STAR(r)<<3;
break;
case 3:
UCA0TXBUF = ER(r)<<3 | UR(r)<<2 | FR(r)<<1 | RR(r);
break;
case 4:
UCA0TXBUF = PR(r)<<6 | BR(r)<<5 | LR(r)<<4 | GR(r)<<3 | TR(r)<<2 | SR(r)<<1 | DRS(r);
break;
case 5:
UCA0TXBUF = POUND(r)<<1 | ZRS(r);
break;
default:
s->lc++;
if (s->lc != s->nc-1) {
s->nch = 0;
UCA0TXBUF = 1 << 7; // first packet, no fn or '#'
} else {
s->flags &= ~CSEND;
}
}
}
}
/** Appliquer les contraintes d'unicite etendue sur chaque region de la grille */
int contrainte_theocycle_region(GRILLE g, PILE_CASE *p){
int x,y, i,j,k,l, add_p=0;
CASE * table[DIM];
for (i=0; i<DIM_Region; i++) for (j=0; j<DIM_Region; j++){ /* Pour chaque region de la grille */
for (k=0;k<DIM_Region; k++) for (l=0;l<DIM_Region;l++){ /* On ajoute au tableau les cases de la region */
x=i*DIM_Region+k; y=j*DIM_Region+l;
table[k+DIM_Region*l]=GR(x,y);
}
add_p|=theocycle_table(table,p); /* On note si la pile a etee changee */
}
return add_p;
}
void
GlideComputerAirData::ProcessVertical(const MoreData &basic,
const MoreData &last_basic,
DerivedInfo &calculated,
const ComputerSettings &settings)
{
/* the "circling" flag may be modified by
CirclingComputer::Turning(); remember the old state so this
method can check for modifications */
const bool last_circling = calculated.circling;
auto_qnh.Process(basic, calculated, settings, waypoints);
circling_computer.TurnRate(calculated, basic,
calculated.flight);
Turning(basic, calculated, settings);
wind_computer.Compute(settings.wind, settings.polar.glide_polar_task,
basic, calculated);
wind_computer.Select(settings.wind, basic, calculated);
wind_computer.ComputeHeadWind(basic, calculated);
thermallocator.Process(calculated.circling,
basic.time, basic.location,
basic.netto_vario,
calculated.GetWindOrZero(),
calculated.thermal_locator);
LastThermalStats(basic, calculated, last_circling);
gr_computer.Compute(basic, last_basic, calculated,
calculated,
settings);
GR(basic, calculated.flight, calculated);
CruiseGR(basic, calculated);
average_vario.Compute(basic, calculated.circling, last_circling,
calculated);
AverageClimbRate(basic, calculated);
if (calculated.circling)
CurrentThermal(basic, calculated, calculated.current_thermal);
lift_database_computer.Compute(calculated.lift_database,
calculated.trace_history.CirclingAverage,
basic, calculated);
circling_computer.MaxHeightGain(basic, calculated.flight, calculated);
NextLegEqThermal(basic, calculated, settings);
}
BOOL CARIB8CharDecode::Analyze( const BYTE* pbSrc, DWORD dwSrcSize, DWORD* pdwReadSize )
{
if( pbSrc == NULL || dwSrcSize == 0 || pdwReadSize == NULL){
return FALSE;
}
BOOL bRet = TRUE;
DWORD dwReadSize = 0;
while( dwReadSize < dwSrcSize ){
DWORD dwReadBuff = 0;
//1バイト目チェック
if( pbSrc[dwReadSize] <= 0x20 ){
//C0制御コード
bRet = C0( pbSrc+dwReadSize, &dwReadBuff );
dwReadSize += dwReadBuff;
if( bRet == FALSE ){
return FALSE;
}else if( bRet == 2 ){
bRet = TRUE;
break;
}
}else if( pbSrc[dwReadSize] > 0x20 && pbSrc[dwReadSize] < 0x7F ){
//GL符号領域
if( GL( pbSrc+dwReadSize, &dwReadBuff ) == FALSE ){
return FALSE;
}
dwReadSize += dwReadBuff;
}else if( pbSrc[dwReadSize] >= 0x7F && pbSrc[dwReadSize] <= 0xA0 ){
//C1制御コード
bRet = C1( pbSrc+dwReadSize, &dwReadBuff );
dwReadSize += dwReadBuff;
if( bRet == FALSE ){
return FALSE;
}else if( bRet == 2 ){
bRet = TRUE;
break;
}
}else if( pbSrc[dwReadSize] > 0xA0 && pbSrc[dwReadSize] < 0xFF ){
//GR符号領域
if( GR( pbSrc+dwReadSize, &dwReadBuff ) == FALSE ){
return FALSE;
}
dwReadSize += dwReadBuff;
}
}
*pdwReadSize = dwReadSize;
return bRet;
}
void my_uncompress(char *file,int argc, char **argv)
{
unsigned int len;
char buffer[8192];
int fd;
char *d;
fd=open(file, O_RDONLY);
if(fd == -1) return;
if(lseek(fd, SEEK_TO, SEEK_SET)<0)
{
perror("lseek");
exit(1);
}
gz=gzdopen(fd,"rb");
if(!gz)
{
puts("gzdopen failed!");
exit(1);
}
#ifdef __NT__
d=getenv("TMP");
if(!d) d=getenv("TEMP");
if(!d) d="C:\\Windows\\temp";
#else
d=getenv("TMPDIR");
if(!d) d="/tmp";
#endif
if(chdir(d)<0)
{
perror("chdir");
exit(1);
}
WERR("Changing dir to %s\n",d);
while(1)
{
char type;
int len;
char *data;
GR(type);
len=read_int();
WERR("namelen=%d\n",len);
gr(buffer, len);
buffer[len]=0;
WERR("Type %c: %s\n",type,buffer);
switch(type)
{
case 'q': /* quit */
exit(0);
case 'w': /* write */
puts(buffer);
break;
case 'e': /* setenv */
WERR("putenv(%s)\n",buffer);
putenv(buffer);
break;
case 's': /* system */
/* We ignore error so that we can continue with
* file deletion
*/
/* FIXME:
* Add support for concatenating all the parameters
* to this command
*/
if(buffer[strlen(buffer)-1]=='$')
{
char *ptr=buffer+strlen(buffer)-1;
int e;
for(e=0;e<argc;e++)
{
char *c;
WERR("argv[%d]=%s\n",e,argv[e]);
*(ptr++)=' ';
*(ptr++)='"';
for(c=argv[e];*c;c++)
{
switch(*c)
{
case '\\':
#ifdef __NT__
*(ptr++)='"';
*(ptr++)='\\';
*(ptr++)='\\';
*(ptr++)='"';
break;
#endif
case '"':
*(ptr++)='\\';
default:
*(ptr++)=*c;
}
}
*(ptr++)='"';
}
*(ptr++)=0;
}
WERR("system(%s)\n",buffer);
system(buffer);
break;
case 'd': /* dir */
/* We ignore mkdir errors and just assume that the
* directory already exists
*/
/* fprintf(stderr,"mkdir(%s)\n",buffer); */
mkdir(buffer, 0777);
break;
case 'f': /* file */
{
FILE *f;
WERR("file(%s)\n",buffer);
f=fopen(buffer,"wb");
if(!f)
{
perror("fopen");
fprintf(stderr,"Failed to open %s\n",buffer);
exit(1);
}
len=read_int();
while(len)
{
int r=len > sizeof(buffer) ? sizeof(buffer) : len;
gr(buffer, r);
if(fwrite(buffer, 1, r, f) != r)
{
perror("fwrite");
exit(1);
}
len-=r;
}
if(fclose(f)<0)
{
perror("fclose");
exit(1);
}
}
break;
case 'D':
WERR("unlink(%s)\n",buffer);
if(unlink(buffer)<0 && rmdir(buffer)<0)
{
#ifdef DEBUG
fprintf(stderr,"Failed to delete %s\n",buffer);
perror("unlink");
#endif
/* exit(1); */
}
break;
default:
fprintf(stderr,"Wrong type (%c (%d))!\n",type,type);
exit(1);
}
}
}
void PDRkEpsilon::correct()
{
if (!turbulence_)
{
// Re-calculate viscosity
nut_ = Cmu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
//***HGWalphat_ = mut_/Prt_;
// alphat_.correctBoundaryConditions();
return;
}
RASModel::correct();
volScalarField divU(fvc::div(phi_/fvc::interpolate(rho_)));
if (mesh_.moving())
{
divU += fvc::div(mesh_.phi());
}
tmp<volTensorField> tgradU = fvc::grad(U_);
volScalarField G(GName(), rho_*nut_*(tgradU() && dev(twoSymm(tgradU()))));
tgradU.clear();
// Update espsilon and G at the wall
epsilon_.boundaryFieldRef().updateCoeffs();
// Add the blockage generation term so that it is included consistently
// in both the k and epsilon equations
const volScalarField& betav =
U_.db().lookupObject<volScalarField>("betav");
const volScalarField& Lobs =
U_.db().lookupObject<volScalarField>("Lobs");
const PDRDragModel& drag =
U_.db().lookupObject<PDRDragModel>("PDRDragModel");
volScalarField GR(drag.Gk());
volScalarField LI
(C4_*(Lobs + dimensionedScalar(dimLength, rootVSmall)));
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
betav*fvm::ddt(rho_, epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(rho_*DepsilonEff(), epsilon_)
==
C1_*betav*G*epsilon_/k_
+ 1.5*pow(Cmu_, 3.0/4.0)*GR*sqrt(k_)/LI
- fvm::SuSp(((2.0/3.0)*C1_)*betav*rho_*divU, epsilon_)
- fvm::Sp(C2_*betav*rho_*epsilon_/k_, epsilon_)
);
epsEqn.ref().relax();
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
solve(epsEqn);
bound(epsilon_, epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
betav*fvm::ddt(rho_, k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(rho_*DkEff(), k_)
==
betav*G + GR
- fvm::SuSp((2.0/3.0)*betav*rho_*divU, k_)
- fvm::Sp(betav*rho_*epsilon_/k_, k_)
);
kEqn.ref().relax();
solve(kEqn);
bound(k_, kMin_);
// Re-calculate viscosity
nut_ = Cmu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
//***HGWalphat_ = mut_/Prt_;
// alphat_.correctBoundaryConditions();
}
#endif
#include <elf.h>
#include <inttypes.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/time.h>
#define BACKEND sh_
#include "libebl_CPU.h"
static const Ebl_Register_Location prstatus_regs[] =
{
#define GR(at, n, dwreg) \
{ .offset = at * 4, .regno = dwreg, .count = n, .bits = 32 }
GR (0, 16, 0), /* r0-r15 */
GR (16, 1, 16), /* pc */
GR (17, 1, 17), /* pr */
GR (18, 1, 22), /* sr */
GR (19, 1, 18), /* gbr */
GR (20, 1, 20), /* mach */
GR (21, 1, 21), /* macl */
/* 22, 1, tra */
#undef GR
};
#define PRSTATUS_REGS_SIZE (23 * 4)
#define ULONG uint32_t
#define PID_T int32_t
#define UID_T uint16_t
#define GID_T uint16_t
