Esempio n. 1
0
void PluginRegistry::init()
{
    // for each directory
    for( StringsCIter i = impl_->directories.begin();
         i != impl_->directories.end(); ++i )
    {
        const std::string& dir = *i;
        LBLOG( LOG_PLUGIN ) << "Searching plugins in " << dir << std::endl;

#ifdef _WIN32
        const Strings& files = searchDirectory( dir, ".*Compressor.*\\.dll" );
        const char DIRSEP = '\\';
#elif defined (Darwin)
        const Strings& files = searchDirectory( dir,
                                                "lib.*Compressor.*\\.dylib" );
        const char DIRSEP = '/';
#else
        const Strings& files = searchDirectory( dir, "lib.*Compressor.*\\.so" );
        const char DIRSEP = '/';
#endif
        // for each file found in the directory
        for( StringsCIter j = files.begin(); j != files.end(); ++j )
        {
            // build path + name of library
            const std::string libraryName = dir.empty() ? *j : dir+DIRSEP+*j;
            addPlugin( libraryName );
        }
    }
}
void FileNameSearchProtocol::listDir(const KUrl& url)
{
    cleanup();

    m_checkContent = url.queryItem("checkContent");

    m_literal = url.queryItem("literal");

    m_checkType = url.queryItem("checkType");


    QString search = url.queryItem("search");
    if (!search.isEmpty() && m_literal == "yes") {
        search = QRegExp::escape(search);
    }

    if (!search.isEmpty()) {
        m_regExp = new QRegExp(search, Qt::CaseInsensitive);
    }

    const QString urlString = url.queryItem("url");
    searchDirectory(KUrl(urlString));

    cleanup();
    finished();
}
Esempio n. 3
0
	/**
		@brief	フォルダ内のファイルおよびサブディレクトリを検索
		@param	tszPath		検索するパス
	 */
	void	search( const _TCHAR* tszPath )
	{
		if( m_bSearchChild )
		{
			searchDirectory( tszPath );
		}
		searchFile( tszPath );
	}
    //FindFiles
    Int DirectoryArchiveHandler::FindFiles( const String& archiveLocation, StringVector* files, bool recurse )
    {
        // Find the files:
        Int count = searchDirectory( archiveLocation, files, recurse );

        // Go through the files and remove the directory from the name
        StringVector::iterator fileIter = files->begin();
        Int length = archiveLocation.length() + 1;
        for ( fileIter; fileIter != files->end(); fileIter++ )
        {
            fileIter->erase( 0, length );
        }
        return count;
    }
Esempio n. 5
0
void deleteFile(char* name, int dirID) {
  int entryOffset, j;
  char directoryBuffer[SECTOR_SIZE];
  char mapBuffer[SECTOR_SIZE];
  /* int sectorPointer = 0; */
  readSector(directoryBuffer, dirID);
  readSector(mapBuffer, MAP_SECTOR);

  entryOffset = searchDirectory(directoryBuffer, name);
  
  if (entryOffset < 0) {
    char errorMessage[];
    errorMessage[0] = 'F';
    errorMessage[1] = 'i';
    errorMessage[2] = 'l';
    errorMessage[3] = 'e';
    errorMessage[4] = ' ';
    errorMessage[5] = 'n';
    errorMessage[6] = 'o';
    errorMessage[7] = 't';
    errorMessage[8] = ' ';
    errorMessage[9] = 'f';
    errorMessage[10] = 'o';
    errorMessage[11] = 'u';
    errorMessage[12] = 'n';
    errorMessage[13] = 'd';
    errorMessage[14] = '\0';
    printString(errorMessage);
    return;
  }

  directoryBuffer[entryOffset] = 0;
  for (j = FILE_NAME_LENGTH; j < FILE_ENTRY_LENGTH; j++) {
    mapBuffer[directoryBuffer[entryOffset + j]] = 0;
    if (directoryBuffer[entryOffset + j] == 0) {
      break;
    }
  }

  writeSector(directoryBuffer, 2);
  writeSector(mapBuffer, 1);
}
Esempio n. 6
0
void readFile(char *filename, char *buffer, int dirID) {
  /* int i, j, k; */
  int entryOffset;
  char directoryBuffer[SECTOR_SIZE];
  int bufferPointer = 0;
  int sectorPointer = 0;
  readSector(&directoryBuffer, dirID);

  entryOffset = searchDirectory(directoryBuffer, filename);

  if (entryOffset < 0) {
    char errorMessage[15];
    errorMessage[0] = 'F';
    errorMessage[1] = 'i';
    errorMessage[2] = 'l';
    errorMessage[3] = 'e';
    errorMessage[4] = ' ';
    errorMessage[5] = 'n';
    errorMessage[6] = 'o';
    errorMessage[7] = 't';
    errorMessage[8] = ' ';
    errorMessage[9] = 'f';
    errorMessage[10] = 'o';
    errorMessage[11] = 'u';
    errorMessage[12] = 'n';
    errorMessage[13] = 'd';
    errorMessage[14] = '\0';
    printString(errorMessage);

    *buffer = '\0';
    return;
  }

  sectorPointer = entryOffset + 6;

  while (directoryBuffer[sectorPointer] != 0) {
    readSector(buffer + bufferPointer, directoryBuffer[sectorPointer]);
    bufferPointer += SECTOR_SIZE;
    sectorPointer++;
  }
}
Esempio n. 7
0
int bbb_initPWM(byte pin) 
{
  int returnval=0;  // Remains zero unless errors are detected
  char pwmFName[50], pwmDirName[50];

  printf("slots file path = %s\n", slotsFilePath);

  // Find directory/file for this PWM channel
  sprintf(pwmFName,"pwm_test_%s",pwmName[pin]);
  if (searchDirectory(ocpDir, pwmFName, pwmDirName)) {  // Not found
    sprintf(pwmDirName,"%s.%d", pwmFName, 15);  // 15 is a default
    returnval -= 1;
  }
 
  // pwmDir[pin]:   Full PWM directory path for channel pin
  sprintf(pwmDir[pin],"%s%s", ocpDir, pwmDirName);
  printf("dir = %s%s\n",ocpDir,pwmDirName);

  if (bbb_setPolarityPWM(pin, pwm_straight))
    returnval -= 2;

  return returnval;
}
    //searchDirectory
    Int DirectoryArchiveHandler::searchDirectory( const String& path, StringVector* files, bool recurse )
    {
        _finddata_t findData;
        String mask = path + "/*.*";
        long handle = _findfirst( mask.c_str(), &findData );
        long result = 0;
        while ( handle != -1 && result != -1 )
        {
            String dir = findData.name;
            if ( dir != "." && dir != ".." )
            {
                if ( ( findData.attrib & _A_SUBDIR ) && recurse )
                {
                    searchDirectory( path + "/" + findData.name, files, recurse );
                }
                else
                    files->push_back( path + "/" + findData.name );
            }

            result = _findnext( handle, &findData );
        }

        return files->size();
    }
