file.cpp

WinCE5.0部分核心源码

  
  return true;
}

/*****************************************************************************
 *****************************************************************************/
void File::print_header(){
  static char *suppress = (suppress = getenv("ri_suppress_info")) ? strstr(suppress, "move") : NULL;
  if(suppress) return;
  
  LAST_PASS_PRINT printf("\nFILES Section\n");
  LAST_PASS_PRINT printf("    Raw   Compr Location Filler File\n");
}

/*****************************************************************************
 *****************************************************************************/
bool File::move_locataion(AddressList &address_list){
  bool filler = false;
  m_load_offset = Memory::allocate_range(address_list, m_data.size(), &filler);

  if(m_load_offset == -1){
    fprintf(stderr, "Error: Ran out of space in ROM for %s\nsize %d\n", m_name.c_str(), m_data.size());
    return false;
  }

  static char *suppress = (suppress = getenv("ri_suppress_info")) ? strstr(suppress, "move") : NULL;
  if(!suppress){
    static char *delim = getenv("ri_comma_delimit") ? "," : " ";

    LAST_PASS_PRINT
      printf("%7d%s%7d%s%08x%s%s%s%s\n",
           m_file_size, delim,
           m_data.size(), delim,
           m_load_offset, delim,
           filler ? "FILLER" : "", delim,
           m_name.c_str());
  }

  return true;
}

/*****************************************************************************
 *****************************************************************************/
bool File::move_name(AddressList &address_list){
  DWORD size = m_name.size() + 1;
  if(!m_build_path.empty())
    size += m_build_path.size() + 1;

  bool filler = false;
  m_name_offset = Memory::allocate_range(address_list, size, &filler);

  if(m_name_offset == -1){
    fprintf(stderr, "Error: Ran out of space in ROM for %s\nsize %d\n", m_name.c_str(), size);    
    return false;
  }

  static char *suppress = (suppress = getenv("ri_suppress_info")) ? strstr(suppress, "move") : NULL;
  if(!suppress){
    static char *delim = getenv("ri_comma_delimit") ? "," : " ";

    LAST_PASS_PRINT
      printf("%-22s%s%-8s%s%08x%s %7u%s%s%s              %s\n",
           m_name.c_str(), delim,
           "FileName", delim,
           m_name_offset, delim,
           size, delim,
           delim, delim,
           filler ? "FILLER" : "");
  }

  return true;
}

/*****************************************************************************
 *****************************************************************************/
bool File::write(ostream &out_file){
  // write data
  write_bin(out_file, m_load_offset, m_data.ptr(), m_data.size());

  // write out file name
  write_bin(out_file, m_name_offset, m_name.c_str(), m_name.size() + 1);

  if(!m_build_path.empty())
    write_bin(out_file, m_name_offset + m_name.size() + 1, m_build_path.c_str(), m_build_path.size() + 1);

  return true;
}

/*****************************************************************************
 *****************************************************************************/
FILESentry File::get_TOC(){
  FILESentry toc = {0};

  toc.dwFileAttributes = m_file_attributes;
  toc.ftTime           = m_file_time;
  toc.lpszFileName     = (char *)m_name_offset;
  toc.nCompFileSize    = m_data.size();
  toc.nRealFileSize    = m_file_size;
  toc.ulLoadOffset     = m_load_offset;

  return toc;
}

/*****************************************************************************
  get_file_info()

  in:
    none

  out:
    boolean value indicating success

  desc:
    reads this file status from disk, including the last write time, the file 
    size, and 8.3 filename.
******************************************************************************/
bool File::get_file_info(){
  HANDLE  hf;
  WIN32_FIND_DATA fd;

  hf = FindFirstFile(m_release_path.c_str(), &fd);
  if(hf == INVALID_HANDLE_VALUE){
    cerr << "Error: Could not find file '" << m_release_path << "' on disk\n";
    return false;
  }

  m_file_time  = fd.ftLastWriteTime;
  m_file_size  = fd.nFileSizeLow;

  FindClose(hf);

  return true;
}

DWORD File::s_rom_offset = 0;
DWORD File::s_page_size = 0x1000;
DWORD File::s_physlast = 0;

/*****************************************************************************
  chksum()

  in:
    ptr  - pointer to data to checksum
    size - length of data
    
  out:
    DWORD - check sum

  desc:
    does a simple sum check sum on a data element
******************************************************************************/
DWORD File::chksum(const void *ptr, DWORD size){
  DWORD chksum = 0;

  for(unsigned i = 0; i < size; i++)
    chksum += *((unsigned char *)ptr + i);

  return chksum;
}

/*****************************************************************************
  write_bin()

  in:
    out_file - an open ostream for output
    offset   - record offset in image
    data     - pointer to data
    size     - size of data
    
  out:
    boolean indicating success

  desc:
    writes a record to the bin file with image offset, length, and checksum
******************************************************************************/
bool File::write_bin(ostream &out_file, DWORD offset, const void *data, DWORD size, bool check_overlap){
  static AddressList overlap_list;
  
  if(!offset && !data && !size){
    overlap_list.clear();
    s_physlast = 0;
  }
  
  if(!size)
    return true;

  offset += s_rom_offset;

  // check for overlaping records

  DWORD aligned_size = align_dword(size);

  if(check_overlap){
    int i = 0;
    for(AddressList::iterator addr_itr = overlap_list.begin(); addr_itr != overlap_list.end(); addr_itr++, i++){
      if(addr_itr->intersects(offset, aligned_size)){
        printf("writing... offset = %08x, dataptr = %08x, size = %8x\n", offset, (DWORD)data, aligned_size);
        printf("hit record %d offset = %08x, size = %8x\n", i, addr_itr->address(), addr_itr->length());
        fflush(stdout);

        assert(!"Error: Bin record overlap in record");
      }
    }

    overlap_list.push_back(Address(offset, aligned_size));
  }

  DWORD sum = chksum(data, size);

  if(last_pass){
    out_file.write((char *)&offset,       sizeof(offset));
    out_file.write((char *)&aligned_size, sizeof(aligned_size));
    out_file.write((char *)&sum,          sizeof(sum));
    
    out_file.write((char *)data, size);
  
    DWORD zero = 0;
    out_file.write((char *)&zero, aligned_size - size);
  }
  
  s_physlast = max(s_physlast, offset - s_rom_offset + aligned_size);

  return true;
}

/*****************************************************************************
  output streams for class File
******************************************************************************/
inline ostream &operator<<(ostream &out_file, const File &file){
  char  buffer[1024];
  
  static char *delim = getenv("ri_comma_delimit") ? "," : " ";
  
  sprintf(buffer, "%-15s%s%-40s%s%-12s%s%08x", 
          file.name().c_str(), delim,
          file.full_path().c_str(), delim,
          file.memory_iterator()->name().c_str(), delim,
          file.file_attributes());

  out_file << buffer;

  return out_file;
}

ostream &operator<<(ostream &out_file, const FileList &file_list){
  static char *suppress = (suppress = getenv("ri_suppress_info")) ? strstr(suppress, "file") : NULL;
  if(suppress) return out_file;
  
  out_file << "File Name       Path     Section\n"
              "--------------- -------- -------\n";

  for(FileList::const_iterator fitr = file_list.begin(); fitr != file_list.end(); fitr++)
    cout << *fitr << endl;
  
  return out_file;
}