static inline void printing(int total_size, int node) {
int permission = 0, llimit, ulimit, tab;
if (node == 0) {
permission = 1;
} else if (mod2(node) == 0) {
permission = (tree[div2(node - 1)] == 1) ? 1 : 0;
} else {
permission = (tree[div2(node)] == 1) ? 1 : 0;
}
if (permission) {
llimit = ulimit = tab = 0;
while (!(llimit <= node && node <= ulimit)) {
tab++;
putchar('\t');
llimit = ulimit + 1;
ulimit = 2 * ulimit + 2;
}
printf(" %d ", total_size / power_2(tab));
if (1 < tree[node]) {
printf("---> Allocated %d\n", tree[node]);
} else if (tree[node] == 1) {
printf("---> Divided\n");
} else {
printf("---> Free\n");
}
printing(total_size, 2 * node + 1);
printing(total_size, 2 * node + 2);
}
}
static inline void segmentalloc(int total_size, int request) {
int i, flevel = 0, size = total_size;
if (total_size < request) {
puts(" * Result:");
puts(" * The system don't have enough free memory");
puts(" * Suggession : Go for VIRTUAL MEMORY");
return;
}
while (1) {
if (request <= size && div2(size) < request) {
break;
} else {
size = div2(size);
flevel++;
}
}
for (i = power_2(flevel) - 1; i <= (power_2(flevel + 1) - 2); i++) {
if (tree[i] == 0 && place(i)) {
tree[i] = request;
makedivided(i);
puts(" * Result : Successful Allocation");
break;
}
}
if (i == power_2(flevel + 1) - 1) {
puts(" * Result :");
puts(" * The system don't have enough free memory");
puts(" * Suggession : Go for VIRTUAL Memory Mode");
}
}
int main() {
int T; scanf("%d", &T);
for (int _ = 1; _ <= T; _++) {
scanf("%s%s", s, t);
for (int i = 0; i <= 40; i++) a[i] = b[i] = 0;
int cnt = 0;
for (int i = 0, l = strlen(s); i < l; i++) {
add(a, a, a);
if (s[i] == '1') a[0]++;
}
for (int i = 0, l = strlen(t); i < l; i++) {
add(b, b, b);
if (t[i] == '1') b[0]++;
}
while (!null(a) && !null(b)) {
if (!(a[0]&1) && !(b[0]&1)) div2(a, a), div2(b, b), cnt++;
else if (!(a[0]&1)) div2(a, a);
else if (!(b[0]&1)) div2(b, b);
else if (less(a, b)) sub(b, a, b);
else sub(a, b, a);
}
if (null(a)) memcpy(a, b, sizeof a);
for (int i = 0; i < cnt; i++)
add(a, a, a);
int i = 40; for (; i >= 0; i--) if (a[i]) break;
printf("Case #%d: ", _); print(a[i], false);
for (i--; i >= 0; i--)
print(a[i], true);
printf("\n");
}
return 0;
}
static inline int place(int node) {
while (node != 0) {
node = (mod2(node) == 0) ? div2(node - 1) : div2(node);
if (1 < tree[node]) {
return 0;
}
}
return 1;
}
int main(){
int m[S], z[S], r[S], y[S];
char tmp[S];
int y_p, m_p, z_p, r_p, sz, t=10;
while(t--){
scanf("%s", &tmp);
sz=-1;
while(tmp[++sz]!='\0');
memset(m,0,S);
memset(m,0,S);
m_p=S;
y_p=S;
sz--;
while(sz>=0){
m[--m_p]=tmp[sz]-'0';
y[--y_p]=tmp[sz]-'0';
sz--;
}
scanf("%s", &tmp);
sz=-1;
memset(m, 0, S);
while(tmp[++sz]!='\0');
z_p=S;
while(sz)z[--z_p]=tmp[--sz]-'0';
add(m, m_p, z, z_p, r, &r_p);
sz=S-1;
m_p=r_p;
while(sz){
m[sz]=r[sz];
sz--;
}
div2(m, m_p, r, &r_p);
print(r,r_p);
printf("\n");
sub(y, y_p, z, z_p, r, &r_p);
div2(r, r_p, m, &m_p);
print(m, m_p);
printf("\n");
}
return 0;
}
void solve() {
char s[10];
int ncmd = 0, begin = 0;
gets(line);
while (begin < strlen(line)){
sscanf(line + begin, "%s", cmd[++ncmd]);
begin += strlen(cmd[ncmd]);
while (line[begin] == ' ')
begin++;
}
p = 0;
while (ncmd) {
strcpy(s, cmd[ncmd]);
ncmd--;
if (strcmp(s, "id") == 0 || strcmp(s, "id-") == 0)
continue;
if (strcmp(s, "rot") == 0) rot();
else if (strcmp(s, "rot-") == 0) rot2();
else if (strcmp(s, "sym") == 0 || strcmp(s, "sym-") == 0) sym();
else if (strcmp(s, "bhsym") == 0 || strcmp(s, "bhsym-") == 0) bhsym();
else if (strcmp(s, "bvsym") == 0 || strcmp(s, "bvsym-") == 0) bvsym();
else if (strcmp(s, "div") == 0) div();
else if (strcmp(s, "div-") == 0) div2();
else if (strcmp(s, "mix") == 0) mix();
else if (strcmp(s, "mix-") == 0) mix2();
p = !p;
}
}
big_integer& big_integer::operator/=(big_integer const& rhs)
{
if (*this < rhs)
{
*this = big_integer(0);
return *this;
}
big_integer m(1);
big_integer a(-1), b(*this + 1);
while (b - a > big_integer(1))
{
m = div2(b + a + big_integer(1));
big_integer bb = m * rhs;
if (bb > *this) {
b = m;
}
else
{
a = m;
}
}
if (a * rhs <= *this) {
*this = a;
} else {
*this = b;
}
while (!data[data.size() - 1] and data.size() != 1) data.pop_back();
return *this;
}
int main ()
{
if (div1 (-(1 << 7)) != 1 << 7)
abort ();
if (div2 (-(1 << 15)) != 1 << 15)
abort ();
if (div3 (-(1 << 7), -1) != 1 << 7)
abort ();
if (div4 (-(1 << 15), -1) != 1 << 15)
abort ();
if (mod1 (-(1 << 7)) != 0)
abort ();
if (mod2 (-(1 << 15)) != 0)
abort ();
if (mod3 (-(1 << 7), -1) != 0)
abort ();
if (mod4 (-(1 << 15), -1) != 0)
abort ();
if (mod5 (0x50000000, 2) != 0)
abort ();
if (mod6 (0x50000000, 2) != 0)
abort ();
exit (0);
}
// FUNCTION: get_integer_from_base_36 {{{
// Converts given base-36 string into integer
// Warning: it tagets integer (signed), so
// the size of number is limited here (while
// decode_zcode generates series of bits of
// arbitrary length)
std::tuple<int, int> get_integer_from_base_36( const std::string & letters ) {
std::vector<int> bits;
std::string workingvar = letters;
// Get base-2 generated array consisting of 1 and 0
QRegExp rx("^0*$");
while( rx.indexIn( QString::fromLatin1( workingvar.c_str() ) ) == -1 ) {
int subtracted, error;
std::tie( workingvar, subtracted, error ) = div2( workingvar );
if( error != 0 ) {
return std::make_tuple( 0, error + 1000 );
}
bits.push_back( subtracted );
}
std::reverse( bits.begin(), bits.end() );
// Now sum up the obtained 0 and 1
int i, mul = 1, size = bits.size();
int REPLY=0;
for ( i = size - 1; i >= 0; i -- ) {
REPLY = REPLY + bits[i]*mul;
mul = mul * 2;
}
// TODO: detect overflow and other problems
return std::make_tuple( REPLY, 0 );
}
NewFloatRepresentation(F f)
: limbs{}, negative(f < 0.f), fpclass(std::fpclassify(f))
{
if (fpclass == FP_INFINITE || fpclass == FP_NAN) return;
unsigned limbIndex = Length<F>::e0;
float s = std::fabs(frexp(f, &exponent));
s *= 1<<29; // pre-scale with 2^29 to extract as many bits as possible in the first iteration
exponent -= 29; // store prescaling in exponent
limbs[limbIndex] = static_cast<limb_t>(s);
while (s) {
s -= limbs[limbIndex];
s *= 1<<29;
mult2(29);
limbIndex++;
limbs[limbIndex] = static_cast<limb_t>(s);
}
// scale to exponent=0
if (exponent < 0)
div2(-exponent);
else if (exponent > 0)
mult2(exponent);
}
static inline void makefree(int request) {
int node = 0;
while (tree[node] != request) {
node++;
}
tree[node] = 0;
while (node != 0) {
if ((tree[(mod2(node) == 0) ? node - 1 : node + 1] == 0) && tree[node] == 0) {
tree[(mod2(node) == 0) ? div2(node - 1) : div2(node)] = 0;
node = (mod2(node) == 0) ? div2(node - 1) : div2(node);
} else {
break;
}
}
}
// FUNCTION: div2 {{{
std::tuple< std::string, int, int > div2( const std::string & letters ) {
std::vector<char> out_letters;
int subtracted, error;
tie( out_letters, subtracted, error ) = div2( std::vector<char>( letters.c_str(), letters.c_str() + letters.size() ) );
if( error != 0 ) {
error += 7000;
}
return std::make_tuple( std::string( out_letters.begin(), out_letters.end() ), subtracted, error );
}
long powmod(long a,num *n,long m){
ll res=1,t=a;
num tmp=*n;
while(tmp.l>0){
if(div2(&tmp,&tmp)){
res=(res*t)%m;
}
t=(t*t)%m;
}
return (long) res;
}
void gcd(BigNumber n1,BigNumber n2)
{
long b=0,i;
while(n1.len && n2.len)
{
if(n1.v[0])
{
if(n2.v[0])
{
if(isSmaller(n1,n2))
n2=minus(n2,n1);
else
n1=minus(n1,n2);
}
else
n2=div2(n2);
}
else
{
if(n2.v[0])
n1=div2(n1);
else
{
n1=div2(n1);
n2=div2(n2);
b++;
}
}
}
if(n2.len)
for(i=n2.len-1;i>=0;i--)
printf("%d",n2.v[i]);
else
for(i=n1.len-1;i>=0;i--)
printf("%d",n1.v[i]);
while(b--)
printf("0");
printf("\n");
}
void refine_lower(mpq const & q, mpbq & l, mpbq & u) {
lean_assert(l < q && q < u);
lean_assert(!q.get_denominator().is_power_of_two());
mpbq mid;
while (true) {
mid = l + u;
div2(mid);
if (mid < q) {
swap(l, mid);
lean_assert(l < q && q < u);
return;
}
swap(u, mid);
}
}
bool Interval::div2_inter(const Interval& num, const Interval& div, Interval& out2) {
// warning: we may have &num==this
Interval out1,_out2;
div2(num,div,out1,_out2);
out1 &= *this;
if (out1.is_empty()) {
*this &= _out2;
out2.set_empty();
return !this->is_empty();
} else {
out2 = *this & _out2;
*this = out1;
return true;
}
}
int main(int argc, char *argv[])
{
int num;
int result;
char str[10];
// testa se ele é divisível por 2
printf("Enter a number: ");
scanf("%d", &num);
result = div2(num);
if(result != 0){
printf("your number is divisible by 2, it should even.");
}else{
printf("your number is not divisible by 2, it should odd.");
}
printf("\n\n ----------------------------------------------- \n\n");
// testa se ele é divisível por 3
printf("Enter a string: ");
scanf("%s", str);
/**
* Eu passei para ca o algoritimo de pegar valores absolutos
* de um número inteiro e somá-los entre si para fazer uma
* melhor debugação.... OBS: a função fgets() ñ funciona no Dev-C no win7
*/
int lengthNum, i, casting;
for(i = 0; i < strlen(str); i++){
casting = (int)str[i] - 48;
printf("\n");
printf("The number of this moment is >>>>> %d \n", casting);
lengthNum = 0;
lengthNum = lengthNum + casting;
}
printf("your string is: %d", lengthNum);
//printf("\n the length your string is: %d", div3(str));
printf("\n\n");
system("PAUSE");
return 0;
}
int* pow(int* a,int* b,int* mod,int size_a,int size_b,int size_m, bool sign_a,bool sign_b,bool sign_m,bool &sign_result,int &size_result)
{
int* new_a=div(a,mod,size_a,size_m,sign_a,sign_m,sign_a,size_a,1);
free(a);
a=new_a;
int* res = (int*) malloc((1 + 2)*sizeof(int));
int* ed = (int*) malloc((1 + 2)*sizeof(int));
res[0]=1;
res[1]=0;
size_result=1;
ed[0]=1;
ed[1]=0;
while (!is_zero(b,size_b))
{
if (b[0]%2==1)
{
int* new_res = mul(res,a,size_result,size_a,sign_result,sign_a,sign_result,size_result);
free(res);
res=new_res;
new_res=div(res,mod,size_result,size_m,sign_result,sign_m,sign_result,size_result,1);
free(res);
res=new_res;
int* new_b=sub(b,ed,size_b,1,0,0,sign_b,size_b);
free(b);
b=new_b;
}
else
{
new_a = mul(a,a,size_a,size_a,sign_a,sign_a,sign_a,size_a);
free(a);
a=new_a;
new_a=div(a,mod,size_a,size_m,sign_a,sign_b,sign_a,size_a,1);
free(a);
a=new_a;
div2(b,size_b);
}
}
return res;
}
//==================================================================
static PFORCEINLINE void makeAvgAndDiff( const TMPTYPE *srcp, TMPTYPE * const desp, u_int n )
{
TMPTYPE * const avgp = desp;
TMPTYPE * const difp = desp + n/2;
//static const int oosqrt2 = (int)((1 << 10) / 1.414213562f);
for (int i=0; i < n/2; ++i)
{
int v1 = *srcp++;
int v2 = *srcp++;
//int avg = right_shift( (v1 + v2) * oosqrt2, 10 );
int avg = div2( v1 + v2 );
avgp[i] = avg;
difp[i] = avg - v1;
}
}
int main(){
float a,b;
int x;
printf("Digite qual operaçao deseja realizar\n");
printf(" 1 Para somar\n");
printf(" 2 para subtrair\n");
printf(" 3 para dividir\n");
printf(" 4 para multiplicar\n");
scanf("%d",&x);
printf(" Digite o primeiro numero");
scanf("%f", &a);
printf(" Digite o segundo numero");
scanf("%f", &b);
if (x=1) {
soma2();}else if (x=2) {
dif2();}else if (x=3) {
div2();} else if (x=4) {
prod2();} else printf("Operação nao listada");
system("pause");
return 0;
}
// FUNCTION: decode_zcode {{{
// Takes zekyl code, i.e. 1/someletters
// and decodes it to sequence of bits
std::tuple< std::vector<int>, int > decode_zcode( const std::string & code ) {
QString _code = QString::fromStdString( code );
QStringList num_let = _code.split("/");
if( num_let.count() != 2 ) {
return std::make_tuple( std::vector<int>(), 101 );
}
bool ok = false;
int number = num_let.first().toInt( &ok );
if( !ok ) {
return std::make_tuple( std::vector<int>(), 102 );
}
std::string letters = num_let.last().toUtf8().constData();
// The zcode can have at most 30 digits
// This is the 150 bits (150 zekylls)
// written in base 36. We have to obtain
// the 150 bits. We will implement division
// in base 36 and gradually obtain the 150 bits.
std::vector<int> bits;
std::string workingvar = letters;
QRegExp rx("^0*$");
while( rx.indexIn( QString::fromStdString( workingvar ) ) == -1 ) {
int subtracted, error;
std::tie( workingvar, subtracted, error ) = div2( workingvar );
if( error != 0 ) {
return std::make_tuple( std::vector<int>(), 103 );
}
bits.push_back( subtracted );
// print "After div $workingvar/${reply[2]}"
}
std::reverse( bits.begin(), bits.end() );
// print "Bits of the letters $letters are: ${(j::)bits[@]}"
return std::make_tuple( bits, 0 );
}
int main ()
{
freopen ("D.in", "r", stdin);
freopen ("D.out", "w", stdout);
get(a, n); get(b, m);
scanf ("%d", &p);
int i, j, carry = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
if (i + j + 1 > N)
N = i + j + 1;
c[i + j] += a[i] * b[j] + carry;
carry = c[i + j] / 10;
c[i + j] %= 10;
}
for (;carry; j++)
{
if (i + j + 1 > N)
N = i + j + 1;
c[i + j] += carry;
carry = c[i + j] / 10;
c[i + j] %= 10;
}
}
long long R = 1, A = 2;
while (N)
{
if (c[0] & 1)
R = (R * A) % p;
A = (A * A) % p;
div2();
}
printf( i64 , R);
return 0;
}
// ######################################################################
void env_stdio_print_alloc_stats(const struct env_alloc_stats* p,
const env_size_t block_size)
{
env_size_t kiB_block_size_whole, kiB_block_size_fract;
div2(block_size, 1024, 2,
&kiB_block_size_whole, &kiB_block_size_fract);
ENV_ASSERT(block_size > 0);
env_size_t n_cache_blocks = 0;
for (env_size_t i = 0; i < p->ncache_used; ++i)
{
const env_size_t nb =
(p->cache[i].num_allocations
* p->cache[i].alloc_size);
n_cache_blocks += p->cache[i].num_allocations;
env_size_t kiB_alloc_whole, kiB_alloc_fract;
div2(nb, 1024, 2,
&kiB_alloc_whole, &kiB_alloc_fract);
env_size_t kiB_alloc_size_whole, kiB_alloc_size_fract;
div2(p->cache[i].alloc_size, 1024, 4,
&kiB_alloc_size_whole, &kiB_alloc_size_fract);
env_size_t alloc_percent_whole, alloc_percent_fract;
div2(nb*100, p->bytes_allocated, 2,
&alloc_percent_whole, &alloc_percent_fract);
env_size_t block_ratio_whole, block_ratio_fract;
char symbol;
if (p->cache[i].alloc_size - p->overhead >= block_size
|| p->cache[i].alloc_size - p->overhead <= 1)
{
div2(p->cache[i].alloc_size - p->overhead,
block_size, 1,
&block_ratio_whole, &block_ratio_fract);
symbol = '*';
}
else
{
div2(block_size,
p->cache[i].alloc_size - p->overhead, 1,
&block_ratio_whole, &block_ratio_fract);
symbol = '/';
}
fprintf(stderr,
"memstats: cache[%02lu/%02lu]: "
"%5lu.%02lukiB (%3lu.%02lu%%) "
"in %4lu allocations "
"(%2lu active) of %5lu.%04lukiB"
" (%lu.%02lukiB %c %5lu.%01lu + %2luB)\n",
i, ENV_NCACHE,
kiB_alloc_whole, kiB_alloc_fract,
alloc_percent_whole, alloc_percent_fract,
p->cache[i].num_allocations,
p->cache[i].num_active,
kiB_alloc_size_whole, kiB_alloc_size_fract,
kiB_block_size_whole, kiB_block_size_fract,
(int) symbol,
block_ratio_whole, block_ratio_fract,
p->overhead);
}
env_size_t kiB_alloc_whole, kiB_alloc_fract;
div2(p->bytes_allocated, 1024, 2,
&kiB_alloc_whole, &kiB_alloc_fract);
env_size_t n_blocks_whole, n_blocks_fract;
div2(p->bytes_allocated, block_size, 1,
&n_blocks_whole, &n_blocks_fract);
fprintf(stderr,
"memstats: =====[TOTAL]: "
"%5lu.%02lukiB (100.00%%) "
"in %4lu allocations "
"(%2lu active) ================"
" (%lu.%02lukiB * %5lu.%01lu )\n",
kiB_alloc_whole, kiB_alloc_fract,
n_cache_blocks,
p->nallocations_current,
kiB_block_size_whole, kiB_block_size_fract,
n_blocks_whole, n_blocks_fract);
fprintf(stderr,
"memstats: %lu/%lu cache table entries in use\n",
p->ncache_used, ENV_NCACHE);
fprintf(stderr,
"memstats: block alignment: %lu bytes\n", p->nalign);
fprintf(stderr,
"memstats: all-time: %llukiB in %lu requested allocations\n",
p->nbytes_alltime/1024, p->nallocations_alltime);
fprintf(stderr,
"memstats: current: %lukiB in %lu active allocations\n",
(unsigned long)(p->nbytes_current/1024),
p->nallocations_current);
}
/*...sgbm_ht_VGA_2x2 \45\ halftone by 2x2 to default VGA palette:0:*/
void gbm_ht_VGA_2x2(const GBM *gbm, const byte *src24, byte *dest4)
{
int stride24 = ((gbm->w * 3 + 3) & ~3);
int stride4 = ((gbm->w * 4 + 31) / 32) * 4;
int x, y;
init();
src24 -= stride24;
dest4 -= stride4;
for ( y = 0; y < gbm->h - 1; y += 2 )
{
const byte *src24a = (src24 += stride24);
const byte *src24b = (src24 += stride24);
byte *dest4a = (dest4 += stride4);
byte *dest4b = (dest4 += stride4);
for ( x = 0; x < gbm->w - 1; x += 2 )
/*...s2x2 case:24:*/
{
word r,g,b;
byte inx;
byte *tmp;
b = *src24a++; g = *src24a++; r = *src24a++;
b += *src24a++; g += *src24a++; r += *src24a++;
b += *src24b++; g += *src24b++; r += *src24b++;
b += *src24b++; g += *src24b++; r += *src24b++;
inx = takefrom(div4(r), div4(g), div4(b)); *dest4a = (inx << 4);
b -= gbmrgb_vga[inx].b; g -= gbmrgb_vga[inx].g; r -= gbmrgb_vga[inx].r;
inx = takefrom(div3(r), div3(g), div3(b)); *dest4a++ |= inx;
b -= gbmrgb_vga[inx].b; g -= gbmrgb_vga[inx].g; r -= gbmrgb_vga[inx].r;
inx = takefrom(div2(r), div2(g), div2(b)); *dest4b = (inx << 4);
b -= gbmrgb_vga[inx].b; g -= gbmrgb_vga[inx].g; r -= gbmrgb_vga[inx].r;
inx = takefrom(r , g , b ); *dest4b++ |= inx;
tmp = dest4a; dest4a = dest4b; dest4b = tmp;
}
/*...e*/
if ( x < gbm->w )
/*...s1x2 case:24:*/
{
word r,g,b;
byte inx;
b = *src24a++; g = *src24a++; r = *src24a;
b += *src24b++; g += *src24b++; r += *src24b;
inx = takefrom(div2(r), div2(g), div2(b)); *dest4a = (inx << 4);
b -= gbmrgb_vga[inx].b; g -= gbmrgb_vga[inx].g; r -= gbmrgb_vga[inx].r;
inx = takefrom(r , g , b ); *dest4b = (inx << 4);
}
/*...e*/
}
if ( y < gbm->h )
{
const byte *src24a = src24 + stride24;
byte *dest4a = dest4 + stride4;
for ( x = 0; x < gbm->w - 1; x += 2 )
/*...s2x1 case:24:*/
{
word r,g,b;
byte inx;
b = *src24a++; g = *src24a++; r = *src24a++;
b += *src24a++; g += *src24a++; r += *src24a++;
inx = takefrom(div2(r), div2(g), div2(b)); *dest4a = (inx << 4);
b -= gbmrgb_vga[inx].b; g -= gbmrgb_vga[inx].g; r -= gbmrgb_vga[inx].r;
inx = takefrom(r , g , b ); *dest4a++ |= inx;
}
/*...e*/
if ( x < gbm->w )
/*...s1x1 case:24:*/
{
word r, g, b;
byte inx;
b = *src24a++; g = *src24a++; r = *src24a;
inx = takefrom(r, g, b); *dest4a = (inx << 4);
}
/*...e*/
}
}
void do_response()
{
Ptr_PageTableItem ptr_pageTabIt;
unsigned int pageNum, offAddr;
unsigned int actAddr;
static int counter=10;
if(--counter<=0) {
div2(); counter=10;
}
if(ptr_memAccReq->reqType==REQUEST_SWITCH)
{
do_switch();
return;
}
/* 检查地址是否越界 */
if (ptr_memAccReq->virAddr < 0 || ptr_memAccReq->virAddr >= VIRTUAL_MEMORY_SIZE)
{
printf("error1\n");
do_error(ERROR_OVER_BOUNDARY);
return;
}
/* 计算页号和页内偏移值 */
pageNum = ptr_memAccReq->virAddr / PAGE_SIZE;
offAddr = ptr_memAccReq->virAddr % PAGE_SIZE;
printf("页号为：%u\t页内偏移为：%u\n", pageNum, offAddr);
/* 获取对应页表项 */
ptr_pageTabIt = (*pageTable)[pageNum/8]+pageNum%8;;
/* 根据特征位决定是否产生缺页中断 */
if (!ptr_pageTabIt->filled)
{
do_page_fault(ptr_pageTabIt);
}
actAddr = ptr_pageTabIt->blockNum * PAGE_SIZE + offAddr;
printf("实地址为：%u\n", actAddr);
/* 检查页面访问权限并处理访存请求 */
switch (ptr_memAccReq->reqType)
{
case REQUEST_READ: //读请求
{
ptr_pageTabIt->count++;
aaaaaaccess(ptr_pageTabIt->blockNum);
if (!(ptr_pageTabIt->proType & READABLE)) //页面不可读
{
printf("error2\n");
do_error(ERROR_READ_DENY);
return;
}
/* 读取实存中的内容 */
printf("读操作成功：值为%02X\n", actMem[actAddr]);
break;
}
case REQUEST_WRITE: //写请求
{
ptr_pageTabIt->count++;
aaaaaaccess(ptr_pageTabIt->blockNum);
if (!(ptr_pageTabIt->proType & WRITABLE)) //页面不可写
{
printf("error3\n");
do_error(ERROR_WRITE_DENY);
return;
}
/* 向实存中写入请求的内容 */
actMem[actAddr] = ptr_memAccReq->value;
ptr_pageTabIt->edited = TRUE;
printf("写操作成功\n");
break;
}
case REQUEST_EXECUTE: //执行请求
{
ptr_pageTabIt->count++;
aaaaaaccess(ptr_pageTabIt->blockNum);
if (!(ptr_pageTabIt->proType & EXECUTABLE)) //页面不可执行
{
printf("error4\n");
do_error(ERROR_EXECUTE_DENY);
return;
}
printf("执行成功\n");
break;
}
default: //非法请求类型
{
printf("error5\n");
do_error(ERROR_INVALID_REQUEST);
return;
}
}
}
void gbm_ht_4R4G4B_2x2(const GBM *gbm, const byte *src24, byte *dest8)
{
int stride24 = ((gbm->w * 3 + 3) & ~3);
int stride8 = ((gbm->w + 3) & ~3);
int x, y;
init();
src24 -= stride24;
dest8 -= stride8;
for ( y = 0; y < gbm->h - 1; y += 2 )
{
const byte *src24a = (src24 += stride24);
const byte *src24b = (src24 += stride24);
byte *dest8a = (dest8 += stride8);
byte *dest8b = (dest8 += stride8);
for ( x = 0; x < gbm->w - 1; x += 2 )
/*...s2x2 case:24:*/
{
word r,g,b;
byte ri,gi,bi;
byte *tmp;
b = *src24a++; g = *src24a++; r = *src24a++;
b += *src24a++; g += *src24a++; r += *src24a++;
b += *src24b++; g += *src24b++; r += *src24b++;
b += *src24b++; g += *src24b++; r += *src24b++;
bi = index4[div4(b)]; gi = index4[div4(g)]; ri = index4[div4(r)];
*dest8a++ = PIX444(ri,gi,bi);
b -= scale4[bi]; g -= scale8[gi]; r -= scale7[ri];
bi = index4[div3(b)]; gi = index4[div3(g)]; ri = index4[div3(r)];
*dest8a++ = PIX444(ri,gi,bi);
b -= scale4[bi]; g -= scale8[gi]; r -= scale7[ri];
bi = index4[div2(b)]; gi = index4[div2(g)]; ri = index4[div2(r)];
*dest8b++ = PIX444(ri,gi,bi);
b -= scale4[bi]; g -= scale8[gi]; r -= scale7[ri];
bi = index4[b ]; gi = index4[g ]; ri = index4[r ];
*dest8b++ = PIX444(ri,gi,bi);
tmp = dest8a; dest8a = dest8b; dest8b = tmp;
}
/*...e*/
if ( x < gbm->w )
/*...s1x2 case:24:*/
{
word r,g,b;
byte ri, gi, bi;
b = *src24a++; g = *src24a++; r = *src24a;
b += *src24b++; g += *src24b++; r += *src24b;
bi = index4[div2(b)]; gi = index4[div2(g)]; ri = index4[div2(r)];
*dest8a = PIX444(ri,gi,bi);
b -= scale4[bi]; g -= scale8[gi]; r -= scale7[ri];
bi = index4[b ]; gi = index4[g ]; ri = index4[r ];
*dest8b = PIX444(ri,gi,bi);
}
/*...e*/
}
if ( y < gbm->h )
{
const byte *src24a = src24 + stride24;
byte *dest8a = dest8 + stride8;
for ( x = 0; x < gbm->w - 1; x += 2 )
/*...s2x1 case:24:*/
{
word r,g,b;
byte ri, gi, bi;
b = *src24a++; g = *src24a++; r = *src24a++;
b += *src24a++; g += *src24a++; r += *src24a++;
bi = index4[div2(b)]; gi = index4[div2(g)]; ri = index4[div2(r)];
*dest8a++ = PIX444(ri,gi,bi);
b -= scale4[bi]; g -= scale8[gi]; r -= scale7[ri];
bi = index4[b ]; gi = index4[g ]; ri = index4[r ];
*dest8a++ = PIX444(ri,gi,bi);
}
/*...e*/
if ( x < gbm->w )
/*...s1x1 case:24:*/
{
byte ri, gi, bi;
bi = index4[*src24a++]; gi = index4[*src24a++]; ri = index4[*src24a];
*dest8a = PIX444(ri,gi,bi);
}
/*...e*/
}
}
/*...sgbm_ht_24_2x2 \45\ halftone by 2x2 to r\58\g\58\b bits:0:*/
void gbm_ht_24_2x2(const GBM *gbm, const byte *src24, byte *dest24, byte rm, byte gm, byte bm)
{
int stride = ((gbm->w * 3 + 3) & ~3);
int x, y;
init();
src24 -= stride;
dest24 -= stride;
for ( y = 0; y < gbm->h - 1; y += 2 )
{
const byte *src24a = (src24 += stride);
const byte *src24b = (src24 += stride);
byte *dest24a = (dest24 += stride);
byte *dest24b = (dest24 += stride);
for ( x = 0; x < gbm->w - 1; x += 2 )
/*...s2x2 case:24:*/
{
word r,g,b;
byte ri,gi,bi;
byte *tmp;
b = *src24a++; g = *src24a++; r = *src24a++;
b += *src24a++; g += *src24a++; r += *src24a++;
b += *src24b++; g += *src24b++; r += *src24b++;
b += *src24b++; g += *src24b++; r += *src24b++;
bi = (div4(b) & bm); gi = (div4(g) & gm); ri = (div4(r) & rm);
*dest24a++ = bi; *dest24a++ = gi; *dest24a++ = ri;
b -= bi; g -= gi; r -= ri;
if ( b > 255 * 3 ) b = 255 * 3;
if ( g > 255 * 3 ) g = 255 * 3;
if ( r > 255 * 3 ) r = 255 * 3;
bi = (div3(b) & bm); gi = (div3(g) & gm); ri = (div3(r) & rm);
*dest24a++ = bi; *dest24a++ = gi; *dest24a++ = ri;
b -= bi; g -= gi; r -= ri;
if ( b > 255 * 2 ) b = 255 * 2;
if ( g > 255 * 2 ) g = 255 * 2;
if ( r > 255 * 2 ) r = 255 * 2;
bi = (div2(b) & bm); gi = (div2(g) & gm); ri = (div2(r) & rm);
*dest24b++ = bi; *dest24b++ = gi; *dest24b++ = ri;
b -= bi; g -= gi; r -= ri;
if ( b > 255 ) b = 255;
if ( g > 255 ) g = 255;
if ( r > 255 ) r = 255;
bi = (b & bm); gi = (g & gm); ri = (r & rm);
*dest24b++ = bi; *dest24b++ = gi; *dest24b++ = ri;
tmp = dest24a; dest24a = dest24b; dest24b = tmp;
}
/*...e*/
if ( x < gbm->w )
/*...s1x2 case:24:*/
{
word r,g,b;
byte ri, gi, bi;
b = *src24a++; g = *src24a++; r = *src24a;
b += *src24b++; g += *src24b++; r += *src24b;
bi = (div2(b) & bm); gi = (div2(g) & gm); ri = (div2(r) & rm);
*dest24a++ = bi; *dest24a++ = gi; *dest24a++ = ri;
b -= bi; g -= gi; r -= ri;
if ( b > 255 ) b = 255;
if ( g > 255 ) g = 255;
if ( r > 255 ) r = 255;
bi = (b & bm); gi = (g & gm); ri = (r & rm);
*dest24b++ = bi; *dest24b++ = gi; *dest24b = ri;
}
/*...e*/
}
if ( y < gbm->h )
{
const byte *src24a = src24 + stride;
byte *dest24a = dest24 + stride;
for ( x = 0; x < gbm->w - 1; x += 2 )
/*...s2x1 case:24:*/
{
word r,g,b;
byte ri, gi, bi;
b = *src24a++; g = *src24a++; r = *src24a++;
b += *src24a++; g += *src24a++; r += *src24a++;
bi = (div2(b) & bm); gi = (div2(g) & gm); ri = (div2(r) & rm);
*dest24a++ = bi; *dest24a++ = gi; *dest24a++ = ri;
b -= bi; g -= gi; r -= ri;
if ( b > 255 ) b = 255;
if ( g > 255 ) g = 255;
if ( r > 255 ) r = 255;
bi = (b & bm); gi = (g & gm); ri = (r & rm);
*dest24a++ = bi; *dest24a++ = gi; *dest24a++ = ri;
}
/*...e*/
if ( x < gbm->w )
/*...s1x1 case:24:*/
{
byte ri, gi, bi;
bi = ((*src24a++) & bm); gi = ((*src24a++) & gm); ri = ((*src24a) & rm);
*dest24a++ = bi; *dest24a++ = gi; *dest24a = ri;
}
/*...e*/
}
}
static void split_into8(
word r, word g, word b,
int n, byte *inxs
)
{
byte inx;
if ( n >= 9 )
{
inx = takefrom8(div9(r), div9(g), div9(b));
b -= gbmrgb_8[inx].b;
g -= gbmrgb_8[inx].g;
r -= gbmrgb_8[inx].r;
*inxs++ = inx;
inx = takefrom8(div8(r), div8(g), div8(b));
b -= gbmrgb_8[inx].b;
g -= gbmrgb_8[inx].g;
r -= gbmrgb_8[inx].r;
*inxs++ = inx;
inx = takefrom8(div7(r), div7(g), div7(b));
b -= gbmrgb_8[inx].b;
g -= gbmrgb_8[inx].g;
r -= gbmrgb_8[inx].r;
*inxs++ = inx;
}
if ( n >= 6 )
{
inx = takefrom8(div6(r), div6(g), div6(b));
b -= gbmrgb_8[inx].b;
g -= gbmrgb_8[inx].g;
r -= gbmrgb_8[inx].r;
*inxs++ = inx;
inx = takefrom8(div5(r), div5(g), div5(b));
b -= gbmrgb_8[inx].b;
g -= gbmrgb_8[inx].g;
r -= gbmrgb_8[inx].r;
*inxs++ = inx;
}
if ( n >= 4 )
{
inx = takefrom8(div4(r), div4(g), div4(b));
b -= gbmrgb_8[inx].b;
g -= gbmrgb_8[inx].g;
r -= gbmrgb_8[inx].r;
*inxs++ = inx;
}
if ( n >= 3 )
{
inx = takefrom8(div3(r), div3(g), div3(b));
b -= gbmrgb_8[inx].b;
g -= gbmrgb_8[inx].g;
r -= gbmrgb_8[inx].r;
*inxs++ = inx;
}
inx = takefrom8(div2(r), div2(g), div2(b));
b -= gbmrgb_8[inx].b;
g -= gbmrgb_8[inx].g;
r -= gbmrgb_8[inx].r;
*inxs++ = inx;
*inxs = takefrom8(r, g, b);
}
tool(void)
{
char buf[BUFSIZ],*p;
unsigned short div2(char *,char **);
struct KEY kk,*kp;
size_t cnt;
FILE *fp;
int i,sts;
keyptr = key;
ininame = "keys.ini";
if((fp= fopen(ininame,"r")) == NULL) { /* Curent directory */
if((p= getenv("KEYS")) != NULL) {
fp= fopen(p,"r"); /* Env val directory */
}
}
if(fp == NULL) {
#ifndef UNIX
_searchenv(ininame,"PATH",buf);
#else
sprintf(buf,"/usr/local/etc/%s", ininame);
#endif
if((fp= fopen(buf,"r")) == NULL) return(NG); /* PATH directory */
}
if((keyptr = (struct KEY *)calloc(KEYDEFMAX,sizeof(struct KEY))) == NULL)
abort();
cnt= 0;
while(fgets(buf,BUFSIZ,fp) != NULL) {
crcut(buf);
if(buf[0] == ';' || buf[0] == '*' || buf[0] == '#') continue;
if((kk.code = div2(buf,&p)) == 0xffff) {
keyptr = key; break;
}
kk.keyword = buf;
kp = lfind(&kk, key, &key_count,sizeof(struct KEY),cpkey);
if(kp == NULL) {
if(othset(&kk,buf,p) == NG) {
ndprintf("Keyword not found [%s]!\n",buf);
if(ynchk("Continue ?") != YES) {
#if (defined TEXT98)
popscrn();
#elif (defined UNIX)
ttclose();
#else
batch("///",NULL);
#endif
exit(1);
}
}
continue;
}
kk.func = kp->func;
kk.helpmsg = kp->helpmsg;
if(key_count < KEYDEFMAX) {
if(cnt) kp = lfind(&kk, keyptr, &cnt,sizeof(struct KEY), codekey);
else kp= NULL;
if(kp == NULL) {
kk.keyword= memgets(buf);
lsearch(&kk, keyptr, &cnt, sizeof(struct KEY), codekey);
}
}
}
key_count= cnt;
fclose(fp);
}
static inline void makedivided(int node) {
while (node != 0) {
node = (mod2(node) == 0) ? div2(node - 1) : div2(node);
tree[node] = 1;
}
}
