static void fill_directory(struct dir_struct *dir, const char **pathspec,
int ignored_too)
{
const char *path, *base;
int baselen;
/* Set up the default git porcelain excludes */
memset(dir, 0, sizeof(*dir));
if (!ignored_too) {
dir->collect_ignored = 1;
setup_standard_excludes(dir);
}
/*
* Calculate common prefix for the pathspec, and
* use that to optimize the directory walk
*/
baselen = common_prefix(pathspec);
path = ".";
base = "";
if (baselen)
path = base = xmemdupz(*pathspec, baselen);
/* Read the directory and prune it */
read_directory(dir, path, base, baselen, pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
}
static int symtab_get_matches(jl_sym_t *tree, const char *str, char **answer)
{
int x, plen, count=0;
ios_t ans;
plen = strlen(str);
while (tree != NULL) {
x = common_prefix(str, tree->name);
if (x == plen) {
ios_mem(&ans, 0);
symtab_search(tree, &count, &ans, str, plen);
size_t nb;
*answer = ios_takebuf(&ans, &nb);
return count;
}
else {
x = strcmp(str, tree->name);
if (x < 0)
tree = tree->left;
else
tree = tree->right;
}
}
return 0;
}
/*
* Take a union of paths in the index and the named tree (typically, "HEAD"),
* and return the paths that match the given pattern in list.
*/
static int list_paths(struct string_list *list, const char *with_tree,
const char *prefix, const struct pathspec *pattern)
{
int i;
char *m;
if (!pattern->nr)
return 0;
m = xcalloc(1, pattern->nr);
if (with_tree) {
char *max_prefix = common_prefix(pattern);
overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
free(max_prefix);
}
for (i = 0; i < active_nr; i++) {
const struct cache_entry *ce = active_cache[i];
struct string_list_item *item;
if (ce->ce_flags & CE_UPDATE)
continue;
if (!ce_path_match(ce, pattern, m))
continue;
item = string_list_insert(list, ce->name);
if (ce_skip_worktree(ce))
item->util = item; /* better a valid pointer than a fake one */
}
return report_path_error(m, pattern, prefix);
}
/// Postprocess settings to compute common prefix.
bool finalize_tool_settings(ToolSettings& s, const boost::program_options::variables_map&) {
s.tools_common_prefix = common_prefix({
s.tools_generic, s.tools_smtrat, s.tools_smtrat_opb,
s.tools_minisatp, s.tools_z3
});
BENCHMAX_LOG_DEBUG("benchmax.tools", "Common tool prefix is " << s.tools_common_prefix);
return false;
}
static void verify_log_output(const size_t buf_sz,
const char *const expected[],
const size_t expected_n)
{
const size_t modifiable = buf_sz + 1;
const size_t unmodifiable = ZF_LOG_BUF_SZ - modifiable;
if (g_line > expected_n)
{
fprintf(stderr, "Lines produced: actual=%u, expected=<%u\n",
(unsigned)g_line, (unsigned)expected_n);
exit(1);
}
size_t complete_lines = 0;
for (size_t i = 0; g_line > i; ++i)
{
const char *const line = g_lines[i];
const size_t line_len = strlen(expected[i]);
const size_t untouched = memchk(line + modifiable, -1, unmodifiable);
const size_t match = common_prefix(expected[i], line_len,
line, g_len[i]);
if (untouched != unmodifiable)
{
fprintf(stderr, "Untouched bytes: actual=%u, expected=%u\n",
(unsigned)untouched, (unsigned)unmodifiable);
exit(1);
}
if (g_null_pos[i] != g_len[i])
{
fprintf(stderr, "Null position: actual=%u, expected=%u\n",
(unsigned)g_null_pos[i], (unsigned)g_len[i]);
exit(1);
}
if (match < g_len[i])
{
fprintf(stderr, "Line partial match: actual=%u, expected=>%u\n",
(unsigned)match, (unsigned)g_len[i]);
exit(1);
}
if (line_len <= buf_sz)
{
++complete_lines;
if (line_len <= buf_sz && match != g_len[i])
{
fprintf(stderr, "Line complete match: actual=%u, expected=%u\n",
(unsigned)match, (unsigned)g_len[i]);
exit(1);
}
}
}
if (expected_n == complete_lines && g_line != expected_n)
{
fprintf(stderr, "Complete lines produced: actual=%u, expected=<%u\n",
(unsigned)g_line, (unsigned)expected_n);
exit(1);
}
}
static int symtab_get_matches(jl_sym_t *tree, const char *str, char **answer)
{
int x, plen, count=0;
ios_t ans;
// given str "X.Y.a", set module := X.Y and name := "a"
jl_module_t *module = NULL;
char *name = NULL, *strcopy = strdup(str);
for (char *s=strcopy, *r=NULL;; s=NULL) {
char *t = strtok_r(s, ".", &r);
if (!t) {
if (str[strlen(str)-1] == '.') {
// this case is "Module."
if (name) {
if (!module) module = jl_current_module;
module = find_submodule_named(module, name);
if (!module) goto symtab_get_matches_exit;
}
name = "";
}
break;
}
if (name) {
if (!module) module = jl_current_module;
module = find_submodule_named(module, name);
if (!module) goto symtab_get_matches_exit;
}
name = t;
}
if (!name) goto symtab_get_matches_exit;
plen = strlen(name);
while (tree != NULL) {
x = common_prefix(name, tree->name);
if (x == plen) {
ios_mem(&ans, 0);
symtab_search(tree, &count, &ans, module, str, name, plen);
size_t nb;
*answer = ios_takebuf(&ans, &nb);
break;
}
else {
x = strcmp(name, tree->name);
if (x < 0)
tree = tree->left;
else
tree = tree->right;
}
}
symtab_get_matches_exit:
free(strcopy);
return count;
}
// If the names of all children have the form (PREFIX)(INDEX)(SUFFIX),
// return the common PREFIX and SUFFIX.
void DispValue::get_index_surroundings(string& prefix, string& suffix) const
{
assert (nchildren() > 0);
prefix = child(0)->full_name();
suffix = child(0)->full_name();
for (int i = 1; i < nchildren(); i++)
{
prefix = common_prefix(prefix, child(i)->full_name());
suffix = common_suffix(suffix, child(i)->full_name());
}
}
static void symtab_search(jl_sym_t *tree, int *pcount, ios_t *result,
const char *prefix, int plen)
{
do {
if (common_prefix(prefix, tree->name) == plen &&
jl_boundp(jl_system_module, tree)) {
ios_puts(tree->name, result);
ios_putc('\n', result);
(*pcount)++;
}
if (tree->left)
symtab_search(tree->left, pcount, result, prefix, plen);
tree = tree->right;
} while (tree != NULL);
}
static void symtab_search(jl_sym_t *tree, int *pcount, ios_t *result,
jl_module_t *module, const char *str,
const char *prefix, int plen)
{
do {
if (common_prefix(prefix, tree->name) == plen &&
(module ? jl_defines_or_exports_p(module, tree) : jl_boundp(jl_current_module, tree))) {
ios_puts(str, result);
ios_puts(tree->name + plen, result);
ios_putc('\n', result);
(*pcount)++;
}
if (tree->left)
symtab_search(tree->left, pcount, result, module, str, prefix, plen);
tree = tree->right;
} while (tree != NULL);
}
Path::completion Path::complete(String & s) const {
Path copy(*this);
copy.rep += '*';
List<Path> all;
copy.expand_wildcards(all);
completion ret = Path::no_completion;
if (all.length() == 1) {
// s = all.get()->rep;
s = all.get().rep;
ret = Path::unique_completion;
}
else if (all.length() > 1) {
s = common_prefix(all);
ret = Path::several_completions;
}
return ret;
}
int fill_directory(struct dir_struct *dir, const char **pathspec)
{
const char *path;
int len;
/*
* Calculate common prefix for the pathspec, and
* use that to optimize the directory walk
*/
len = common_prefix(pathspec);
path = "";
if (len)
path = xmemdupz(*pathspec, len);
/* Read the directory and prune it */
read_directory(dir, path, len, pathspec);
return len;
}
char* get_longest_prefix(char **results){
int i;
int prefix=0;
int test=0;
char *ret=NULL;
if(results && results[0]){
prefix=strlen(results[0]);
for(i=1;results[i];i++){
test=common_prefix(results[0],results[i]);
prefix=minimum(prefix,test);
}
INIT_MEM(ret,(2*prefix)+1);
memcpy(ret,results[0],prefix);
ret[prefix]=0;
add_slashes(ret,prefix+1);
}
return ret;
}
string longestCommonPrefix(vector<string>& strs) {
string common_prefix("");
int maxlength = 0;
for (int i = 0; i < strs.size(); i++) {
if (strs[i].length() > maxlength)
maxlength = strs[i].length();
}
for (int i = 0; i < maxlength; i++) {
for (int j = 0; j < strs.size(); j++) {
if (common_prefix.length() == i)
common_prefix += strs[j][i];
else if (common_prefix[i] != strs[j][i])
return common_prefix.erase(common_prefix.size() - 1);
}
}
return common_prefix;
}
// precondition: players should be sorted by team by nameclean or nameclean reverse
void determine_clantags( int prefix )
{
// if prefix is true , search for prefix, else search for postfix
// players should be sorted by team by nameclean
// determine clantags from teams
// we need to extract the [dbB+ ] part
// go for the biggest common prefix (for at least half the team)
/* Let's hear it for the BLUE team :
PluTo |
Spammage |
dbB+ BLADE y1
dbB+ CROW |
dbB+ DEMOMAN |
dbB+ DeG |
dbB+ SNK y2
duB+ twist |
----x--------
the nr of players from y1 to y2 should be >= pivot
'x' is the length of the tag
*/
//int MIN_TAGLENGTH = 2; // this is the minimum size to be considered a tag
// btw this fixes a bug too.
int y1, y2; // variables to indicate a playerrange : players y1..y2
int p1, p2; // indicate the first and last player in a team
int t; // variable used in for loop to walk the teams
int tag_length; //
int max_length; // longest tag found
int max_y1, max_y2; // playerrange of players that have this longest tag in common
int found_tag;
int finished; // tagsearch finished for this team
int pivot; // nr of players needed to make it a clantag
// do all the teams
p1 = 0; p2 = -1;
for ( t = 0 ; t < team_count ; t++ ) {
p1 = p2 + 1;
p2 = p1;
while ( p2 < player_count - 1 && ( sorted_player( p1 )->team == sorted_player( p2 )->team ) ) {
// look for the last player in this team
p2++;
}
// in case loop ended because of p2 == player_count
if ( sorted_player( p1 )->team != sorted_player( p2 )->team ) {
p2--;
}
// ok, now we got p1 and p2 being the first and last player of the same team
pivot = calculate_pivot_point( nr_players_in_range( p1, p2 ) );
if ( pivot > 0 ) {
y1 = p1;
y2 = p1 + 1;
found_tag = FALSE;
max_length = 0;
finished = ( nr_players_in_range( y1, p2 ) < pivot );
while ( !found_tag && !finished ) {
y2 = y1 + 1;
//tag_length = 0;
while ( y2 <= p2 && common_prefix( y1, y2, &tag_length, prefix ) ){
// we got a playerrange with a common prefix of length "tag_length"
if ( nr_players_in_range( y1, y2 ) >= pivot ) {
// we got the number of players needed to make it a clantag
if ( tag_length > max_length ) {
// cool, it's even bigger than a previously found tag
max_length = tag_length;
max_y1 = y1; // remember first player
max_y2 = y2; // remember last player
// because the tag won't get bigger when we increase y2, we
// may as well speed up the search and break out of this while loop
break;
}
}
y2++;
}
y1++;
finished = ( nr_players_in_range( y1, p2 ) < pivot );
// this means there are not enough players in the range y1..p2 to find
// a possible clantag, so we might as well stop searching this range.
}
if ( max_length >= MIN_TAGLENGTH ) {
// ok we found it
found_tag = TRUE;
if ( prefix ) {
// normal clantag
if ( max_length > (signed)strlen( TEAMS[ sorted_player( max_y1 )->team ].clantag ) ) {
// only copy if it's bigger than the current clantag
strncopy( TEAMS[ sorted_player( max_y1 )->team ].clantag , sorted_player( max_y1 )->nameclean, max_length );
create_clantag_html( player_index[ max_y1 ], FALSE );
}
}
else {
// reverse clantag
if ( max_length > (signed)strlen( TEAMS[ sorted_player( max_y1 )->team ].clantag ) ) {
// only copy if it's bigger than the current clantag
strncopy( TEAMS[ sorted_player( max_y1 )->team ].clantag ,
sorted_player( max_y1 )->nameclean + strlen( sorted_player( max_y1 )->nameclean ) - max_length,
max_length );
create_clantag_html( player_index[ max_y1 ], TRUE );
}
}
rstrip( TEAMS[ sorted_player( max_y1 )->team ].clantag );
}
}
else {
// don't bother, teamsize is 0 or 1, no use to try to get the clantag
}
}
}
static bool extract_theme(const std::string &path, const std::string &target,
const std::string &theme_name)
{
mb::autoclose::archive in(archive_read_new(), archive_read_free);
if (!in) {
LOGE("%s: Out of memory when creating archive reader", __FUNCTION__);
return false;
}
mb::autoclose::archive out(archive_write_disk_new(), archive_write_free);
if (!out) {
LOGE("%s: Out of memory when creating disk writer", __FUNCTION__);
return false;
}
archive_read_support_format_zip(in.get());
// Set up disk writer parameters. We purposely don't extract any file
// metadata
int flags = ARCHIVE_EXTRACT_SECURE_SYMLINKS
| ARCHIVE_EXTRACT_SECURE_NODOTDOT;
archive_write_disk_set_standard_lookup(out.get());
archive_write_disk_set_options(out.get(), flags);
if (archive_read_open_filename(in.get(), path.c_str(), 10240) != ARCHIVE_OK) {
LOGE("%s: Failed to open file: %s",
path.c_str(), archive_error_string(in.get()));
return false;
}
archive_entry *entry;
int ret;
std::string target_path;
std::string common_prefix("theme/common/");
std::string theme_prefix("theme/");
theme_prefix += theme_name;
theme_prefix += '/';
while (true) {
ret = archive_read_next_header(in.get(), &entry);
if (ret == ARCHIVE_EOF) {
break;
} else if (ret == ARCHIVE_RETRY) {
LOGW("%s: Retrying header read", path.c_str());
continue;
} else if (ret != ARCHIVE_OK) {
LOGE("%s: Failed to read header: %s",
path.c_str(), archive_error_string(in.get()));
return false;
}
const char *path = archive_entry_pathname(entry);
if (!path || !*path) {
LOGE("%s: Header has null or empty filename", path);
return false;
}
const char *suffix;
if (mb::util::starts_with(path, common_prefix)) {
suffix = path + common_prefix.size();
} else if (mb::util::starts_with(path, theme_prefix)) {
suffix = path + theme_prefix.size();
} else {
LOGV("Skipping: %s", path);
continue;
}
// Build path
target_path = target;
if (target_path.back() != '/' && *suffix != '/') {
target_path += '/';
}
target_path += suffix;
LOGV("Extracting: %s -> %s", path, target_path.c_str());
archive_entry_set_pathname(entry, target_path.c_str());
// Extract file
ret = archive_read_extract2(in.get(), entry, out.get());
if (ret != ARCHIVE_OK) {
LOGE("%s: %s", archive_entry_pathname(entry),
archive_error_string(in.get()));
return false;
}
}
if (archive_read_close(in.get()) != ARCHIVE_OK) {
LOGE("%s: Failed to close file: %s",
path.c_str(), archive_error_string(in.get()));
return false;
}
return true;
}
address_prefix address_prefix::common_prefix(const address_prefix & second)const
{
return common_prefix(*this, second);
}
int
main (int argc, char **argv)
{
int i, pid, status, res;
int time_out, max_decisions;
char *name;
pretty_print = 0;
multiple_files = 0;
time_out = 3600;
max_decisions = -1; /* no bound is default */
#ifdef SAT2002FMT
verbose = 1;
#else
verbose = 0;
#endif
limmat = 0;
sparse = 0;
name = 0;
for (i = 1; i < argc; i++)
{
if (!strcmp (argv[i], "-h") || !strcmp (argv[i], "--help"))
{
usage ();
exit (0);
}
else if (!strcmp (argv[i], "--clauses"))
{
assignment_as_clauses = 1;
}
else if (!strcmp (argv[i], "--version"))
{
printf ("%s\n", version_Limmat ());
exit (0);
}
else if (!strcmp (argv[i], "--options"))
{
printf ("%s\n", options_Limmat ());
exit (0);
}
else if (!strcmp (argv[i], "--copyright"))
{
printf ("%s\n", copyright_Limmat ());
exit (0);
}
else if (!strcmp (argv[i], "-v") || !strcmp (argv[i], "--verbose"))
{
verbose++;
}
else if (!strcmp (argv[i], "-s") || !strcmp (argv[i], "--sparse"))
{
sparse++;
}
else if (!strcmp (argv[i], "-p") || !strcmp (argv[i], "--pretty-print"))
{
pretty_print = 1;
}
else if (argv[i][0] == '-' && argv[i][1] == 'm')
{
if (argv[i][2])
{
if (isdigit ((int) argv[i][2]))
{
max_decisions = atoi (argv[i] + 2);
}
else
goto EXPECTED_DIGIT_FOR_MAX_DECISIONS_ARGUMENT;
}
else if (++i < argc && isdigit ((int) argv[i][0]))
{
max_decisions = atoi (argv[i]);
}
else
goto EXPECTED_DIGIT_FOR_MAX_DECISIONS_ARGUMENT;
}
else
if (argv[i][0] == '-' &&
argv[i][1] == '-' &&
argv[i][2] == 't' &&
argv[i][3] == 'i' &&
argv[i][4] == 'm' &&
argv[i][5] == 'e' &&
argv[i][6] == '-' &&
argv[i][7] == 'o' &&
argv[i][8] == 'u' && argv[i][9] == 't' && argv[i][10] == '=')
{
if (isdigit ((int) argv[i][11]))
{
max_decisions = atoi (argv[i] + 11);
}
else
{
EXPECTED_DIGIT_FOR_MAX_DECISIONS_ARGUMENT:
fprintf (stderr,
"*** limmat: expected digit for max decisions argument\n");
exit (1);
}
}
else if (argv[i][0] == '-' && argv[i][1] == 't')
{
if (argv[i][2])
{
if (isdigit ((int) argv[i][2]))
{
time_out = atoi (argv[i] + 2);
}
else
goto EXPECTED_DIGIT_FOR_TIME_OUT_ARGUMENT;
}
else if (++i < argc && isdigit ((int) argv[i][0]))
{
time_out = atoi (argv[i]);
}
else
goto EXPECTED_DIGIT_FOR_TIME_OUT_ARGUMENT;
}
else
if (argv[i][0] == '-' &&
argv[i][1] == '-' &&
argv[i][2] == 't' &&
argv[i][3] == 'i' &&
argv[i][4] == 'm' &&
argv[i][5] == 'e' &&
argv[i][6] == '-' &&
argv[i][7] == 'o' &&
argv[i][8] == 'u' && argv[i][9] == 't' && argv[i][10] == '=')
{
if (isdigit ((int) argv[i][11]))
{
time_out = atoi (argv[i] + 11);
}
else
{
EXPECTED_DIGIT_FOR_TIME_OUT_ARGUMENT:
fprintf (stderr,
"*** limmat: expected digit for time out argument\n");
exit (1);
}
}
else if (argv[i][0] == '-')
{
fprintf (stderr,
"*** limmat: unknown command line option '%s' (try '-h')\n",
argv[i]);
exit (1);
}
else if (name)
{
multiple_files = 1;
}
else
name = argv[i];
}
if (multiple_files)
{
prefix = common_prefix (argv, argc);
suffix = common_suffix (argv, argc);
len_prefix = strlen (prefix);
len_suffix = strlen (suffix);
sparse = 1;
}
if (verbose)
sparse = 0;
if (pretty_print)
{
if (multiple_files)
{
fprintf (stderr,
"*** limmat: can not pretty print multiple files\n");
exit (1);
}
limmat = new_Limmat (0);
parse (name);
print_Limmat (limmat, stdout);
delete_Limmat (limmat);
res = ABNORMAL_EXIT_VALUE;
}
else
{
res = 0;
if (multiple_files)
{
for (i = 1; !res && i < argc; i++)
{
if (!skip_arg (argv, &i))
{
if ((pid = fork ()))
{
wait (&status);
if (WIFSIGNALED (status) ||
WEXITSTATUS (status) == ABNORMAL_EXIT_VALUE)
{
res = ABNORMAL_EXIT_VALUE;
}
}
else
child (argv[i], time_out, max_decisions);
}
}
}
else
child (name, time_out, max_decisions);
}
if (prefix)
free (prefix);
if (suffix)
free (suffix);
exit (res);
return res;
}