Esempio n. 9
0
void writeFile(char* name, char* buffer, int numberOfSectors, int dirID) {
  int i, j, entryOffset;
  char directoryBuffer[SECTOR_SIZE];
  char mapBuffer[SECTOR_SIZE];
  char sectorPointers[26];
  char errorMessage[19];
  /* char debug[3]; */
  
  readSector(directoryBuffer, ROOT_SECTOR);

  /* try to see if this file already exists */
  entryOffset = searchDirectory(directoryBuffer, name);
  if (entryOffset < 0) { 
    /* find an empty entry to store file info */
    i = findEmptyEntry(directoryBuffer);
    if (i < 0) {
      errorMessage[0] = 'F';
      errorMessage[1] = 'i';
      errorMessage[2] = 'l';
      errorMessage[3] = 'e';
      errorMessage[4] = ' ';
      errorMessage[5] = 'f';
      errorMessage[6] = 'u';
      errorMessage[7] = 'l';
      errorMessage[8] = 'l';
      errorMessage[9] = '\0';
      printString(errorMessage);
      return;
    }
    entryOffset = i ;
  }

  readSector(mapBuffer, MAP_SECTOR);
  /* find enough sectors for storage */
  i = 0;
  for (j = 0 ; j < numberOfSectors; j++) {
    while(mapBuffer[i]!=0x00) {
      i++;
      if (i > SECTOR_TOTAL_NUM){
        errorMessage[0] = 'D';
        errorMessage[1] = 'i';
        errorMessage[2] = 's';
        errorMessage[3] = 'k';
        errorMessage[4] = ' ';
        errorMessage[5] = 'f';
        errorMessage[6] = 'u';
        errorMessage[7] = 'l';
        errorMessage[8] = 'l';
        errorMessage[9] = '\0';
        printString(errorMessage);
        return;
      }
    }
    sectorPointers[j] = i;
    i++;
  }

  /* write file name, and append '\0' at the end if there is space */
  for (j = 0; j < FILE_NAME_LENGTH; j++) {
    directoryBuffer[entryOffset+j] = name[j];
    if (name[j] == '\0') {
      break;
    }
  }

  /* write data into sectors */
  for (j = 0; j < numberOfSectors; j++) {
    mapBuffer[sectorPointers[j]] = 0xFF;
    directoryBuffer[entryOffset+FILE_NAME_LENGTH+j] = sectorPointers[j];
    writeSector(buffer, sectorPointers[j]);
    buffer += SECTOR_SIZE;
  }
  directoryBuffer[entryOffset+FILE_NAME_LENGTH+numberOfSectors] = 0; /* end the sector pointer sequence */
  
  /* write back root directory and map */
  writeSector(directoryBuffer, ROOT_SECTOR);
  writeSector(mapBuffer, MAP_SECTOR);
}