static int all_c_code(const char * f){
if(is_dir(f) && !starts_with(f,".")){ return 1; }
if(starts_with(f, "_")){ return 0; } //TODO fixme
if(ends_with(f, ".h") || ends_with(f, ".c")){
return 1;
}
return 0;
};
TokenMap* TokenMap::from_partitioner(StringRef partitioner) {
if (ends_with(partitioner, Murmur3Partitioner::name())) {
return new TokenMapImpl<Murmur3Partitioner>();
} else if (ends_with(partitioner, RandomPartitioner::name())) {
return new TokenMapImpl<RandomPartitioner>();
} else if (ends_with(partitioner, ByteOrderedPartitioner::name())) {
return new TokenMapImpl<ByteOrderedPartitioner>();
} else {
LOG_WARN("Unsupported partitioner class '%s'", partitioner.to_string().c_str());
return NULL;
}
}
static const char *
fqd_http_mime_type(const char *url) {
if(ends_with(url, ".js")) return "text/javascript";
if(ends_with(url, ".json")) return "application/json";
if(ends_with(url, ".css")) return "text/css";
if(ends_with(url, ".jpg") || ends_with(url, ".jpeg")) return "image/jpeg";
if(ends_with(url, ".gif")) return "image/gif";
if(ends_with(url, ".png")) return "image/png";
if(ends_with(url, "/") || ends_with(url, ".html") || ends_with(url, ".htm"))
return "text/html";
return "application/octet-stream";
}
// This callback function will be called when the decoder produces trace output
void trace_callback(const char* zone, const char* data, void* context)
{
(void) context;
// The zone string starts with our custom prefix, so it is easier to
// check if the zone ends with a given suffix
if (ends_with(zone, "decoder_state") ||
ends_with(zone, "symbol_coefficients_before_read_symbol") ||
ends_with(zone, "symbol_index_before_read_uncoded_symbol"))
{
printf("%s:\n", zone);
printf("%s\n", data);
}
}
bool MeshModel::saveToFile(const std::string filename) const
{
std::ofstream outfile(filename);
if (outfile.bad())
return false;
if (ends_with(filename, "off") || ends_with(filename, "OFF"))
return saveOFF(outfile);
else if (ends_with(filename, "obj") || ends_with(filename, "OBJ"))
return saveOBJ(outfile);
return false;
}
static void
step1a(wchar_t *word) {
int len;
len = wcslen(word);
if(ends_with(word, L"SSES")) {
word[len-2] = '\0';
} else if(ends_with(word, L"IES")) {
word[len-2] = '\0';
} else if(!ends_with(word, L"SS") && ends_with(word, L"S")) {
word[len-1] = '\0';
}
}
SharedRefPtr<ReplicationStrategy> ReplicationStrategy::from_keyspace_meta(const KeyspaceMetadata& ks_meta) {
std::string strategy_class = ks_meta.strategy_class();
SharedRefPtr<ReplicationStrategy> strategy;
if (ends_with(strategy_class, NetworkTopologyStrategy::STRATEGY_CLASS)) {
return SharedRefPtr<ReplicationStrategy>(
new NetworkTopologyStrategy(strategy_class, ks_meta.strategy_options()));
} else if (ends_with(strategy_class, SimpleStrategy::STRATEGY_CLASS)) {
return SharedRefPtr<ReplicationStrategy>(
new SimpleStrategy(strategy_class, ks_meta.strategy_options()));
} else {
return SharedRefPtr<ReplicationStrategy>(new NonReplicatedStrategy(strategy_class));
}
}
int64_t
GetImageMetadata(const char *path, char *name)
{
if (ends_with (path, ".jpg") || ends_with (path, ".jpeg"))
{
return _get_jpeg_metadata (path, name);
}
else if (ends_with (path, ".png"))
{
return _get_png_metadata (path, name);
}
else
return 0;
}
size_t Environment<T>::print(std::string prefix)
{
size_t indent = 0;
if (parent_) indent = parent_->print(prefix) + 1;
std::cerr << prefix << std::string(indent, ' ') << "== " << this << std::endl;
for (typename std::map<std::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
if (!ends_with(i->first, "[f]") && !ends_with(i->first, "[f]4") && !ends_with(i->first, "[f]2")) {
std::cerr << prefix << std::string(indent, ' ') << i->first << " " << i->second;
if (Value* val = dynamic_cast<Value*>(i->second))
{ std::cerr << " : " << val->to_string(); }
std::cerr << std::endl;
}
}
return indent ;
}
inline std::string get_j4a_loader_file(const std::string& value)
{
if (ends_with(value, ".c")) {
std::string result(value, 0, value.length() - 2);
return result + ".loader.j4a";
} else if (ends_with(value, ".cpp")) {
std::string result(value, 0, value.length() - 4);
return result + ".loader.j4a";
} else if (ends_with(value, ".java")) {
std::string result(value, 0, value.length() - 5);
return result + ".loader.j4a";
}
return value + ".loader.j4a";
}
static void
step5(wchar_t *word) {
int len;
len = wcslen(word);
if(ends_with(word, L"E") && compute_measure(word, len-1) > 1) {
word[len-1] = '\0';
} else if(ends_with(word, L"E") && compute_measure(word, len-1) == 1 && !ends_consonant_vowel_consonant(word, len-1)) {
word[len-1] = '\0';
}
if(ends_with(word, L"L") && compute_measure(word, len) > 1 && ends_double_consonant(word, len)) {
word[len-1] = '\0';
}
}
void DirectoryTree::import_from_files()
{
QModelIndexList ids = selectionModel()->selectedIndexes();
if (ids.size() == 0)
return;
QModelIndex index = ids.at(0);
if (!index.isValid())
return;
// 弹出对话框
QStringList files = QFileDialog::getOpenFileNames(this,
tr("打开文件"),
QString::fromLocal8Bit(_last_visited_dir.data(), _last_visited_dir.length()),
"Text file (*.txt)");
const size_t size = files.size();
if (size == 0)
return;
DirectoryTreeModel *m = dynamic_cast<DirectoryTreeModel*>(model());
assert(NULL != m);
for (size_t i = 0; i < size; ++i)
{
const QString& file = files.at(i);
// get title
string dir, name;
Path::split(file.toLocal8Bit(), &dir, &name);
if (!ends_with(name.c_str(), ".txt") && !ends_with(name.c_str(), ".TXT"))
continue;
string title;
Path::split_ext(name.c_str(), &title, NULL);
_last_visited_dir = dir;
// get content
QString all = read_text_file(file);
all = convert_txt_to_html(all);
// insert to db
m->insert_article(index, QString::fromLocal8Bit(title.data(), title.length()),
MIME_PKM_RICHTEXT, all);
}
// 发送通知
DirectoryItem *p = static_cast<DirectoryItem*>(index.internalPointer());
assert(NULL != p);
PkmPlugin *plugin = dynamic_cast<PkmPlugin*>(get_plugin().pointer());
plugin->directory_activated(p->get_id(), p->get_name());
}
/*
* the::text::string_compare_utility::ends_with
*/
bool the::text::string_compare_utility::ends_with(const char *str,
size_t strLen, const char *end, size_t endLen, bool matchCase) {
if ((endLen == 0) || (endLen > strLen)) return false;
if (matchCase) {
return ::memcmp(str + (strLen - endLen), end, endLen * sizeof(char))
== 0;
} else {
if (the::text::locale_utility::is_utf8_locale()) {
the::wstring s, e;
the::text::string_converter::convert(s, str, strLen);
the::text::string_converter::convert(e, end, endLen);
return ends_with(s.c_str(), s.length(), e.c_str(), e.length(),
false);
}
for (size_t i = 0; i < endLen; i++) {
if (char_utility::to_lower_case(str[strLen - endLen + i])
!= char_utility::to_lower_case(end[i])) {
return false;
}
}
return true;
}
}
vector<string> *Sound::get_wav_filenames()
{
vector<string> *wav_filenames = new vector<string>;
struct dirent *dirent;
DIR *dir;
if (base_sound_directory.empty())
{
error->log(SOUND, IMPORTANT, "No sound directory specified\n");
return NULL;
}
if ((dir = opendir(base_sound_directory.c_str())) == NULL)
{
error->log(SOUND, CRITICAL, "Can't open " + base_sound_directory + "\n");
return NULL;
}
while ((dirent = readdir(dir)))
{
if (ends_with(dirent->d_name, ".wav"))
{
wav_filenames->push_back(dirent->d_name);
}
}
if (closedir(dir) != 0)
{
error->log(SOUND, CRITICAL, "Trouble closing " + base_sound_directory + "\n");
return NULL;
}
return wav_filenames;
}
bool is_source_file(const std::string& filename, std::string &fixed_file_name)
{
StringVec_t extensions;
extensions.push_back(".cpp");
extensions.push_back(".cxx");
extensions.push_back(".cc");
extensions.push_back(".c");
for(size_t n=0; n<extensions.size(); ++n) {
if ( ends_with(filename, extensions.at(n)) ) {
fixed_file_name = filename;
#ifdef _WIN32
std::replace(fixed_file_name.begin(), fixed_file_name.end(), '/', '\\');
#endif
char* ret = normalize_path(fixed_file_name.c_str(), fixed_file_name.length());
fixed_file_name = ret;
free(ret);
// rtrim
fixed_file_name.erase(0, fixed_file_name.find_first_not_of("\t\r\v\n\" "));
// ltrim
fixed_file_name.erase(fixed_file_name.find_last_not_of("\t\r\v\n\" ")+1);
return true;
}
}
fixed_file_name.clear();
return false;
}
/* Validates list of tags. Returns zero if tags are well-formed and non-zero
* otherwise. */
static int
validate_tags(const char tags[])
{
return tags[0] == '\0'
|| starts_with_lit(tags, ",") || strstr(tags, ",,") != NULL
|| ends_with(tags, ",");
}
static int is_executable(const char *name)
{
struct stat st;
if (stat(name, &st) || /* stat, not lstat */
!S_ISREG(st.st_mode))
return 0;
#if defined(GIT_WINDOWS_NATIVE)
/* On Windows we cannot use the executable bit. The executable
* state is determined by extension only. We do this first
* because with virus scanners opening an executeable for
* reading is potentially expensive.
*/
if (ends_with(name, ".exe"))
return S_IXUSR;
{ /* now that we know it does not have an executable extension,
peek into the file instead */
char buf[3] = { 0 };
int n;
int fd = open(name, O_RDONLY);
st.st_mode &= ~S_IXUSR;
if (fd >= 0) {
n = read(fd, buf, 2);
if (n == 2)
/* look for a she-bang */
if (!strcmp(buf, "#!"))
st.st_mode |= S_IXUSR;
close(fd);
}
}
#endif
return st.st_mode & S_IXUSR;
}
static FILE *
extract_outfile_gen(char **outname_ptr, int w, int h, int bc, int i)
{
char *inname = *outname_ptr;
if (output == NULL || is_directory(output)) {
StrBuf *outname;
char *inbase;
outname = strbuf_new();
if (output != NULL) {
strbuf_append(outname, output);
if (!ends_with(output, "/"))
strbuf_append(outname, "/");
}
inbase = strrchr(inname, '/');
inbase = (inbase == NULL ? inname : inbase+1);
if (ends_with_nocase(inbase, ".ico") || ends_with_nocase(inbase, ".cur")) {
strbuf_append_substring(outname, inbase, 0, strlen(inbase)-4);
} else {
strbuf_append(outname, inbase);
}
strbuf_appendf(outname, "_%d_%dx%dx%d.png", i, w, h, bc);
*outname_ptr = strbuf_free_to_string(outname);
return fopen(*outname_ptr, "wb");
}
else if (strcmp(output, "-") == 0) {
*outname_ptr = xstrdup(_("(standard out)"));
return stdout;
}
*outname_ptr = xstrdup(output);
return fopen(output, "wb");
}
/**
* Given path to app binary, say app.dll or app.exe, retrieve the app.deps.json.
*/
pal::string_t get_deps_from_app_binary(const pal::string_t& app)
{
assert(app.find(DIR_SEPARATOR) != pal::string_t::npos);
assert(ends_with(app, _X(".dll"), false) || ends_with(app, _X(".exe"), false));
// First append directory.
pal::string_t deps_file;
deps_file.assign(get_directory(app));
deps_file.push_back(DIR_SEPARATOR);
// Then the app name and the file extension
pal::string_t app_name = get_filename(app);
deps_file.append(app_name, 0, app_name.find_last_of(_X(".")));
deps_file.append(_X(".deps.json"));
return deps_file;
}
inline bool iends_with(
const Range1T& Input,
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return ends_with(Input, Test, is_iequal(Loc));
}
/**
* Get the list of midi files directly in the given directory
* return a vector of file names
* note: we don't check if they are valid MIDI files, only if the
* MIDI extension is here
*/
static std::vector<std::string> get_midi_files(const std::string& path) {
const std::string MIDI_EXTENSION(".mid");
std::vector<std::string> midiFileNames;
tinydir_dir midiDir;
tinydir_open_sorted(&midiDir, path.c_str());
for (unsigned i = 0; i < midiDir.n_files; i++) {
tinydir_file file;
tinydir_readfile_n(&midiDir, &file, i);
if (file.is_dir) {
continue;
}
std::string tmpFileName(file.name);
std::cout << tmpFileName << std::endl;
if (!ends_with(tmpFileName, MIDI_EXTENSION)) {
continue ;
}
std::cout << tmpFileName << std::endl;
midiFileNames.push_back(tmpFileName);
}
tinydir_close(&midiDir);
return midiFileNames;
}
/**
* Concatenate two file names into a new string.
* If file is "." return a duplicate of file2.
*/
char *
cat_files(const char *file, const char *file2)
{
if (strcmp(file, ".") == 0)
return xstrdup(file2);
return xasprintf("%s%s%s", file, (ends_with(file, "/") ? "" : "/"), file2);
}
void pack_closure(llvm::Type *
#if LLVM_VERSION >= 37
type
#endif
,
Value *dst,
const Closure& closure,
const Scope<Value *> &src,
llvm::StructType *buffer_t,
IRBuilder<> *builder) {
// type, type of dst should be a pointer to a struct of the type returned by build_type
int idx = 0;
LLVMContext &context = builder->getContext();
vector<string> nm = closure.names();
vector<llvm::Type*> ty = llvm_types(closure, buffer_t, context);
for (size_t i = 0; i < nm.size(); i++) {
#if LLVM_VERSION >= 37
Value *ptr = builder->CreateConstInBoundsGEP2_32(type, dst, 0, idx);
#else
Value *ptr = builder->CreateConstInBoundsGEP2_32(dst, 0, idx);
#endif
Value *val;
if (!ends_with(nm[i], ".buffer") || src.contains(nm[i])) {
val = src.get(nm[i]);
if (val->getType() != ty[i]) {
val = builder->CreateBitCast(val, ty[i]);
}
} else {
// Skip over buffers not in the symbol table. They must not be needed.
val = ConstantPointerNull::get(buffer_t->getPointerTo());
}
builder->CreateStore(val, ptr);
idx++;
}
}
void SpaceStationType::Init()
{
assert(s_lua == 0);
if (s_lua != 0) return;
s_lua = luaL_newstate();
lua_State *L = s_lua;
LUA_DEBUG_START(L);
pi_lua_open_standard_base(L);
LuaVector::Register(L);
LUA_DEBUG_CHECK(L, 0);
lua_register(L, "define_orbital_station", define_orbital_station);
lua_register(L, "define_surface_station", define_surface_station);
namespace fs = FileSystem;
for (fs::FileEnumerator files(fs::gameDataFiles, "stations", fs::FileEnumerator::Recurse);
!files.Finished(); files.Next()) {
const fs::FileInfo &info = files.Current();
if (ends_with(info.GetPath(), ".lua")) {
const std::string name = info.GetName();
s_currentStationFile = name.substr(0, name.size()-4);
pi_lua_dofile(L, info.GetPath());
s_currentStationFile.clear();
}
}
LUA_DEBUG_END(L, 0);
}
int cmd_merge_recursive(int argc, const char **argv, const char *prefix)
{
const unsigned char *bases[21];
unsigned bases_count = 0;
int i, failed;
unsigned char h1[20], h2[20];
struct merge_options o;
struct commit *result;
init_merge_options(&o);
if (argv[0] && ends_with(argv[0], "-subtree"))
o.subtree_shift = "";
if (argc < 4)
usagef(builtin_merge_recursive_usage, argv[0]);
for (i = 1; i < argc; ++i) {
const char *arg = argv[i];
if (starts_with(arg, "--")) {
if (!arg[2])
break;
if (parse_merge_opt(&o, arg + 2))
die("Unknown option %s", arg);
continue;
}
if (bases_count < ARRAY_SIZE(bases)-1) {
unsigned char *sha = xmalloc(20);
if (get_sha1(argv[i], sha))
die("Could not parse object '%s'", argv[i]);
bases[bases_count++] = sha;
}
else
warning("Cannot handle more than %d bases. "
"Ignoring %s.",
(int)ARRAY_SIZE(bases)-1, argv[i]);
}
if (argc - i != 3) /* "--" "<head>" "<remote>" */
die("Not handling anything other than two heads merge.");
o.branch1 = argv[++i];
o.branch2 = argv[++i];
if (get_sha1(o.branch1, h1))
die("Could not resolve ref '%s'", o.branch1);
if (get_sha1(o.branch2, h2))
die("Could not resolve ref '%s'", o.branch2);
o.branch1 = better_branch_name(o.branch1);
o.branch2 = better_branch_name(o.branch2);
if (o.verbosity >= 3)
printf("Merging %s with %s\n", o.branch1, o.branch2);
failed = merge_recursive_generic(&o, h1, h2, bases_count, bases, &result);
if (failed < 0)
return 128; /* die() error code */
return failed;
}
void remove_realm_files_from_directory(const std::string &dir_path)
{
FileSystemRequest scandir_req;
if (uv_fs_scandir(uv_default_loop(), &scandir_req, dir_path.c_str(), 0, nullptr) < 0) {
throw UVException(static_cast<uv_errno_t>(scandir_req.result));
}
uv_dirent_t entry;
while (uv_fs_scandir_next(&scandir_req, &entry) != UV_EOF) {
std::string path(dir_path + '/' + entry.name);
if (entry.type == UV_DIRENT_DIR) {
static std::string realm_management_extension(".realm.management");
if (ends_with(path, realm_management_extension)) {
uv_dirent_t management_entry;
FileSystemRequest management_scandir_req;
if (uv_fs_scandir(uv_default_loop(), &management_scandir_req, path.c_str(), 0, nullptr) < 0) {
throw UVException(static_cast<uv_errno_t>(scandir_req.result));
}
while (uv_fs_scandir_next(&management_scandir_req, &management_entry) != UV_EOF) {
std::string management_entry_path = path + '/' + management_entry.name;
FileSystemRequest delete_req;
if (uv_fs_unlink(uv_default_loop(), &delete_req, management_entry_path.c_str(), nullptr) != 0) {
throw UVException(static_cast<uv_errno_t>(delete_req.result));
}
}
FileSystemRequest management_rmdir_req;
if (uv_fs_rmdir(uv_default_loop(), &management_rmdir_req, path.c_str(), nullptr)) {
throw UVException(static_cast<uv_errno_t>(management_rmdir_req.result));
}
}
} else {
static std::string realm_extension(".realm");
static std::string realm_note_extension(".realm.note");
static std::string realm_lock_extension(".realm.lock");
if (ends_with(path, realm_extension) || ends_with(path, realm_note_extension) || ends_with(path, realm_lock_extension)) {
FileSystemRequest delete_req;
if (uv_fs_unlink(uv_default_loop(), &delete_req, path.c_str(), nullptr) != 0) {
throw UVException(static_cast<uv_errno_t>(delete_req.result));
}
}
}
}
}
/**
* Initialize resolved paths to known entries like coreclr, jit.
*/
void deps_resolver_t::init_known_entry_path(const deps_entry_t& entry, const pal::string_t& path)
{
if (entry.asset_type != deps_entry_t::asset_types::native)
{
return;
}
if (m_coreclr_path.empty() && ends_with(entry.relative_path, _X("/") + pal::string_t(LIBCORECLR_NAME), false))
{
m_coreclr_path = path;
return;
}
if (m_clrjit_path.empty() && ends_with(entry.relative_path, _X("/") + pal::string_t(LIBCLRJIT_NAME), false))
{
m_clrjit_path = path;
return;
}
}
// TODO fix this stuff
static int pkg_is_main(struct pkg * slf){
if( ! slf->h_file ){
return ends_with(slf->c_file, "main.c");
}
return 0;
};
int is_compressed_with_index(const char *path, int *index) {
if(ends_with(path, ".compr")) {
*index = strlen(path) - strlen(".compr");
return 1;
} else
*index = -1;
return 0;
}
static void
step1c(wchar_t *word) {
int len;
len = wcslen(word);
if(ends_with(word, L"Y") && contains_vowel(word, len-2) > 0) {
word[len-1] = 'i';
}
}
