void instr_LEA (CPU *cpu) { int dst = bitshift(cpu->instr_reg,11,9,0); int pcoffset = (int)bitshift(cpu->instr_reg,8,0,1); cpu->reg[dst] = cpu->pgm_counter+pcoffset; printf("LEA R%d %x %x ; Reg[%x] <- %x + %x = %x \n",dst,cpu->pgm_counter,pcoffset,dst,cpu->pgm_counter,pcoffset,cpu->pgm_counter+pcoffset); set_condition_code(cpu,cpu->reg[dst]); }
void instr_STR (CPU *cpu) { int dst = bitshift(cpu->instr_reg,11,9,0); int base = bitshift(cpu->instr_reg,8,6,0); int offset = bitshift(cpu->instr_reg,5,0,1); cpu->memory[base+offset] = cpu->reg[dst]; printf("STR R%d R%d %x ; memory[%x+%x] = reg[%x]= %x\n",dst,base,offset,offset,cpu->pgm_counter,dst,cpu->reg[dst]); }
void instr_NOT (CPU *cpu) { int dst = bitshift(cpu->instr_reg,11,9,0); int src = bitshift(cpu->instr_reg,8,6,0); cpu->reg[dst] = ~cpu->reg[src]; printf("NOT R%d R%d ; reg[%x]<-~reg[%x] = \n",dst,src,dst,src,~cpu->reg[src]); set_condition_code(cpu,cpu->reg[dst]); }
void instr_LDI (CPU *cpu) { int dst = bitshift(cpu->instr_reg,11,9,0); int pcoffset = (int)bitshift(cpu->instr_reg,8,0,1); cpu->reg[dst] = cpu->memory[cpu->memory[pcoffset+cpu->pgm_counter]]; printf("LDI R%d %x %x ; reg[%x] <- memory[memory[%x+%x]] = %x \n",dst,pcoffset,cpu->pgm_counter,dst,pcoffset,cpu->pgm_counter,cpu->memory[cpu->memory[pcoffset+cpu->pgm_counter]]); set_condition_code(cpu,cpu->reg[dst]); }
void instr_ST (CPU *cpu) { int src = bitshift(cpu->instr_reg,11,9,0); int pcoffset = bitshift(cpu->instr_reg,8,0,1); cpu->memory[cpu->pgm_counter+pcoffset] = cpu->reg[src]; printf("ST R%d %x %x ; memory[%x] <-reg[%x] = %x,\n",src,cpu->pgm_counter,pcoffset,src,cpu->pgm_counter+pcoffset,cpu->reg[src]); }
void instr_LD (CPU *cpu) { int dst = bitshift(cpu->instr_reg,11,9,0); int pcoffset = bitshift(cpu->instr_reg,8,0,1); cpu->reg[dst] = cpu->memory[cpu->pgm_counter+pcoffset]; printf("LD R%d %d ; reg[%x]<- memory[%x] = %x ,\n",dst,pcoffset,dst,cpu->pgm_counter+pcoffset,cpu->memory[cpu->pgm_counter+pcoffset]); set_condition_code(cpu,cpu->reg[dst]); }
void instr_LDR (CPU *cpu) { int dst = bitshift(cpu->instr_reg,11,9,0); int base = bitshift(cpu->instr_reg,8,6,0); int offset = (int)bitshift(cpu->instr_reg,5,0,1); cpu->reg[dst] = cpu->memory[cpu->reg[base]+offset]; printf("LDR R%d %x %x ; reg[%x] <-memory[reg[%x]+%x] = %x\n",dst,base,offset,dst,base,offset,cpu->memory[cpu->reg[base]+offset]); set_condition_code(cpu,cpu->reg[dst]); }
void instr_AND (CPU *cpu) { int type = bitshift(cpu->instr_reg,5,5,0); int dst = bitshift(cpu->instr_reg,11,9,0); int src1 = bitshift(cpu->instr_reg,8,6,0); if(type==1){ int src2 = bitshift(cpu->instr_reg,2,0,0); cpu->reg[dst] = cpu->reg[src1]&cpu->reg[src2]; printf("AND R%d R%d 0 R%d; reg[%x]<-reg[%x]&®[%x] = %x\n",dst,src1,src2,dst,src1,src2,cpu->reg[src1]&cpu->reg[src2]); }else{ int imm5 =bitshift(cpu->instr_reg,4,0,0); cpu->reg[dst] = cpu->reg[src1]&imm5; printf("AND R%d R%d 1 %x; reg[%x]<-reg[%x]&&%x = %x\n",dst,src1,imm5,dst,src1,imm5,cpu->reg[src1]&imm5); } set_condition_code(cpu,cpu->reg[dst]); }
/* /\* } *\/ */ void instr_ADD (CPU *cpu) { int type = bitshift(cpu->instr_reg,5,5,0); int dst = bitshift(cpu->instr_reg,11,9,0); int src1 = bitshift(cpu->instr_reg,8,6,0); if(type==0){ int src2 = bitshift(cpu->instr_reg,2,0,0); cpu->reg[dst] = cpu->reg[src1]+cpu->reg[src2]; printf("ADD R%d R%d 0 R%d;reg[%d] = %x+%x = %x\n",dst,src1,src2,dst,cpu->reg[src1],cpu->reg[src2],cpu->reg[src1]+cpu->reg[src2]); }else{ int imm5 =bitshift(cpu->instr_reg,4,0,1); cpu->reg[dst] = cpu->reg[src1]+imm5; printf("ADD R%d R%d 1 %d; reg[%d] = %x +%x\n",dst,src1,imm5,dst,cpu->reg[src1],imm5,cpu->reg[src1]+imm5); } set_condition_code(cpu,cpu->reg[dst]); }
void instr_BR (CPU *cpu) { int mask = bitshift(cpu->instr_reg,11,9,0); char maskcode[30]; switch(mask){ case 0 : strcpy(maskcode,"NOP"); break; case 1 : strcpy(maskcode,"NOP"); break; case 2 : strcpy(maskcode,"Z '=0'"); break; case 3 : strcpy(maskcode,"PZ '>=0'"); break; case 4 : strcpy(maskcode,"N '<0'"); break; case 5 : strcpy(maskcode,"NP '!=0'"); break; case 6 : strcpy(maskcode,"NZ '<=0'"); break; case 7 : strcpy(maskcode,"BR 'unconditional'"); break; } int pcoffset = bitshift(cpu->instr_reg,8,0,1); if(mask&get_condition_code(cpu)!=0){ int oldcounter = cpu->pgm_counter; cpu->pgm_counter += pcoffset; printf("BR number:%d %s ;condition satisify! New pgm_counter = %x + %x = %x\n",cpu->condition_number,maskcode,oldcounter,pcoffset,cpu->pgm_counter); }else{ printf("BR number:%d %s ;condition NOT satisify!\n",cpu->condition_number,maskcode); } }
/** * Evaluates the comparison expressions: greater than (a > b), less than (a < b), * greater than or equal to (a >= b), less than or equal to (a <= b), * which have the same operator precedence, by recursively calling the * functions for evaluating expressions with higher precedence. * * @param[out] ret: the integer value the logical and expression evaluates to * * @return: whether at the current location the expression can be evaluated */ bool MacroParser::comparison(int64_t *ret) { int64_t term2 = 0; if (bitshift(ret)) { for (;;) { if (_scanner.atSymbol(GT_EQ)) { if (bitshift(&term2)) { *ret = *ret >= term2; } else { return false; } } else if (_scanner.atSymbol(LT_EQ)) { if (bitshift(&term2)) { *ret = *ret <= term2; } else { return false; } } else if (_scanner.atSymbol(GT)) { if (bitshift(&term2)) { *ret = *ret > term2; } else { return false; } } else if (_scanner.atSymbol(LT)) { if (bitshift(&term2)) { *ret = *ret < term2; } else { return false; } } else { return true; } } } return false; }
void instr_TRAP(CPU *cpu) { int vectors = bitshift(cpu->instr_reg,7,0,0); Word pointer; char temp; switch(vectors){ case 32: printf("input a char:"); scanf("%c",&temp); cpu->reg[0] = cpu->reg[0]&0; cpu->reg[0] =temp; printf("read a char '%c'\n",temp); break; case 33: temp = cpu->reg[0]; printf("%c",temp); break; case 34: pointer = cpu->reg[0]; while(cpu->memory[pointer]){ printf("%c",cpu->memory[pointer]); pointer++; } break; case 35: printf("Input a char:"); scanf("%c",&temp); cpu->reg[0] = cpu->reg[0]&0; cpu->reg[0] =temp; printf("read a char '%c'\n",temp); break; case 37: cpu->running = 0; break; } printf("\n"); }
void instr_STI (CPU *cpu) { int src = bitshift(cpu->instr_reg,11,9,0); int pcoffset = bitshift(cpu->instr_reg,8,0,1); cpu->memory[cpu->memory[pcoffset+cpu->pgm_counter]] = cpu->reg[src]; printf("STI R%d %x ; memory[memory[%x+%x]]<-reg[%x] = %x \n",src,pcoffset,cpu->pgm_counter,pcoffset,src,cpu->reg[src]); }
void instr_JMP (CPU *cpu) { int base = bitshift(cpu->instr_reg,8,6,0); cpu->pgm_counter = cpu->reg[base]; printf("JMP New pgm_counter = reg[%d] = %x\n",base,cpu->reg[base]); }
static int fillbmpheader(FILE *file,struct bmpheader *head) { int i; memset(head,'\0',sizeof(*head)); if ( getc(file)!='B' || getc(file)!='M' ) return 0; /* Bad format */ head->size = getl(file); head->mbz1 = getshort(file); head->mbz2 = getshort(file); head->offset = getl(file); head->headersize = getl(file); if ( head->headersize==12 ) { /* Windows 2.0 format, also OS/2 */ head->width = getshort(file); head->height = getshort(file); head->planes = getshort(file); head->bitsperpixel = getshort(file); head->colorsused = 0; head->compression = 0; } else { head->width = getl(file); head->height = getl(file); head->planes = getshort(file); head->bitsperpixel = getshort(file); head->compression = getl(file); head->imagesize = getl(file); head->ignore1 = getl(file); head->ignore2 = getl(file); head->colorsused = getl(file); head->colorsimportant = getl(file); } if ( head->height<0 ) head->height = -head->height; else head->invert = true; if ( head->bitsperpixel!=1 && head->bitsperpixel!=4 && head->bitsperpixel!=8 && head->bitsperpixel!=16 && head->bitsperpixel!=24 && head->bitsperpixel!=32 ) return( 0 ); if ( head->compression==3 && ( head->bitsperpixel==16 || head->bitsperpixel==32 )) /* Good */; else if ( head->compression==0 && ( head->bitsperpixel<=8 || head->bitsperpixel==24 || head->bitsperpixel==32 )) /* Good */; else if ( head->compression==1 && head->bitsperpixel==8 ) /* Good */; else if ( head->compression==2 && head->bitsperpixel==4 ) /* Good */; else return( 0 ); if ( head->colorsused==0 ) head->colorsused = 1<<head->bitsperpixel; if ( head->bitsperpixel>=16 ) head->colorsused = 0; if ( head->colorsused>(1<<head->bitsperpixel) ) return( 0 ); for ( i=0; i<head->colorsused; ++i ) { int b = getc(file), g = getc(file), r=getc(file); head->clut[i] = COLOR_CREATE(r,g,b); if ( head->headersize!=12 ) getc(file); } if ( head->compression==3 || head->headersize==108 ) { head->red_mask = getl(file); head->green_mask = getl(file); head->blue_mask = getl(file); head->red_shift = bitshift(head->red_mask); head->green_shift = bitshift(head->green_mask); head->blue_shift = bitshift(head->blue_mask); } if ( head->headersize==108 ) { getl(file); /* alpha_mask */ getl(file); /* color space type */ getl(file); /* redx */ getl(file); /* redy */ getl(file); /* redz */ getl(file); /* greenx */ getl(file); /* greeny */ getl(file); /* greenz */ getl(file); /* bluex */ getl(file); /* bluey */ getl(file); /* bluez */ getl(file); /* gammared */ getl(file); /* gammagreen */ getl(file); /* gammablue */ } return( 1 ); }
static int fillbmpheader(FILE *fp,struct bmpheader *head) { /* Get BMPheader info. Return 0 if read the header okay, -1 if read error */ int i; long temp; if ( fgetc(fp)!='B' || getc(fp)!='M' || /* Bad format */ \ getlong(fp,&head->size) || \ (head->mbz1=getshort(fp))<0 || \ (head->mbz2=getshort(fp))<0 || \ getlong(fp,&head->offset) || \ getlong(fp,&head->headersize) ) return( -1 ); if ( head->headersize==12 ) { /* Windows 2.0 format, also OS/2 */ if ( (head->width=getshort(fp))<0 || \ (head->height=getshort(fp))<0 || \ (head->planes=getshort(fp))<0 || \ (head->bitsperpixel=getshort(fp))<0 ) return( -1 ); //head->colorsused=0; //head->compression=0; } else { if ( getlong(fp,&head->width) || \ getlong(fp,&head->height) || \ (head->planes=getshort(fp))<0 || \ (head->bitsperpixel=getshort(fp))<0 || \ getlong(fp,&head->compression) || \ getlong(fp,&head->imagesize) || \ getlong(fp,&head->ignore1) || \ getlong(fp,&head->ignore2) || \ getlong(fp,&head->colorsused) || \ getlong(fp,&head->colorsimportant) ) return( -1 ); } if ( head->height<0 ) head->height = -head->height; else head->invert = true; if ( head->bitsperpixel!=1 && head->bitsperpixel!=4 && head->bitsperpixel!=8 && head->bitsperpixel!=16 && head->bitsperpixel!=24 && head->bitsperpixel!=32 ) return( -1 ); if ( head->compression==3 && ( head->bitsperpixel==16 || head->bitsperpixel==32 ) ) /* Good */; else if ( head->compression==0 && ( head->bitsperpixel<=8 || head->bitsperpixel==24 || head->bitsperpixel==32 ) ) /* Good */; else if ( head->compression==1 && head->bitsperpixel==8 ) /* Good */; else if ( head->compression==2 && head->bitsperpixel==4 ) /* Good */; else return( -1 ); if ( head->colorsused==0 ) head->colorsused = 1<<head->bitsperpixel; if ( head->bitsperpixel>=16 ) head->colorsused = 0; if ( head->colorsused>(1<<head->bitsperpixel) ) return( -1 ); for ( i=0; i<head->colorsused; ++i ) { int b,g,r; if ( (b=fgetc(fp))<0 || (g=fgetc(fp))<0 || (r=fgetc(fp))<0 ) return( -1 ); head->clut[i]=COLOR_CREATE(r,g,b); if ( head->headersize!=12 && fgetc(fp)<0 ) return( -1 ); } if ( head->compression==3 || head->headersize==108 ) { if ( getlong(fp,&head->red_mask) || \ getlong(fp,&head->green_mask) || \ getlong(fp,&head->blue_mask) ) return( -1 ); head->red_shift = bitshift(head->red_mask); head->green_shift = bitshift(head->green_mask); head->blue_shift = bitshift(head->blue_mask); } if ( head->headersize==108 && ( getlong(fp,&temp) || /* alpha_mask */ \ getlong(fp,&temp) || /* color space type */ \ getlong(fp,&temp) || /* redx */ \ getlong(fp,&temp) || /* redy */ \ getlong(fp,&temp) || /* redz */ \ getlong(fp,&temp) || /* greenx */ \ getlong(fp,&temp) || /* greeny */ \ getlong(fp,&temp) || /* greenz */ \ getlong(fp,&temp) || /* bluex */ \ getlong(fp,&temp) || /* bluey */ \ getlong(fp,&temp) || /* bluez */ \ getlong(fp,&temp) || /* gammared */ \ getlong(fp,&temp) || /* gammagreen */ \ getlong(fp,&temp) ) /* gammablue */ ) return( -1 ); return( 0 ); }