/// data() is re-implemented from QStandardItemModel to return the widget window title and icon for the Qt::DecorationRole and Qt::DisplayRole/Qt::EditRole QVariant AMWindowPaneModel::data(const QModelIndex &index, int role) const { switch(role) { case Qt::DisplayRole: case Qt::EditRole: // alias items can have separate descriptions, but for normal items, the DisplayRole and EditRole should be the window title if(!isAlias(index) && internalPane(index)) return internalPane(index)->windowTitle(); else return AMDragDropItemModel::data(index, role); break; case Qt::DecorationRole: if(!isAlias(index) && internalPane(index)) return internalPane(index)->windowIcon(); else return AMDragDropItemModel::data(index, role); break; // read-only property, defined as being (a) NOT an alias, AND (b) having no valid window pane widget set case AMWindowPaneModel::IsHeadingRole: return (index.isValid() && !isAlias(index) && internalPane(index) == 0); break; // Dock state: alias items should return the dock state of their target. Other items simply return their dock state, as stored in the AMWindowPaneModel::DockStateRole. case AMWindowPaneModel::DockStateRole: if(isAlias(index)) { QStandardItem* target = aliasTarget(index); if(target) return data(target->index(), role); else return true; } else return AMDragDropItemModel::data(index, role); break; case AMWindowPaneModel::UndockResizeRole: return AMDragDropItemModel::data(index, role); break; case AMWindowPaneModel::IsVisibleRole: if (AMDragDropItemModel::data(index, role).isValid()) return AMDragDropItemModel::data(index, role); else return true; break; default: return AMDragDropItemModel::data(index, role); } }
U_CFUNC const char * ucnv_io_getConverterName(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) { const char *aliasTmp = alias; int32_t i = 0; for (i = 0; i < 2; i++) { if (i == 1) { /* * After the first unsuccess converter lookup, check to see if * the name begins with 'x-'. If it does, strip it off and try * again. This behaviour is similar to how ICU4J does it. */ if (aliasTmp[0] == 'x' || aliasTmp[1] == '-') { aliasTmp = aliasTmp+2; } else { break; } } if(haveAliasData(pErrorCode) && isAlias(aliasTmp, pErrorCode)) { uint32_t convNum = findConverter(aliasTmp, containsOption, pErrorCode); if (convNum < gMainTable.converterListSize) { return GET_STRING(gMainTable.converterList[convNum]); } /* else converter not found */ } else { break; } } return NULL; }
U_CAPI UEnumeration * U_EXPORT2 ucnv_openStandardNames(const char *convName, const char *standard, UErrorCode *pErrorCode) { UEnumeration *myEnum = NULL; if (haveAliasData(pErrorCode) && isAlias(convName, pErrorCode)) { uint32_t listOffset = findTaggedAliasListsOffset(convName, standard, pErrorCode); /* When listOffset == 0, we want to acknowledge that the converter name and standard are okay, but there is nothing to enumerate. */ if (listOffset < gMainTable.taggedAliasListsSize) { UAliasContext *myContext; myEnum = reinterpret_cast<UEnumeration *>(uprv_malloc(sizeof(UEnumeration))); if (myEnum == NULL) { *pErrorCode = U_MEMORY_ALLOCATION_ERROR; return NULL; } uprv_memcpy(myEnum, &gEnumAliases, sizeof(UEnumeration)); myContext = reinterpret_cast<UAliasContext *>(uprv_malloc(sizeof(UAliasContext))); if (myContext == NULL) { *pErrorCode = U_MEMORY_ALLOCATION_ERROR; uprv_free(myEnum); return NULL; } myContext->listOffset = listOffset; myContext->listIdx = 0; myEnum->context = myContext; } /* else converter or tag not found */ } return myEnum; }
static uint16_t ucnv_io_getAliases(const char* alias, uint16_t start, const char** aliases, UErrorCode* pErrorCode) { if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { uint32_t currAlias; uint32_t convNum = findConverter(alias, NULL, pErrorCode); if (convNum < gMainTable.converterListSize) { /* tagListNum - 1 is the ALL tag */ int32_t listOffset = gMainTable.taggedAliasArray[ (gMainTable.tagListSize - 1) * gMainTable.converterListSize + convNum]; if (listOffset) { uint32_t listCount = gMainTable.taggedAliasLists[listOffset]; /* +1 to skip listCount */ const uint16_t* currList = gMainTable.taggedAliasLists + listOffset + 1; for (currAlias = start; currAlias < listCount; currAlias++) { aliases[currAlias] = GET_STRING(currList[currAlias]); } } /* else this shouldn't happen. internal program error */ } /* else converter not found */ } return 0; }
static const char* ucnv_io_getAlias(const char* alias, uint16_t n, UErrorCode* pErrorCode) { if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { uint32_t convNum = findConverter(alias, NULL, pErrorCode); if (convNum < gMainTable.converterListSize) { /* tagListNum - 1 is the ALL tag */ int32_t listOffset = gMainTable.taggedAliasArray[ (gMainTable.tagListSize - 1) * gMainTable.converterListSize + convNum]; if (listOffset) { uint32_t listCount = gMainTable.taggedAliasLists[listOffset]; /* +1 to skip listCount */ const uint16_t* currList = gMainTable.taggedAliasLists + listOffset + 1; if (n < listCount) { return GET_STRING(currList[n]); } *pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR; } /* else this shouldn't happen. internal program error */ } /* else converter not found */ } return NULL; }
/// Convenience function to retrieve an alias item's target item. Returns 0 if the item at this \c index is not an alias. QStandardItem* AMWindowPaneModel::aliasTarget(const QModelIndex& index) const { if(!index.isValid() || !isAlias(index)) return 0; QVariant itemPointer = data(index, AMWindowPaneModel::AliasTargetRole); if(itemPointer.isValid()) return itemPointer.value<QStandardItem*>(); else return 0; }
U_CFUNC const char * ucnv_io_getConverterName(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) { if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { uint32_t convNum = findConverter(alias, containsOption, pErrorCode); if (convNum < gMainTable.converterListSize) { return GET_STRING(gMainTable.converterList[convNum]); } /* else converter not found */ } return NULL; }
U_CAPI const char * U_EXPORT2 ucnv_getCanonicalName(const char *alias, const char *standard, UErrorCode *pErrorCode) { if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { uint32_t convNum = findTaggedConverterNum(alias, standard, pErrorCode); if (convNum < gMainTable.converterListSize) { return GET_STRING(gMainTable.converterList[convNum]); } } return NULL; }
void AMWindowPaneModel::onRowsInserted(const QModelIndex &parent, int first, int last) { // for each item inserted: install event filter on the widget, and add to the widget lookup hash. for(int row=first; row<=last; row++) { QModelIndex i = index(row, 0, parent); if(!isAlias(i)) { QWidget* widget = internalPane(i); if(widget) { widget2item_.insert(widget, itemFromIndex(i)); widget->installEventFilter(this); } } } }
void AMWindowPaneModel::onRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last) { for(int row=first; row<=last; row++) { QModelIndex i = index(row, 0, parent); if(!isAlias(i)) { QWidget* w = internalPane(i); if(w) { widget2item_.remove(w); w->removeEventFilter(this); } } } }
/// Convenience function to return a pointer to an item's QWidget window pane. For alias items, will return the window pane of the target. \warning Might be 0 if an invalid item has been added to the model, or if this index is a heading item. QWidget* AMWindowPaneModel::pane(const QModelIndex& index) const { if(!index.isValid()) return 0; if(isAlias(index)) { QStandardItem* target = aliasTarget(index); if(target) return internalPane(target->index()); else return 0; } else { return internalPane(index); } }
static uint16_t ucnv_io_countAliases(const char *alias, UErrorCode *pErrorCode) { if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { uint32_t convNum = findConverter(alias, NULL, pErrorCode); if (convNum < gMainTable.converterListSize) { /* tagListNum - 1 is the ALL tag */ int32_t listOffset = gMainTable.taggedAliasArray[(gMainTable.tagListSize - 1)*gMainTable.converterListSize + convNum]; if (listOffset) { return gMainTable.taggedAliasLists[listOffset]; } /* else this shouldn't happen. internal program error */ } /* else converter not found */ } return 0; }
U_CAPI const char * U_EXPORT2 ucnv_getStandardName(const char *alias, const char *standard, UErrorCode *pErrorCode) { if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) { uint32_t listOffset = findTaggedAliasListsOffset(alias, standard, pErrorCode); if (0 < listOffset && listOffset < gMainTable.taggedAliasListsSize) { const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1; /* Get the preferred name from this list */ if (currList[0]) { return GET_STRING(currList[0]); } /* else someone screwed up the alias table. */ /* *pErrorCode = U_INVALID_FORMAT_ERROR */ } } return NULL; }
const AST::Alias& Value::alias() const { assert(isAlias()); return *(impl_->union_.alias); }
/// setData() is re-implemented from QStandardItemModel to set the widget window title and icon for the Qt::DecorationRole and Qt::DisplayRole/Qt::EditRole bool AMWindowPaneModel::setData(const QModelIndex &index, const QVariant &value, int role) { if(!index.isValid()) return false; switch(role) { case Qt::DisplayRole: case Qt::EditRole: // alias items and heading items can have separate descriptions, but for normal items, the DisplayRole and EditRole should be the window title if(isAlias(index) || isHeading(index)) return AMDragDropItemModel::setData(index, value, role); if(internalPane(index)) { internalPane(index)->setWindowTitle(value.toString()); return true; } else return false; break; case Qt::DecorationRole: // alias items and heading items can have separate icons, but for normal items, the Decoration role should be the window icon if(isAlias(index) || isHeading(index)) return AMDragDropItemModel::setData(index, value, role); if(internalPane(index)) { internalPane(index)->setWindowIcon(value.value<QIcon>()); return true; } else return false; break; case AMWindowPaneModel::DockStateRole: { // docking an alias? dock the target instead. if(isAlias(index)) { QStandardItem* target = aliasTarget(index); if(target) return setData(target->index(), value, role); else return false; } bool nowDocked = value.toBool(); bool wasDocked = isDocked(index); // set dock state like normal, but emit special signal dockStateChanged() if it's changing. if(AMDragDropItemModel::setData(index, value, role)) { QWidget* w = internalPane(index); if(wasDocked && !nowDocked) emit dockStateChanged(w, false, index.data(AMWindowPaneModel::UndockResizeRole).toBool()); else if(!wasDocked && nowDocked) emit dockStateChanged(w, true, index.data(AMWindowPaneModel::UndockResizeRole).toBool()); return true; } else return false; break; } case AMWindowPaneModel::UndockResizeRole: return AMDragDropItemModel::setData(index, value, role); break; default: return AMDragDropItemModel::setData(index, value, role); } }
/// Convenience function to check if this item is a header item. This is defined as being true when (a) the item is NOT an alias, AND (b) that the AM::Widget role is 0/unset. bool AMWindowPaneModel::isHeading(const QModelIndex &index) const { return (index.isValid() && !isAlias(index) && internalPane(index) == 0); }
///------------------------------------------------------------------------------------------------- /// Scan a single file. Everything that applies to ms_scan also applies to this function. If /// you know the type of the file, set the type paramter to one of TYPE_AUDIO, TYPE_VIDEO, or /// TYPE_IMAGE. Set it to TYPE_UNKNOWN to have it determined automatically. /// /// @author Andy Grundman /// @date 03/15/2011 /// /// @param [in,out] s If non-null, the. /// @param full_path Full pathname of the full file. /// /// ### remarks . ///------------------------------------------------------------------------------------------------- void ms_scan_file(MediaScan *s, const char *full_path, enum media_type type) { MediaScanError *e = NULL; MediaScanResult *r = NULL; int ret; uint32_t hash; int mtime = 0; uint64_t size = 0; DBT key, data; char tmp_full_path[MAX_PATH_STR_LEN]; #ifdef WIN32 char *ext = strrchr(full_path, '.'); #endif if (s == NULL) { ms_errno = MSENO_NULLSCANOBJ; LOG_ERROR("MediaScan = NULL, aborting scan\n"); return; } if (s->on_result == NULL) { ms_errno = MSENO_NORESULTCALLBACK; LOG_ERROR("Result callback not set, aborting scan\n"); return; } #if (defined(__APPLE__) && defined(__MACH__)) if (isAlias(full_path)) { LOG_INFO("File %s is a mac alias\n", full_path); // Check if this file is a shortcut and if so resolve it if (!CheckMacAlias(full_path, tmp_full_path)) { LOG_ERROR("Failure to follow symlink or alias, skipping file\n"); return; } } else { strcpy(tmp_full_path, full_path); } #elif defined(__unix__) || defined(__unix) if (isAlias(full_path)) { LOG_INFO("File %s is a unix symlink\n", full_path); // Check if this file is a shortcut and if so resolve it FollowLink(full_path, tmp_full_path); } else { strcpy(tmp_full_path, full_path); } #elif defined(WIN32) if (strcasecmp(ext, ".lnk") == 0) { // Check if this file is a shortcut and if so resolve it parse_lnk(full_path, tmp_full_path, MAX_PATH_STR_LEN); if (PathIsDirectory(tmp_full_path)) return; } else { strcpy(tmp_full_path, full_path); } #endif // Check if the file has been recently scanned hash = HashFile(tmp_full_path, &mtime, &size); // Skip 0-byte files if (unlikely(size == 0)) { LOG_WARN("Skipping 0-byte file: %s\n", tmp_full_path); return; } // Setup DBT values memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); key.data = (char *)full_path; key.size = strlen(full_path) + 1; data.data = &hash; data.size = sizeof(uint32_t); if ((s->flags & MS_RESCAN) || (s->flags & MS_FULL_SCAN)) { // s->dbp will be null if this function is called directly, if not check if this file is // already scanned. if (s->dbp != NULL) { // DB_GET_BOTH will only return OK if both key and data match, this avoids the need to check // the returned data against hash int ret = s->dbp->get(s->dbp, NULL, &key, &data, DB_GET_BOTH); if (ret != DB_NOTFOUND) { // LOG_INFO("File %s already scanned, skipping\n", tmp_full_path); return; } } } LOG_INFO("Scanning file %s\n", tmp_full_path); if (type == TYPE_UNKNOWN || type == TYPE_LNK) { // auto-detect type type = _should_scan(s, tmp_full_path); if (!type) { if (s->on_error) { ms_errno = MSENO_SCANERROR; e = error_create(tmp_full_path, MS_ERROR_TYPE_UNKNOWN, "Unrecognized file extension"); send_error(s, e); return; } } } r = result_create(s); if (r == NULL) return; r->type = type; r->path = strdup(full_path); if (result_scan(r)) { // These were determined by HashFile r->mtime = mtime; r->size = size; r->hash = hash; // Store path -> hash data in cache if (s->dbp != NULL) { memset(&data, 0, sizeof(DBT)); data.data = &hash; data.size = sizeof(uint32_t); ret = s->dbp->put(s->dbp, NULL, &key, &data, 0); if (ret != 0) { s->dbp->err(s->dbp, ret, "Cache store failed: %s", db_strerror(ret)); } } send_result(s, r); } else { if (s->on_error && r->error) { // Copy the error, because the original will be cleaned up by result_destroy below MediaScanError *ecopy = error_copy(r->error); send_error(s, ecopy); } result_destroy(r); } } /* ms_scan_file() */
const ValueArray& Value::aliasTemplateArguments() const { assert(isAlias()); return impl_->valueArray; }
// --------------------------------------------------------------------------- // Win32TransService: Constructors and Destructor // --------------------------------------------------------------------------- Win32TransService::Win32TransService(MemoryManager* manager) : fCPMap(NULL) , fManager(manager) { // Figure out if we are on XP or later and save that flag for later use. // We need this because of certain code page conversion calls. OSVERSIONINFO OSVer; OSVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); ::GetVersionEx(&OSVer); if ((OSVer.dwPlatformId == VER_PLATFORM_WIN32_NT) && ((OSVer.dwMajorVersion == 5) && (OSVer.dwMinorVersion > 0))) { onXPOrLater = true; } fCPMap = new RefHashTableOf<CPMapEntry>(109); // // Open up the registry key that contains the info we want. Note that, // if this key does not exist, then we just return. It will just mean // that we don't have any support except for intrinsic encodings supported // by the parser itself (and the LCP support of course. // HKEY charsetKey; if (::RegOpenKeyExA ( HKEY_CLASSES_ROOT , "MIME\\Database\\Charset" , 0 , KEY_READ , &charsetKey)) { return; } // // Read in the registry keys that hold the code page ids. Skip for now // those entries which indicate that they are aliases for some other // encodings. We'll come back and do a second round for those and look // up the original name and get the code page id. // // Note that we have to use A versions here so that this will run on // 98, and transcode the strings to Unicode. // const unsigned int nameBufSz = 1024; char nameBuf[nameBufSz + 1]; unsigned int subIndex; unsigned long theSize; for (subIndex = 0;;++subIndex) { // Get the name of the next key theSize = nameBufSz; if (::RegEnumKeyExA ( charsetKey , subIndex , nameBuf , &theSize , 0, 0, 0, 0) == ERROR_NO_MORE_ITEMS) { break; } // Open this subkey HKEY encodingKey; if (::RegOpenKeyExA ( charsetKey , nameBuf , 0 , KEY_READ , &encodingKey)) { continue; } // // Lts see if its an alias. If so, then ignore it in this first // loop. Else, we'll add a new entry for this one. // if (!isAlias(encodingKey)) { // // Lets get the two values out of this key that we are // interested in. There should be a code page entry and an // IE entry. // // The Codepage entry is the default code page for a computer using that charset // while the InternetEncoding holds the code page that represents that charset // unsigned long theType; unsigned int CPId; unsigned int IEId; theSize = sizeof(unsigned int); if (::RegQueryValueExA ( encodingKey , "Codepage" , 0 , &theType , (unsigned char*)&CPId , &theSize) != ERROR_SUCCESS) { ::RegCloseKey(encodingKey); continue; } // // If this is not a valid Id, and it might not be because its // not loaded on this system, then don't take it. // if (::IsValidCodePage(CPId)) { theSize = sizeof(unsigned int); if (::RegQueryValueExA ( encodingKey , "InternetEncoding" , 0 , &theType , (unsigned char*)&IEId , &theSize) != ERROR_SUCCESS) { ::RegCloseKey(encodingKey); continue; } CPMapEntry* newEntry = new (fManager) CPMapEntry(nameBuf, IEId, fManager); fCPMap->put((void*)newEntry->getEncodingName(), newEntry); } } // And close the subkey handle ::RegCloseKey(encodingKey); } // // Now loop one more time and this time we do just the aliases. For // each one we find, we look up that name in the map we've already // built and add a new entry with this new name and the same id // values we stored for the original. // char aliasBuf[nameBufSz + 1]; for (subIndex = 0;;++subIndex) { // Get the name of the next key theSize = nameBufSz; if (::RegEnumKeyExA ( charsetKey , subIndex , nameBuf , &theSize , 0, 0, 0, 0) == ERROR_NO_MORE_ITEMS) { break; } // Open this subkey HKEY encodingKey; if (::RegOpenKeyExA ( charsetKey , nameBuf , 0 , KEY_READ , &encodingKey)) { continue; } // // If its an alias, look up the name in the map. If we find it, // then construct a new one with the new name and the aliased // ids. // if (isAlias(encodingKey, aliasBuf, nameBufSz)) { int targetLen = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, aliasBuf, -1, NULL, 0); if(targetLen!=0) { XMLCh* uniAlias = (XMLCh*) fManager->allocate ( (targetLen + 1) * sizeof(XMLCh) );//new XMLCh[targetLen + 1]; ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, aliasBuf, -1, (LPWSTR)uniAlias, targetLen); uniAlias[targetLen] = 0; _wcsupr(uniAlias); // Look up the alias name CPMapEntry* aliasedEntry = fCPMap->get(uniAlias); if (aliasedEntry) { int targetLen = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, nameBuf, -1, NULL, 0); if(targetLen!=0) { XMLCh* uniName = (XMLCh*) fManager->allocate ( (targetLen + 1) * sizeof(XMLCh) );//new XMLCh[targetLen + 1]; ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, nameBuf, -1, (LPWSTR)uniName, targetLen); uniName[targetLen] = 0; _wcsupr(uniName); // // If the name is actually different, then take it. // Otherwise, don't take it. They map aliases that are // just different case. // if (!XMLString::equals(uniName, aliasedEntry->getEncodingName())) { CPMapEntry* newEntry = new (fManager) CPMapEntry(uniName, aliasedEntry->getIEEncoding(), fManager); fCPMap->put((void*)newEntry->getEncodingName(), newEntry); } fManager->deallocate(uniName);//delete [] uniName; } } fManager->deallocate(uniAlias);//delete [] uniAlias; } } // And close the subkey handle ::RegCloseKey(encodingKey); } // And close the main key handle ::RegCloseKey(charsetKey); }
void recurse_dir(MediaScan *s, const char *path, int recurse_count) { char *dir, *p; char tmp_full_path[MAX_PATH_STR_LEN]; DIR *dirp; struct dirent *dp; struct dirq *subdirq; // list of subdirs of the current directory struct dirq_entry *parent_entry = NULL; // entry for current dir in s->_dirq char redirect_dir[MAX_PATH_STR_LEN]; if (recurse_count > RECURSE_LIMIT) { LOG_ERROR("Hit recurse limit of %d scanning path %s\n", RECURSE_LIMIT, path); return; } if (path[0] != '/') { // XXX Win32 // Get full path char *buf = (char *)malloc((size_t)MAX_PATH_STR_LEN); if (buf == NULL) { FATAL("Out of memory for directory scan\n"); return; } dir = getcwd(buf, (size_t)MAX_PATH_STR_LEN); strcat(dir, "/"); strcat(dir, path); } else { #ifdef USING_TCMALLOC // strdup will cause tcmalloc to crash on free dir = (char *)malloc((size_t)MAX_PATH_STR_LEN); strcpy(dir, path); #else dir = strdup(path); #endif } // Strip trailing slash if any p = &dir[0]; while (*p != 0) { if (p[1] == 0 && *p == '/') *p = 0; p++; } LOG_INFO("Recursed into %s\n", dir); #if defined(__APPLE__) if (isAlias(dir)) { if (CheckMacAlias(dir, redirect_dir)) { LOG_INFO("Resolving Alias %s to %s\n", dir, redirect_dir); strcpy(dir, redirect_dir); } else { LOG_ERROR("Failure to follow symlink or alias, skipping directory\n"); goto out; } } #elif defined(__linux__) if (isAlias(dir)) { FollowLink(dir, redirect_dir); LOG_INFO("Resolving symlink %s to %s\n", dir, redirect_dir); strcpy(dir, redirect_dir); } #endif if ((dirp = opendir(dir)) == NULL) { LOG_ERROR("Unable to open directory %s: %s\n", dir, strerror(errno)); goto out; } subdirq = malloc(sizeof(struct dirq)); SIMPLEQ_INIT(subdirq); while ((dp = readdir(dirp)) != NULL) { char *name = dp->d_name; // skip all dot files if (name[0] != '.') { // Check if scan should be aborted if (unlikely(s->_want_abort)) break; // XXX some platforms may be missing d_type/DT_DIR if (dp->d_type == DT_DIR) { // Add to list of subdirectories we need to recurse into struct dirq_entry *subdir_entry = malloc(sizeof(struct dirq_entry)); // Construct full path //*tmp_full_path = 0; strcpy(tmp_full_path, dir); strcat(tmp_full_path, "/"); strcat(tmp_full_path, name); if (_should_scan_dir(s, tmp_full_path)) { subdir_entry->dir = strdup(tmp_full_path); SIMPLEQ_INSERT_TAIL(subdirq, subdir_entry, entries); LOG_INFO(" subdir: %s\n", tmp_full_path); } else { LOG_INFO(" skipping subdir: %s\n", tmp_full_path); } } else { enum media_type type = _should_scan(s, name); LOG_INFO("name %s = type %d\n", name, type); if (type) { struct fileq_entry *entry; // Check if this file is a shortcut and if so resolve it #if defined(__APPLE__) if (isAlias(name)) { char full_name[MAX_PATH_STR_LEN]; LOG_INFO("Mac Alias detected\n"); strcpy(full_name, dir); strcat(full_name, "\\"); strcat(full_name, name); parse_lnk(full_name, redirect_dir, MAX_PATH_STR_LEN); if (PathIsDirectory(redirect_dir)) { struct dirq_entry *subdir_entry = malloc(sizeof(struct dirq_entry)); subdir_entry->dir = strdup(redirect_dir); SIMPLEQ_INSERT_TAIL(subdirq, subdir_entry, entries); LOG_INFO(" subdir: %s\n", tmp_full_path); type = 0; } } #elif defined(__linux__) if (isAlias(name)) { char full_name[MAX_PATH_STR_LEN]; printf("Linux Alias detected\n"); strcpy(full_name, dir); strcat(full_name, "\\"); strcat(full_name, name); FollowLink(full_name, redirect_dir); if (PathIsDirectory(redirect_dir)) { struct dirq_entry *subdir_entry = malloc(sizeof(struct dirq_entry)); subdir_entry->dir = strdup(redirect_dir); SIMPLEQ_INSERT_TAIL(subdirq, subdir_entry, entries); LOG_INFO(" subdir: %s\n", tmp_full_path); type = 0; } } #endif if (parent_entry == NULL) { // Add parent directory to list of dirs with files parent_entry = malloc(sizeof(struct dirq_entry)); parent_entry->dir = strdup(dir); parent_entry->files = malloc(sizeof(struct fileq)); SIMPLEQ_INIT(parent_entry->files); SIMPLEQ_INSERT_TAIL((struct dirq *)s->_dirq, parent_entry, entries); } // Add scannable file to this directory list entry = malloc(sizeof(struct fileq_entry)); entry->file = strdup(name); entry->type = type; SIMPLEQ_INSERT_TAIL(parent_entry->files, entry, entries); s->progress->total++; LOG_INFO(" [%5d] file: %s\n", s->progress->total, entry->file); } } } } closedir(dirp); // Send progress update if (s->on_progress && !s->_want_abort) if (progress_update(s->progress, dir)) send_progress(s); // process subdirs while (!SIMPLEQ_EMPTY(subdirq)) { struct dirq_entry *subdir_entry = SIMPLEQ_FIRST(subdirq); SIMPLEQ_REMOVE_HEAD(subdirq, entries); if (!s->_want_abort) recurse_dir(s, subdir_entry->dir, recurse_count); free(subdir_entry); } free(subdirq); out: free(dir); }
// --------------------------------------------------------------------------- // CygwinTransService: Constructors and Destructor // --------------------------------------------------------------------------- CygwinTransService::CygwinTransService() { fCPMap = new RefHashTableOf<CPMapEntry>(109); // // Open up the registry key that contains the info we want. Note that, // if this key does not exist, then we just return. It will just mean // that we don't have any support except for intrinsic encodings supported // by the parser itself (and the LCP support of course. // HKEY charsetKey; if (::RegOpenKeyExA ( HKEY_CLASSES_ROOT , "MIME\\Database\\Charset" , 0 , KEY_READ , &charsetKey)) { return; } // // Read in the registry keys that hold the code page ids. Skip for now // those entries which indicate that they are aliases for some other // encodings. We'll come back and do a second round for those and look // up the original name and get the code page id. // // Note that we have to use A versions here so that this will run on // 98, and transcode the strings to Unicode. // const unsigned int nameBufSz = 1024; char nameBuf[nameBufSz + 1]; unsigned int subIndex = 0; unsigned long theSize; while (true) { // Get the name of the next key theSize = nameBufSz; if (::RegEnumKeyExA ( charsetKey , subIndex , nameBuf , &theSize , 0, 0, 0, 0) == ERROR_NO_MORE_ITEMS) { break; } // Open this subkey HKEY encodingKey; if (::RegOpenKeyExA ( charsetKey , nameBuf , 0 , KEY_READ , &encodingKey)) { XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService); } // // Lts see if its an alias. If so, then ignore it in this first // loop. Else, we'll add a new entry for this one. // if (!isAlias(encodingKey)) { // // Lets get the two values out of this key that we are // interested in. There should be a code page entry and an // IE entry. // unsigned long theType; unsigned int CPId; unsigned int IEId; theSize = sizeof(unsigned int); if (::RegQueryValueExA ( encodingKey , "Codepage" , 0 , &theType , (unsigned char*)&CPId , &theSize) != ERROR_SUCCESS) { XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService); } // // If this is not a valid Id, and it might not be because its // not loaded on this system, then don't take it. // if (::IsValidCodePage(CPId)) { theSize = sizeof(unsigned int); if (::RegQueryValueExA ( encodingKey , "InternetEncoding" , 0 , &theType , (unsigned char*)&IEId , &theSize) != ERROR_SUCCESS) { XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService); } CPMapEntry* newEntry = new CPMapEntry(nameBuf, CPId, IEId); fCPMap->put((void*)newEntry->getEncodingName(), newEntry); } } // And now close the subkey handle and bump the subkey index ::RegCloseKey(encodingKey); subIndex++; } // // Now loop one more time and this time we do just the aliases. For // each one we find, we look up that name in the map we've already // built and add a new entry with this new name and the same id // values we stored for the original. // subIndex = 0; char aliasBuf[nameBufSz + 1]; while (true) { // Get the name of the next key theSize = nameBufSz; if (::RegEnumKeyExA ( charsetKey , subIndex , nameBuf , &theSize , 0, 0, 0, 0) == ERROR_NO_MORE_ITEMS) { break; } // Open this subkey HKEY encodingKey; if (::RegOpenKeyExA ( charsetKey , nameBuf , 0 , KEY_READ , &encodingKey)) { XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService); } // // If its an alias, look up the name in the map. If we find it, // then construct a new one with the new name and the aliased // ids. // if (isAlias(encodingKey, aliasBuf, nameBufSz)) { const unsigned int srcLen = strlen(aliasBuf); const unsigned int targetLen = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, aliasBuf, srcLen, NULL, 0); XMLCh* uniAlias = (XMLCh*) XMLPlatformUtils::fgMemoryManager->allocate ( (targetLen + 1) * sizeof(XMLCh) );//new XMLCh[targetLen + 1]; ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, aliasBuf, srcLen, (LPWSTR)uniAlias, targetLen); uniAlias[targetLen] = 0; ::LCMapStringW( gLocaleId, LCMAP_UPPERCASE, (LPCWSTR)uniAlias, targetLen, (LPWSTR)uniAlias, targetLen); // Look up the alias name CPMapEntry* aliasedEntry = fCPMap->get(uniAlias); if (aliasedEntry) { // // If the name is actually different, then take it. // Otherwise, don't take it. They map aliases that are // just different case. // if (auxCompareString(uniAlias, aliasedEntry->getEncodingName(), -1L, false)) { CPMapEntry* newEntry = new CPMapEntry(uniAlias, aliasedEntry->getWinCP(), aliasedEntry->getIEEncoding()); fCPMap->put((void*)newEntry->getEncodingName(), newEntry); } } XMLPlatformUtils::fgMemoryManager->deallocate(uniAlias);//delete [] uniAlias; } // And now close the subkey handle and bump the subkey index ::RegCloseKey(encodingKey); subIndex++; } // And close the main key handle ::RegCloseKey(charsetKey); }
/* * getCommand * * arguments: * char *cmdLine: pointer to the command line string * * returns: commandT*: pointer to the commandT struct generated by * parsing the cmdLine string * * This parses the command line string, and returns a commandT struct, * as defined in runtime.h. You must free the memory used by commandT * using the freeCommand function after you are finished. * * This function tokenizes the input, preserving quoted strings. It * supports escaping quotes and the escape character, '\'. */ commandT* getCommand(char* cmdLine) { //printf("here"); char* restOfLine = (char*)malloc(sizeof(char)*BUFSIZE); //char* restCmdLine = (char*)malloc(sizeof(char)*BUFSIZE); commandT* cmd = malloc(sizeof(commandT) + sizeof(char*) * MAXARGS); cmd->argv[0] = 0; cmd->name = 0; cmd->argc = 0; cmd->piped = FALSE; cmd->next=NULL; int i, inArg = 0; char quote = 0; char escape = 0; // Set up the initial empty argument char* tmp = malloc(sizeof(char*) * BUFSIZE); int tmpLen = 0; tmp[0] = 0; //For aliasing: //aliasL* alias; char* keptString = 0; //printf("parsing:%s\n", cmdLine); for (i = 0; cmdLine[i] != 0; i++) { //printf("\tindex %d, char %c\n", i, cmdLine[i]); // Check for whitespace if (cmdLine[i] == ' ') { if (inArg == 0) continue; if (quote == 0) { // End of an argument cmd->argv[cmd->argc] = malloc(sizeof(char) * (tmpLen + 1)); strcpy(cmd->argv[cmd->argc], tmp); //Get rest of command to add on to expanded command of alias if(cmd->argc==0){ if(isAlias(cmd->argv[0])){ alias=getAlias(cmd->argv[0]); if(alias->found == FALSE){ keptString = splitCmd(cmdLine, i, restOfLine); //printf("The rest of the string is: %s\n", keptString); } } } inArg = 0; tmp[0] = 0; tmpLen = 0; cmd->argc++; cmd->argv[cmd->argc] = 0; continue; } } // If we get here, we're in text or a quoted string inArg = 1; // Start or end quoting. if (cmdLine[i] == '\'' || cmdLine[i] == '"') { if (escape != 0 && quote != 0 && cmdLine[i] == quote) { // Escaped quote. Add it to the argument. tmp[tmpLen++] = cmdLine[i]; tmp[tmpLen] = 0; escape = 0; continue; } if (quote == 0) { //printf("\t\tstarting quote around %c\n", cmdLine[i]); quote = cmdLine[i]; continue; } else { if (cmdLine[i] == quote) { //printf("\t\tfound end quote %c\n", quote); quote = 0; continue; } } } // Handle escape character repeat if (cmdLine[i] == '\\' && escape == '\\') { escape = 0; tmp[tmpLen++] = '\\'; tmp[tmpLen] = 0; continue; } // Handle single escape character followed by a non-backslash or quote character if (escape == '\\') { if (quote != 0) { tmp[tmpLen++] = '\\'; tmp[tmpLen] = 0; } escape = 0; } // Set the escape flag if we have a new escape character sequence. if (cmdLine[i] == '\\') { escape = '\\'; continue; } if(cmdLine[i] =='|'){ cmd->piped =TRUE; i+=2; char* nextCmd = splitCmd(cmdLine, i, restOfLine); pipeSeq(nextCmd, cmd); //printf("%s\n",nextCmd); //cmd->piped =TRUE; //printf("Piped is %b\n", cmd->piped); break; } tmp[tmpLen++] = cmdLine[i]; tmp[tmpLen] = 0; } // End the final argument, if any. if (tmpLen > 0) { //printf("\t\tend of argument %d, got:%s\n", cmd.argc, tmp); cmd->argv[cmd->argc] = malloc(sizeof(char) * (tmpLen + 1)); strcpy(cmd->argv[cmd->argc], tmp); //cmd->next=0; inArg = 0; tmp[0] = 0; tmpLen = 0; cmd->argc++; cmd->argv[cmd->argc] = 0; //If input is an alias call expanded command if(isAlias(cmd->argv[0])){ alias=getAlias(cmd->argv[0]); if(alias->found == FALSE){ char* concat = concatCmd(alias->origName, keptString); alias->found=TRUE; cmd = getCommand(concat); alias->found=FALSE; //free(concat); } // alias->found=FALSE; } } free(tmp); //TODO Maybe we Need the cmd Line? free(restOfLine); //free(restCmdLine); cmd->name = cmd->argv[0]; return cmd; } /* getCommand */