void shift(int A[MAX], int units) { if(units < 0) { left_shift(A, -units); } else if(units > 0) { right_shift(A, units); } }
/** * dividend = numerator, divisor = denominator * * Note that this process destroys divisor (and, of course, * overwrites quotient). The dividend is the remainder of the * division (if that's important to the caller). The divisor will * be modified by this routine, but it will end up back where it * “started”. */ void divide( huge *dividend, huge *divisor, huge *quotient ) { int bit_size, bit_position; // "bit_position" keeps track of which bit, of the quotient, // is being set or cleared on the current operation. bit_size = bit_position = 0; // First, left-shift divisor until it's >= than the dividend while ( compare( divisor, dividend ) < 0 ) { left_shift( divisor ); bit_size++; } // overestimates a bit in some cases if ( quotient ) { quotient->sign = !( dividend->sign == dividend->sign ); quotient->size = ( bit_size / 8 ) + 1; quotient->rep = ( unsigned char * ) calloc(quotient->size, sizeof( unsigned char ) ); memset( quotient->rep, 0, quotient->size ); } bit_position = 8 - ( bit_size % 8 ) - 1; do { if ( compare( divisor, dividend ) <= 0 ) { subtract_magnitude( dividend, divisor ); // dividend -= divisor if ( quotient ) { quotient->rep[ ( int ) ( bit_position / 8 ) ] |= ( 0x80 >> ( bit_position % 8 ) ); } } if ( bit_size ) { right_shift( divisor ); } bit_position++; }
/************************************************************** * MOVE UP **************************************************************/ char jet_moveUp(struct Jet* input) { if (input -> yLocation == 0 && input -> yPos == 8) { return 1; } else { char move_index; if (input -> yPos == 8) { set_LCD_Cursor(input -> xLocation, input -> yLocation + 1); for (move_index = 0; move_index < JET_LENGTH; move_index++) { LcdWrite(0x00); input -> bot_row[move_index] = input -> mid_row[move_index]; input -> mid_row[move_index] = input -> top_row[move_index]; input -> top_row[move_index] = 0x00; } input -> yPos = 0; input -> yLocation--; } //Shift the object values to make it appear to move up for (move_index = 0; move_index < JET_LENGTH; move_index++) { right_shift(&input -> mid_row[move_index], &input -> top_row[move_index]); if ((input -> bot_row[move_index] & 0x01) == 0x01) { input -> mid_row[move_index] = input -> mid_row[move_index] | 0x80; } input -> bot_row[move_index] = input -> bot_row[move_index] >> 1; } input -> yPos++; input -> yPixelPosition--; display_jet(input, 0); return 0; } }
/**************************************************** * Falcon MOVE UP ****************************************************/ char Falcon_moveUp(struct Falcon* Falcon) { if (Falcon -> yPixelPosition == 0) { return 1; } else { char falcon_index; if (Falcon -> yPos == 8) { set_LCD_Cursor(Falcon -> xLocation, Falcon -> yLocation + 1); for (falcon_index = 0; falcon_index < SHIP_LENGTH; falcon_index++) { LcdWrite(0x00); Falcon -> bot_row[falcon_index] = Falcon -> mid_row[falcon_index]; Falcon -> mid_row[falcon_index] = Falcon -> top_row[falcon_index]; Falcon -> top_row[falcon_index] = 0x00; } Falcon -> yPos = 0; Falcon -> yLocation--; } //Shift the object values to make it appear to move up for (falcon_index = 0; falcon_index < SHIP_LENGTH; falcon_index++) { right_shift(&Falcon -> mid_row[falcon_index], &Falcon -> top_row[falcon_index]); if ((Falcon -> bot_row[falcon_index] & 0x01) == 0x01) { Falcon -> mid_row[falcon_index] = Falcon -> mid_row[falcon_index] | 0x80; } Falcon -> bot_row[falcon_index] = Falcon -> bot_row[falcon_index] >> 1; } Falcon -> yPos++; Falcon -> yPixelPosition--; displayFalcon(Falcon, 0); return 0; } }
static void do_rsh(enum size_tag size, gp_boolean is_const, int value, char *name) { int i; gp_boolean is_signed = false; char *reg1 = NULL; char *reg2 = NULL; char *label1 = NULL; char *label2 = NULL; switch (size) { case size_bit: assert(0); break; case size_int8: is_signed = true; /* fall through */ case size_uint8: reg1 = codegen_get_temp(size); if (is_const) { codegen_write_asm("movwf %s", reg1); for (i = 0; i < value; i++) { if (is_signed) { /* put the sign in the carry */ codegen_write_asm("rlf %s, w", reg1); } else { codegen_write_asm("bcf STATUS, C"); } codegen_write_asm("rrf %s, f", reg1, i); } codegen_write_asm("movf %s, w", reg1); /* move the result into w */ } else { reg2 = codegen_get_temp(size); label1 = codegen_next_label(); label2 = codegen_next_label(); codegen_write_asm("movwf %s", reg1); codegen_write_asm("movf %s, w", name); codegen_write_asm("movwf %s", reg2); codegen_write_label(label1); codegen_write_asm("btfsc STATUS, Z"); codegen_write_asm("goto %s", label2); if (is_signed) { /* put the sign in the carry */ codegen_write_asm("rlf %s, w", reg1); } else { codegen_write_asm("bcf STATUS, C"); } codegen_write_asm("rrf %s, f", reg1); codegen_write_asm("decf %s, f", reg2); codegen_write_asm("goto %s", label1); codegen_write_label(label2); codegen_write_asm("movf %s, w", reg1); /* move the result into w */ } break; case size_int16: case size_int24: case size_int32: is_signed = true; /* fall through */ case size_uint16: case size_uint24: case size_uint32: reg1 = codegen_get_temp(size_uint8); label1 = codegen_next_label(); label2 = codegen_next_label(); if (is_const) { codegen_write_asm("movlw %#x", value); codegen_write_asm("addlw 0", value); } else { /* never can shift more than 31 so read the bottom byte only */ codegen_write_asm("movf %s, w", name); } codegen_write_asm("movwf %s", reg1); codegen_write_label(label1); codegen_write_asm("btfsc STATUS, Z"); codegen_write_asm("goto %s", label2); codegen_write_asm("bcf STATUS, C"); right_shift(size, is_signed); codegen_write_asm("decf %s, f", reg1); codegen_write_asm("goto %s", label1); codegen_write_label(label2); break; case size_float: default: assert(0); } if (reg1) free(reg1); if (reg2) free(reg2); if (label1) free(label1); if (label2) free(label2); }
//================================================================== static PFORCEINLINE int div2( int val ) { return right_shift( val, 1 ); }
static void blockToHaar( const TBLOCK *in_blockp, short out_haarp[ScreenHaarComprPack::BLOCK_DIM][ScreenHaarComprPack::BLOCK_DIM], u_int block_dim, u_int min_dim, u_int shift_bits ) { PASSERT( min_dim >= 2 ); TMPTYPE tmp_line1[ScreenHaarComprPack::BLOCK_DIM]; TMPTYPE tmp_line2[ScreenHaarComprPack::BLOCK_DIM]; TMPTYPE tmp_haar[ScreenHaarComprPack::BLOCK_DIM][ScreenHaarComprPack::BLOCK_DIM]; #if 0 for (int y=0; y < block_dim; ++y) { for (int x=0; x < block_dim; ++x) { *out_haarp++ = *in_blockp++; } } return; #endif for (int y=0; y < block_dim; ++y) { int y_off = y * block_dim; for (int i=0; i < block_dim; ++i) tmp_line1[i] = in_blockp[ i + y_off ]; for (int n = block_dim; n >= min_dim; n /= 2) { for (int i=0; i < n; ++i) tmp_line2[i] = tmp_line1[i]; makeAvgAndDiff( tmp_line2, tmp_line1, n ); } for (int i=0; i < block_dim; ++i) tmp_haar[i][y] = tmp_line1[i]; } for (int x=0; x < block_dim; ++x) { //for (int i=0; i < block_dim; ++i) // tmp_line1[i] = tmp_haar[x][i]; memcpy( tmp_line1, tmp_haar[x], ScreenHaarComprPack::BLOCK_DIM*sizeof(tmp_line1[0]) ); for (int n = block_dim; n >= min_dim; n /= 2) { for (int i=0; i < n; ++i) tmp_line2[i] = tmp_line1[i]; makeAvgAndDiff( tmp_line2, tmp_line1, n ); } for (int i=0; i < block_dim; ++i) { //if ( x == 0 && i == 0 ) // out_haarp[x][i] = pack_sign( tmp_line1[i] ); //else out_haarp[x][i] = pack_sign( right_shift( tmp_line1[i], shift_bits ) ); } } }