/*ds18b20_hex2temperature -- Caculate temperature according to hex_value*/ float ds18b20_hex2temperature(unsigned short hex_value) { int bit_index = 0; float temperature = 0.0f; if (IS_NEGATIVE(hex_value)){ hex_value--; while (bit_index <= DS18B20_TEMPERATURE_DATA_MAX_BIT){ if ((hex_value & (1 << bit_index)) == 0){ temperature += BIT2VALUE(bit_index); } bit_index++; } temperature = -temperature; }else{ while (bit_index <= DS18B20_TEMPERATURE_DATA_MAX_BIT){ if (hex_value & (1 << bit_index)){ temperature += BIT2VALUE(bit_index); } bit_index++; } } return temperature; }
/** * @brief * open with different users FS_MAX_OPEN_FILES open file entries (for less than FS_MAX_VNODES files), * than another file and making sure the last open fails with * the matching error * @return 1 if successful, 0 otherwise */ error_t openTest9(){ user_id user1 = 1, user2 = 2; uint32_t i, flags1 = NANDFS_O_RDONLY, flags2 = NANDFS_O_RDONLY; int32_t fd1, fd2; /* set user1 in process*/ SET_CURRENT_USER(user1); fd1 = open(VALID_MOCK_FILE_NAME_1, flags1, 0); // PRINT_MSG_AND_NUM("\nfd1=", fd1); /* verify open for reading */ VERIFY(!COMPARE(fd1,FD_EMPTY)); VERIFY(verifyOpenFileEntry(fd1,flags1,0,user1,0)); VERIFY(verifyVnode(OPEN_FILE_GET_VNODE(fd1), VALID_MOCK_INO_NUM_1, 1)); /* set user2 in process*/ SET_CURRENT_USER(user2); for(i=1;i<FS_MAX_OPEN_FILES;i++){ fd2 = open(VALID_MOCK_FILE_NAME_2, flags2, 0); // PRINT_MSG_AND_NUM("\nfd2=", fd2); /* verify open for reading */ VERIFY(!IS_NEGATIVE(fd2)); VERIFY(verifyOpenFileEntry(fd2,flags2,0,user2,1)); } /* verify all other file entries are empty*/ for(i=0;i< FS_MAX_OPEN_FILES;i++){ VERIFY(!verifyOpenFileEntryEmpty(i)); } /* verify all other vnodes are empty */ for(i=2;i< FS_MAX_VNODES;i++){ VERIFY(verifyVnodeEmpty(i)); } /* now try opening again and verify failure */ fd2 = open(VALID_MOCK_FILE_NAME_2, flags2, 0); // PRINT_MSG_AND_NUM("\nfd2=", fd2); VERIFY(IS_NEGATIVE(fd2)); return 1; }
/** * @brief * open a file that exists twice for reading * should succeed * @return 1 if successful, 0 otherwise */ error_t openTest5(){ user_id user1 = 1, user2 = 2; uint32_t i, flags = NANDFS_O_RDONLY; int32_t fd1, fd2; /* set user1 in process*/ SET_CURRENT_USER(user1); fd1 = open(VALID_MOCK_FILE_NAME_1, flags, 0); /* verify open */ VERIFY(!IS_NEGATIVE(fd1)); VERIFY(verifyOpenFileEntry(fd1,flags,0,user1,0)); VERIFY(verifyVnode(OPEN_FILE_GET_VNODE(fd1), VALID_MOCK_INO_NUM_1, 1)); /* set user2 in process*/ SET_CURRENT_USER(user2); fd2 = open(VALID_MOCK_FILE_NAME_1, flags, 0); /* verify open*/ VERIFY(!IS_NEGATIVE(fd2)); VERIFY(verifyOpenFileEntry(fd2,flags,0,user2,0)); VERIFY(verifyVnode(OPEN_FILE_GET_VNODE(fd2), VALID_MOCK_INO_NUM_1, 2)); /* verify all other file entries are empty*/ for(i=0;i< FS_MAX_OPEN_FILES;i++){ if(i==fd1 || i == fd2) continue; VERIFY(verifyOpenFileEntryEmpty(i)); } /* verify all other vnodes are empty */ for(i=0;i< FS_MAX_VNODES;i++){ if(i==OPEN_FILE_GET_VNODE(fd1) || i==OPEN_FILE_GET_VNODE(fd2)) continue; VERIFY(verifyVnodeEmpty(i)); } return 1; }
/** * @brief * try opening a pathname that leads to a directory with write permission. * should fail * @return 1 if successful, 0 otherwise */ error_t openTest23(){ int32_t res; /* try opening root directory for reading and verify success*/ res = open("/", NANDFS_O_RDONLY, 0); VERIFY(!res); /* try opening root directory for writing and verify failure*/ res = open("/", NANDFS_O_WRONLY, 0); VERIFY(IS_NEGATIVE(res)); return 1; }
bool OBResidue::GetAminoAcidProperty(int property) const { switch(property) { case OBAminoAcidProperty::ACIDIC: return IS_ACIDIC(_aakey) != 0; case OBAminoAcidProperty::ACYCLIC: return IS_ACYCLIC(_aakey) != 0; case OBAminoAcidProperty::ALIPHATIC: return IS_ALIPHATIC(_aakey) != 0; case OBAminoAcidProperty::AROMATIC: return IS_AROMATIC(_aakey) != 0; case OBAminoAcidProperty::BASIC: return IS_BASIC(_aakey) != 0; case OBAminoAcidProperty::BURIED: return IS_BURIED(_aakey) != 0; case OBAminoAcidProperty::CHARGED: return IS_CHARGED(_aakey) != 0; case OBAminoAcidProperty::CYCLIC: return IS_CYCLIC(_aakey) != 0; case OBAminoAcidProperty::HYDROPHOBIC: return IS_HYDROPHOBIC(_aakey) != 0; case OBAminoAcidProperty::LARGE: return IS_LARGE(_aakey) != 0; case OBAminoAcidProperty::MEDIUM: return IS_MEDIUM(_aakey) != 0; case OBAminoAcidProperty::NEGATIVE: return IS_NEGATIVE(_aakey) != 0; case OBAminoAcidProperty::NEUTRAL: return IS_NEUTRAL(_aakey) != 0; case OBAminoAcidProperty::POLAR: return IS_POLAR(_aakey) != 0; case OBAminoAcidProperty::POSITIVE: return IS_POSITIVE(_aakey) != 0; case OBAminoAcidProperty::SMALL: return IS_SMALL(_aakey) != 0; case OBAminoAcidProperty::SURFACE: return IS_SURFACE(_aakey) != 0; default: return false; } }
/** * @brief * open a file that doesn't exists for writing * should fail * @return 1 if successful, 0 otherwise */ error_t openTest4(){ user_id user = 1; uint32_t i, flags = NANDFS_O_WRONLY; int32_t fd; /* set user in process*/ SET_CURRENT_USER(user); fd = open(INVALID_MOCK_FILE_NAME_1, flags, 0); VERIFY(IS_NEGATIVE(fd)); /* verify all file entries are empty*/ for(i=0;i< FS_MAX_OPEN_FILES;i++){ VERIFY(verifyOpenFileEntryEmpty(i)); } /* verify all other vnodes are empty */ for(i=0;i< FS_MAX_VNODES;i++){ VERIFY(verifyVnodeEmpty(i)); } return 1; }
static inline INT32 SX(INT32 x) { return IS_NEGATIVE(x) ? x | 0xff000000 : x & 0x00ffffff; }
/* Clip a triangle against the viewport and user clip planes. */ static void do_clip_tri( struct draw_stage *stage, struct prim_header *header, unsigned clipmask ) { struct clip_stage *clipper = clip_stage( stage ); struct vertex_header *a[MAX_CLIPPED_VERTICES]; struct vertex_header *b[MAX_CLIPPED_VERTICES]; struct vertex_header **inlist = a; struct vertex_header **outlist = b; unsigned tmpnr = 0; unsigned n = 3; unsigned i; boolean aEdges[MAX_CLIPPED_VERTICES]; boolean bEdges[MAX_CLIPPED_VERTICES]; boolean *inEdges = aEdges; boolean *outEdges = bEdges; inlist[0] = header->v[0]; inlist[1] = header->v[1]; inlist[2] = header->v[2]; /* * Note: at this point we can't just use the per-vertex edge flags. * We have to observe the edge flag bits set in header->flags which * were set during primitive decomposition. Put those flags into * an edge flags array which parallels the vertex array. * Later, in the 'unfilled' pipeline stage we'll draw the edge if both * the header.flags bit is set AND the per-vertex edgeflag field is set. */ inEdges[0] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_0); inEdges[1] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_1); inEdges[2] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_2); while (clipmask && n >= 3) { const unsigned plane_idx = ffs(clipmask)-1; const boolean is_user_clip_plane = plane_idx >= 6; const float *plane = clipper->plane[plane_idx]; struct vertex_header *vert_prev = inlist[0]; boolean *edge_prev = &inEdges[0]; float dp_prev = dot4( vert_prev->clip, plane ); unsigned outcount = 0; clipmask &= ~(1<<plane_idx); assert(n < MAX_CLIPPED_VERTICES); if (n >= MAX_CLIPPED_VERTICES) return; inlist[n] = inlist[0]; /* prevent rotation of vertices */ inEdges[n] = inEdges[0]; for (i = 1; i <= n; i++) { struct vertex_header *vert = inlist[i]; boolean *edge = &inEdges[i]; float dp = dot4( vert->clip, plane ); if (!IS_NEGATIVE(dp_prev)) { assert(outcount < MAX_CLIPPED_VERTICES); if (outcount >= MAX_CLIPPED_VERTICES) return; outEdges[outcount] = *edge_prev; outlist[outcount++] = vert_prev; } if (DIFFERENT_SIGNS(dp, dp_prev)) { struct vertex_header *new_vert; boolean *new_edge; assert(tmpnr < MAX_CLIPPED_VERTICES + 1); if (tmpnr >= MAX_CLIPPED_VERTICES + 1) return; new_vert = clipper->stage.tmp[tmpnr++]; assert(outcount < MAX_CLIPPED_VERTICES); if (outcount >= MAX_CLIPPED_VERTICES) return; new_edge = &outEdges[outcount]; outlist[outcount++] = new_vert; if (IS_NEGATIVE(dp)) { /* Going out of bounds. Avoid division by zero as we * know dp != dp_prev from DIFFERENT_SIGNS, above. */ float t = dp / (dp - dp_prev); interp( clipper, new_vert, t, vert, vert_prev ); /* Whether or not to set edge flag for the new vert depends * on whether it's a user-defined clipping plane. We're * copying NVIDIA's behaviour here. */ if (is_user_clip_plane) { /* we want to see an edge along the clip plane */ *new_edge = TRUE; new_vert->edgeflag = TRUE; } else { /* we don't want to see an edge along the frustum clip plane */ *new_edge = *edge_prev; new_vert->edgeflag = FALSE; } } else { /* Coming back in. */ float t = dp_prev / (dp_prev - dp); interp( clipper, new_vert, t, vert_prev, vert ); /* Copy starting vert's edgeflag: */ new_vert->edgeflag = vert_prev->edgeflag; *new_edge = *edge_prev; } } vert_prev = vert; edge_prev = edge; dp_prev = dp; } /* swap in/out lists */ { struct vertex_header **tmp = inlist; inlist = outlist; outlist = tmp; n = outcount; } { boolean *tmp = inEdges; inEdges = outEdges; outEdges = tmp; } } /* If flat-shading, copy provoking vertex color to polygon vertex[0] */ if (n >= 3) { if (clipper->flat) { if (stage->draw->rasterizer->flatshade_first) { if (inlist[0] != header->v[0]) { assert(tmpnr < MAX_CLIPPED_VERTICES + 1); if (tmpnr >= MAX_CLIPPED_VERTICES + 1) return; inlist[0] = dup_vert(stage, inlist[0], tmpnr++); copy_colors(stage, inlist[0], header->v[0]); } } else { if (inlist[0] != header->v[2]) { assert(tmpnr < MAX_CLIPPED_VERTICES + 1); if (tmpnr >= MAX_CLIPPED_VERTICES + 1) return; inlist[0] = dup_vert(stage, inlist[0], tmpnr++); copy_colors(stage, inlist[0], header->v[2]); } } } /* Emit the polygon as triangles to the setup stage: */ emit_poly( stage, inlist, inEdges, n, header ); } }
constexpr int32_t SX(int32_t x) { return IS_NEGATIVE(x) ? x | 0xff000000 : x & 0x00ffffff; }
/* Clip a triangle against the viewport and user clip planes. */ static void do_clip_tri( struct draw_stage *stage, struct prim_header *header, unsigned clipmask ) { struct clipper *clipper = clipper_stage( stage ); struct vertex_header *a[MAX_CLIPPED_VERTICES]; struct vertex_header *b[MAX_CLIPPED_VERTICES]; struct vertex_header **inlist = a; struct vertex_header **outlist = b; unsigned tmpnr = 0; unsigned n = 3; unsigned i; inlist[0] = header->v[0]; inlist[1] = header->v[1]; inlist[2] = header->v[2]; while (clipmask && n >= 3) { const unsigned plane_idx = ffs(clipmask)-1; const float *plane = clipper->plane[plane_idx]; struct vertex_header *vert_prev = inlist[0]; float dp_prev = dot4( vert_prev->clip, plane ); unsigned outcount = 0; clipmask &= ~(1<<plane_idx); inlist[n] = inlist[0]; /* prevent rotation of vertices */ for (i = 1; i <= n; i++) { struct vertex_header *vert = inlist[i]; float dp = dot4( vert->clip, plane ); if (!IS_NEGATIVE(dp_prev)) { outlist[outcount++] = vert_prev; } if (DIFFERENT_SIGNS(dp, dp_prev)) { struct vertex_header *new_vert = clipper->stage.tmp[tmpnr++]; outlist[outcount++] = new_vert; if (IS_NEGATIVE(dp)) { /* Going out of bounds. Avoid division by zero as we * know dp != dp_prev from DIFFERENT_SIGNS, above. */ float t = dp / (dp - dp_prev); interp( clipper, new_vert, t, vert, vert_prev ); /* Force edgeflag true in this case: */ new_vert->edgeflag = 1; } else { /* Coming back in. */ float t = dp_prev / (dp_prev - dp); interp( clipper, new_vert, t, vert_prev, vert ); /* Copy starting vert's edgeflag: */ new_vert->edgeflag = vert_prev->edgeflag; } } vert_prev = vert; dp_prev = dp; } { struct vertex_header **tmp = inlist; inlist = outlist; outlist = tmp; n = outcount; } } /* If flat-shading, copy color to new provoking vertex. */ if (clipper->flat && inlist[0] != header->v[2]) { if (1) { inlist[0] = dup_vert(stage, inlist[0], tmpnr++); } copy_colors(stage, inlist[0], header->v[2]); } /* Emit the polygon as triangles to the setup stage: */ if (n >= 3) emit_poly( stage, inlist, n, header ); }
/** * @brief * try opening a legal pathname with "." and ".." * @return 1 if successful, 0 otherwise */ error_t openTest26(){ bool_t cpWritten; INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(prev_log_addr); INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr_file); INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr_dir2); INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr_dir1); INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr_root); INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr); dirent_flash *dirent_ptr = CAST_TO_DIRENT(fs_buffer); inode_t *ino_ptr = CAST_TO_INODE(fs_buffer); uint8_t *f_full_name = "/directory1/../directory1/directory2/file1.dat"; uint32_t i; int32_t fd, flags = NANDFS_O_RDONLY; user_id user = 1; init_logical_address(prev_log_addr); init_logical_address(log_addr_file); init_logical_address(log_addr_dir2); init_logical_address(log_addr_dir1); init_logical_address(log_addr_root); init_logical_address(log_addr); /* set user in process*/ SET_CURRENT_USER(user); /* write file inode */ VERIFY(!writeNewInode(4, INO_NUM_EMPTY, FTYPE_FILE, log_addr_file)); /* write directory2 inode*/ VERIFY(!writeNewInode(3, 2, FTYPE_DIR, log_addr_dir2)); /* write directory1 inode*/ VERIFY(!writeNewInode(2, 1, FTYPE_DIR, log_addr_dir1)); /* write file1.dat direntry in directory2*/ VERIFY(!readFileBlock(fs_buffer, 3, INODE_FILE_DATA_SIZE, log_addr_dir2, TID_EMPTY)); /* iterate until we find an empty directory entry*/ while(!IS_DIRENT_EMPTY(dirent_ptr)) moveToNextDirentry(&dirent_ptr, DIRENT_GET_LEN(dirent_ptr)); setNewDirentry(dirent_ptr, 4, FTYPE_FILE, "file1.dat"); VERIFY(!allocAndWriteBlock(log_addr, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0)); /* write directory2 inode with new pointer to the above block*/ VERIFY(!fsReadBlockSimple(log_addr_dir2, fs_buffer)); INODE_SET_DIRECT(ino_ptr,0,log_addr); VERIFY(!allocAndWriteBlock(log_addr_dir2, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0)); /* write directory2 direntry in directory1*/ VERIFY(!readFileBlock(fs_buffer, 2, INODE_FILE_DATA_SIZE, log_addr_dir1,TID_EMPTY)); /* iterate until we find an empty directory entry*/ while(!IS_DIRENT_EMPTY(dirent_ptr)) moveToNextDirentry(&dirent_ptr, DIRENT_GET_LEN(dirent_ptr)); setNewDirentry(dirent_ptr, 3, FTYPE_DIR, "directory2"); VERIFY(!allocAndWriteBlock(log_addr, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0)); /* write directory1 inode with new pointer to the above block*/ VERIFY(!fsReadBlockSimple(log_addr_dir1, fs_buffer)); INODE_SET_DIRECT(ino_ptr,0,log_addr); VERIFY(!allocAndWriteBlock(log_addr_dir1, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0)); /* write directory1 direntry in root*/ VERIFY(!readFileBlock(fs_buffer, 1, INODE_FILE_DATA_SIZE, log_addr_root, TID_EMPTY)); /* iterate until we find an empty directory entry*/ while(!IS_DIRENT_EMPTY(dirent_ptr)) moveToNextDirentry(&dirent_ptr, DIRENT_GET_LEN(dirent_ptr)); setNewDirentry(dirent_ptr, 2, FTYPE_DIR, "directory1"); VERIFY(!allocAndWriteBlock(log_addr, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0)); /* write directory1 inode with new pointer to the above block*/ VERIFY(!fsReadBlockSimple(log_addr_root, fs_buffer)); INODE_SET_DIRECT(ino_ptr,0,log_addr); VERIFY(!allocAndWriteBlock(log_addr_root, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0)); /* write inode0 with pointers to the new root address*/ VERIFY(!fsReadBlockSimple(FS_GET_INO0_ADDR_PTR(), fs_buffer)); INODE_SET_DIRECT(ino_ptr,0,log_addr_root); INODE_SET_DIRECT(ino_ptr,1,log_addr_dir1); INODE_SET_DIRECT(ino_ptr,2,log_addr_dir2); INODE_SET_DIRECT(ino_ptr,3,log_addr_file); INODE_SET_NBYTES(ino_ptr, CAST_VAL_TO_UINT32(INODE_FILE_DATA_SIZE+4*FS_BLOCK_SIZE)); VERIFY(!allocAndWriteBlock(FS_GET_INO0_ADDR_PTR(), fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0)); /* and now try opening file1.dat*/ fd = open(f_full_name, flags, 0); VERIFY(!IS_NEGATIVE(fd)); VERIFY(COMPARE(VNODE_GET_INO_NUM(OPEN_FILE_GET_VNODE(fd)), 4)); VERIFY(IS_RDONLY(OPEN_FILE_GET_FLAGS(fd))); for(i=0; i< FS_MAX_OPEN_FILES;i++){ if(i==fd){ VERIFY(verifyOpenFileEntry(fd, flags,0,user, 0)); } else{ VERIFY(verifyOpenFileEntryEmpty(i)); } } for(i=0; i<FS_MAX_VNODES;i++){ if(i!=fd){ VERIFY(verifyVnodeEmpty(i)); } else{ VERIFY(verifyVnode(i, 4, 1)); } } // return 1; }