bool
atf_check::run_output_check(const atf::check::check_result &r,
const std::string &stdxxx)
const
{
atf::fs::path path("/");
std::string arg;
output_check_t check = m_stdout_check;
if (stdxxx == "stdout") {
path = r.stdout_path();
arg = m_stdout_arg.c_str();
check = m_stdout_check;
} else if (stdxxx == "stderr") {
path = r.stderr_path();
arg = m_stderr_arg.c_str();
check = m_stderr_check;
} else
UNREACHABLE;
if (check == oc_empty) {
if (!file_empty(path)) {
std::cerr << "Fail: incorrect " << stdxxx << std::endl;
print_diff(atf::fs::path("/dev/null"), path);
return false;
}
} else if (check == oc_file) {
if (atf::io::cmp(path, atf::fs::path(arg)) != 0) {
std::cerr << "Fail: incorrect " << stdxxx << std::endl;
print_diff(atf::fs::path(arg), path);
return false;
}
} else if (check == oc_inline) {
std::string decoded = decode(arg);
atf::fs::path path2 = atf::fs::path(atf::config::get("atf_workdir")) \
/ "inline.XXXXXX";
atf::fs::temp_file temp(path2);
temp.write(decoded);
if (atf::io::cmp(path, temp.get_path()) != 0) {
std::cerr << "Fail: incorrect " << stdxxx << std::endl;
print_diff(temp.get_path(), path);
return false;
}
} else if (check == oc_save) {
std::ifstream ifs(path.c_str(), std::fstream::binary);
ifs >> std::noskipws;
std::istream_iterator< char > begin(ifs), end;
std::ofstream ofs(arg.c_str(), std::fstream::binary
| std::fstream::trunc);
std::ostream_iterator <char> obegin(ofs);
std::copy(begin, end, obegin);
}
int main(int argc, char **argv)
{
diff *d;
char **a, **b, *m;
size_t la, lb; /*lengths */
FILE *fa, *fb;
if (argc < 3)
return fprintf(stderr, "usage: %s file file\n", argv[0]);
fa = fopen_or_fail(argv[1], "r");
fb = fopen_or_fail(argv[2], "r");
a = fill_array_with_lines(fa, &la);
b = fill_array_with_lines(fb, &lb);
if (!(d = lcs(a, la, b, lb)))
return 0; /*empty files */
print_diff(d, a, b);
while ((m = *(a++)))
free(m);
while ((m = *(b++)))
free(m);
free(d->c);
free(d);
fclose(fa);
fclose(fb);
return 0;
}
static void
print_diff_now (struct mi_timestamp *start)
{
struct mi_timestamp now;
timestamp (&now);
print_diff (start, &now);
}
/*
* Xfrom-to (e.g. R10-15)
* A - change allowed
* S - change required, semantic
* R - change required, random
* F - change forbidden
*/
static enum df check(const char *range, unsigned char *o, unsigned char *n)
{
char strict;
unsigned long long from, to;
enum df ret;
if (sscanf(range, "%c%llu-%llu", &strict, &from, &to) != 3) {
printf("Unknown range format %s.\n", range);
return FAIL;
}
switch (toupper(strict)) {
case 'A':
ret = OK;
break;
case 'S':
ret = memcmp(&o[from], &n[from], to - from + 1) != 0 ? OK : FAIL;
break;
case 'R': /* FIXME - random test */
ret = memcmp(&o[from], &n[from], to - from + 1) != 0 ? OK : FAIL;
break;
case 'F':
ret = memcmp(&o[from], &n[from], to - from + 1) == 0 ? OK : FAIL;
break;
default:
ret = FAIL;
break;
}
if (ret == FAIL)
print_diff(from, to - from + 1, o, n);
return ret;
}
int main(int argc, char* argv[])
{
const size_t size = (argc > 1) ? atoi(argv[1]) : 32;
cmpvec inputData;
for (size_t i = 0; i < size; ++i) {
inputData.push_back(CMP(0.1 + i, 0.2 * i));
}
cmpvec bf;
ft_bf(size, inputData, bf);
if (0) {
cmpvec gsl;
ft_gsl(size, inputData, gsl);
print_diff(bf, gsl);
}
if(0) {
cmpvec fftw;
ft_fftw(size, inputData, fftw);
print_diff(bf, fftw);
}
if(0) {
cmpvec fftw_d;
const int isz = size;
ft_fftw_d(1, &isz, inputData, fftw_d);
print_diff(bf, fftw_d);
}
if(1) {
cmpvec fftw_d1;
const int sz1[] = { 3, 5 };
ft_fftw_d(2, &sz1[0], inputData, fftw_d1);
cmpvec fftw_d2;
const int sz2[] = { 5, 3 };
ft_fftw_d(2, &sz2[0], inputData, fftw_d2);
print_both(fftw_d1, fftw_d2);
}
return 0;
}
int main(int argc, char **argv) {
int opt, sprofdiff = 0;
#ifdef DEBUG
/* disable buffering so the output mixes correctly */
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
#endif
/* parse arguments */
while ((opt = getopt(argc, argv, "b:dp:s:")) != -1) {
switch (opt) {
case 'b':
/* additional binary specified */
binary_add(optarg);
break;
case 'd':
/* generate output for sprofdiff */
sprofdiff = 1;
break;
case 'p':
/* minimum percentage specified */
minimum_perc = atof(optarg);
if (minimum_perc < 0 || minimum_perc > 100) {
fprintf(stderr, "error: cut-off percentage "
"makes no sense: %g\n", minimum_perc);
exit(1);
}
break;
case 's':
/* source tree directory specified */
src_path = optarg;
break;
default: usage(argv[0]);
}
}
/* load samples */
if (optind >= argc) usage(argv[0]);
for (; optind < argc; optind++) {
struct endpoint_info *e;
load_trace(argv[optind]);
for(e = endpoints; e; e = e->next)
e->seen = 0;
}
/* print report */
if (sprofdiff) {
print_diff();
} else {
print_report();
}
return 0;
}
void print_error(string expected, string actual)
{
int expected_lines = std::count(expected.begin(), expected.end(), '\n');
int actual_lines = std::count(actual.begin(), actual.end(), '\n');
cerr << endl << "Did not get expected content" << endl << "expected (" << expected_lines << " lines): ->" << expected << "<-" << endl
<< "actual (" << actual_lines << " lines): ->" << actual << "<-" << endl;
cerr << endl;
print_diff(expected, actual);
}
int main(void)
{
size_t i,j;
diff *d;
d = lcs(x, y);
print_diff(d, x, y);
for(i = 0; i <= (d->m); i++) {
putchar('\n');
for(j = 0; j < d->n; j++)
printf("%d ", d->c[i*d->n+j]);
}
putchar('\n');
return 0;
}
int main(int argc, char const *argv[]) {
assert(argc == 3);
FILE *file1 = fopen(argv[1], "r");
FILE *file2 = fopen(argv[2], "r");
assert(file1 != NULL && file2 != NULL);
char file1_line[BUFFER_LINE_SIZE];
char file2_line[BUFFER_LINE_SIZE];
char *file1_line_ptr = file1_line;
char *file2_line_ptr = file2_line;
while (true) {
file1_line_ptr = fgets(file1_line, BUFFER_LINE_SIZE, file1);
file2_line_ptr = fgets(file2_line, BUFFER_LINE_SIZE, file2);
if (file1_line_ptr == NULL && file2_line_ptr == NULL) {
printf("Files are identical\n");
break;
} else if (file1_line_ptr == NULL) {
print_diff(argv[1], "", argv[2], file2_line);
break;
} else if (file2_line_ptr == NULL) {
print_diff(argv[1], file1_line, argv[2], "");
break;
} else if (strcmp(file1_line, file2_line) != 0) {
print_diff(argv[1], file1_line, argv[2], file2_line);
break;
}
}
fclose(file1);
fclose(file2);
return 0;
}
// Finally, the entry point for the PHP code.
const char *wikidiff_do_diff(const char *text1, const char *text2, int num_lines_context)
{
try {
std::vector<std::string> lines1;
std::vector<std::string> lines2;
std::string ret;
// constant reallocation is bad for performance (note: we might want to reduce this
// later, it might be too much)
ret.reserve(strlen(text1) + strlen(text2) + 10000);
line_explode(text1, lines1);
line_explode(text2, lines2);
print_diff(lines1, lines2, num_lines_context, ret);
return strdup(ret.c_str());
} catch (std::bad_alloc &e) {
return strdup("Out of memory in diff.");
} catch (...) {
return strdup("Unknown exception in diff.");
}
}
//diffs workdir and index - ie unstaged changes
//equivalent to `git diff` - WORKS
int diff(git_repository* repo) {
git_diff_list* diff;
git_index* index;
git_reference* ref_head;
git_commit* head;
git_tree* head_tree;
git_repository_index(&index, repo);
git_index_read(index);
git_repository_head(&ref_head, repo);
git_reference_peel((git_object**) &head, ref_head, GIT_OBJ_COMMIT);
git_commit_tree(&head_tree, head);
git_diff_index_to_workdir(&diff, repo, index, NULL);
print_diff(diff);
return 0;
}
/**
* The robot following/avoid a light infinitely
* @global _mode_light_ it must be set
*/
void go_light()
{
_go_light_running_ = 1;
while(_go_light_running_)
{
int diff;
diff = light_diff();
diff *= _light_environnement_; /* Go more efficiently to the light specifing the environnement */
/* Invert the mode */
if(_mode_light_ == GO_DARK)
{
diff= -diff;
}
print_diff(diff);
driveb(_motor_initial_speed_, diff);
}
stop();
_go_light_running_ = -1;
}
int main(int argc, char **argv) {
IDEAL* pp;
IDEAL** Ms;
IDEAL** Rads;
char M_name[MAX_LABEL_LENGTH];
char N_name[MAX_LABEL_LENGTH];
/* learn who we really are */
progname = (const char *)strrchr(argv[0], '/');
progname = progname ? (progname + 1) : argv[0];
/* handle cmdline */
handle_cmdline(&argc, &argv);
/* initializing needed things */
init_constants();
if ( !(i < numofMs) || !(j < nilindex) ) {
fprintf(stderr, "i must be less than numofMs = m*(pi - 1) + 1, "
"j must be less than nilindex = l*(p - 1) + 1.\n");
exit(EXIT_FAILURE);
}
/* we need at most 2 IDEALs per array */
Ms = (IDEAL**) malloc(2*sizeof(IDEAL*));
Rads = (IDEAL**) malloc(2*sizeof(IDEAL*));
if (Ms == NULL || Rads == NULL) {
fprintf(stderr, "Unable to allocate memory for ideals' arrays.\n");
exit(EXIT_FAILURE);
}
/* do the job */
if ((output_control & WAS_SPECIFIED_M) && (output_control & WAS_SPECIFIED_RAD)) {
/* both M_pi(m,i) and Rad^j were specified, process only them*/
pp = ideal_create(q);
ideal_init(pp, pi, m, i);
Ms[0] = pp;
pp = ideal_create(q);
ideal_init(pp, p, l, l*(p - 1) - j);
Rads[0] = pp;
sprintf(M_name, "M_%llu(%u,%llu)", pi, m, i);
sprintf(N_name, "Rad^%llu", j);
if (ideal_issubset(Rads[0], Ms[0])) {
print_diff(Ms[0], Ms[0], Rads[0], M_name, N_name, use_colors);
if (debug >= 2) {
fprintf(stdout, "%s\t\t=\n", N_name);
if (use_colors) {
color_ideal_print(SPECIAL_COLOR, Rads[0], isspecial_integer);
} else {
ideal_print(Rads[0]);
}
fprintf(stdout, "\n");
}
} else if (ideal_issubset(Ms[0], Rads[0])) {
print_diff(Rads[0], Rads[0], Ms[0], N_name, M_name, use_colors);
if (debug >= 2) {
fprintf(stdout, "%s\t\t=\n", M_name);
if (use_colors) {
color_ideal_print(SPECIAL_COLOR, Ms[0], isspecial_integer);
} else {
ideal_print(Ms[0]);
}
fprintf(stdout, "\n");
}
} else {
/* we will store intersection here */
pp = ideal_create(q);
Ms[1] = pp;
if (debug >= 2) {
fprintf(stdout, "%s\t\t=\n", M_name);
if (use_colors) {
color_ideal_print(SPECIAL_COLOR, Ms[0], isspecial_integer);
} else {
ideal_print(Ms[0]);
}
fprintf(stdout, "\n");
}
if (debug >= 2) {
fprintf(stdout, "%s\t\t=\n", N_name);
if (use_colors) {
color_ideal_print(SPECIAL_COLOR, Rads[0], isspecial_integer);
} else {
ideal_print(Rads[0]);
}
fprintf(stdout, "\n");
}
ideal_intersect(Ms[1], Ms[0], Rads[0]);
sprintf(N_name, "(M_%llu(%u,%llu) /\\ Rad^%llu)", pi, m, i, j);
sprintf(M_name, "M_%llu(%u,%llu)", pi, m, i);
print_diff(Ms[0], Ms[0], Ms[1], M_name, N_name, use_colors);
sprintf(M_name, "Rad^%llu", j);
print_diff(Rads[0], Rads[0], Ms[1], M_name, N_name, use_colors);
}
} else if (output_control & WAS_SPECIFIED_RAD) {
/* only Rad^j was specified, find sup and inf M_pi(m,k) and process all three of them */
unsigned long long Mpi_to_Rad, Rad_to_Mpi;
Rad_to_Mpi = maximum_Pi_for_P(l*(p - 1) - j, p, m);
Mpi_to_Rad = minimum_Pi_for_P(l*(p - 1) - j, p, m, lambda);
if (Mpi_to_Rad == Rad_to_Mpi) {
fprintf(stdout, "Rad^%llu == M_%llu(%u,%llu)\n\n",
j, pi, m, Rad_to_Mpi);
goto end;
}
pp = ideal_create(q);
ideal_init(pp, pi, m, Rad_to_Mpi);
Ms[0] = pp;
pp = ideal_create(q);
ideal_init(pp, pi, m, Mpi_to_Rad);
Ms[1] = pp;
pp = ideal_create(q);
ideal_init(pp, p, l, l*(p - 1) - j);
Rads[0] = pp;
fprintf(stdout, "M_%llu(%u,%llu) -> Rad^%llu -> M_%llu(%u,%llu)\n\n",
pi, m, Mpi_to_Rad, j, pi, m, Rad_to_Mpi);
sprintf(N_name, "Rad^%llu", j);
sprintf(M_name, "M_%llu(%u,%llu)", pi, m, Mpi_to_Rad);
print_diff(Ms[1], Ms[1], Rads[0], M_name, N_name, use_colors);
sprintf(M_name, "M_%llu(%u,%llu)", pi, m, Rad_to_Mpi);
print_diff(Ms[0], Rads[0], Ms[0], N_name, M_name, use_colors);
if (debug >= 2) {
fprintf(stdout, "%s\t\t=\n", N_name);
if (use_colors) {
color_ideal_print(SPECIAL_COLOR, Rads[0], isspecial_integer);
} else {
ideal_print(Rads[0]);
}
fprintf(stdout, "\n");
}
} else if (output_control & WAS_SPECIFIED_M) {
/* only M_pi(m,i) was specified, find sup and inf Rad^j and process all three of them */
unsigned long long Mpi_to_Rad, Rad_to_Mpi;
Rad_to_Mpi = minimum_P_for_Pi(i, p, m);
Mpi_to_Rad = maximum_P_for_Pi(i, p, m, l, lambda, numofMs - 1);
if (Mpi_to_Rad == Rad_to_Mpi) {
fprintf(stdout, "M_%llu(%u,%llu) == Rad^%llu\n\n",
pi, m, i, l*(p - 1) - Rad_to_Mpi);
goto end;
}
pp = ideal_create(q);
ideal_init(pp, p, l, Mpi_to_Rad);
Rads[0] = pp;
pp = ideal_create(q);
ideal_init(pp, p, l, Rad_to_Mpi);
Rads[1] = pp;
pp = ideal_create(q);
ideal_init(pp, pi, m, i);
Ms[0] = pp;
fprintf(stdout, "Rad^%llu -> M_%llu(%u,%llu) -> Rad^%llu\n\n",
l*(p - 1) - Rad_to_Mpi, pi, m, i, l*(p - 1) - Mpi_to_Rad);
sprintf(M_name, "M_%llu(%u,%llu)", pi, m, i);
sprintf(N_name, "Rad^%llu", l*(p - 1) - Rad_to_Mpi);
print_diff(Rads[1], Rads[1], Ms[0], N_name, M_name, use_colors);
sprintf(N_name, "Rad^%llu", l*(p - 1) - Mpi_to_Rad);
print_diff(Rads[0], Ms[0], Rads[0], M_name, N_name, use_colors);
if (debug >= 2) {
fprintf(stdout, "%s\t\t=\n", M_name);
if (use_colors) {
color_ideal_print(SPECIAL_COLOR, Ms[0], isspecial_integer);
} else {
ideal_print(Ms[0]);
}
fprintf(stdout, "\n");
}
} else {
fprintf(stderr, "Incorrect usage. See --help.\n");
}
end:
/* do cleanup */
dbg_msg_l(5, "Freeing Ms...\n");
for (i = 0; i < 2; ++i) {
ideal_free(Ms[i]);
}
free(Ms);
dbg_msg_l(5, "Freeing Rads...\n");
for (i = 0; i < 2; ++i) {
ideal_free(Rads[i]);
}
free(Rads);
return 0;
}
static int compare_files(const char *inp, const char *out, const char *output_prefix) {
struct stat st_in, st_out;
int ret = 0;
if (lstat(inp, &st_in)) {
perror("lstat(INPUT) failed");
return 2;
}
if (lstat(out, &st_out)) {
perror("lstat(OUTPUT) failed");
return 2;
}
if (st_in.st_size != st_out.st_size) {
print_diff(output_prefix, "Size differs",
st_in.st_size, st_out.st_size);
ret = 1;
}
if (st_in.st_size > 0) {
if (S_ISREG(st_in.st_mode)) {
FILE *f = fopen(out, "rb");
char buf[sizeof(randumness)];
if (!f) {
perror("Unable to open output file for reading");
ret = 2;
} else {
if (fread(buf, sizeof(buf), 1, f) != 1) {
perror("Output file read failed");
ret = 2;
} else if (memcmp(buf, randumness, sizeof(buf))) {
fprintf(stderr, "[%s] File contents differ\n",
output_prefix);
ret = 1;
}
fclose(f);
}
} else if (S_ISLNK(st_in.st_mode)) {
char buf[sizeof(ex_linkdest)];
switch (readlink(out, buf, sizeof(buf))) {
case -1:
perror("readlink(OUTPUT) failed");
ret = 2;
break;
case sizeof(buf) - 1:
if (memcmp(buf, ex_linkdest, sizeof(buf))) {
buf[sizeof(buf) - 1] = 0;
fprintf(stderr, "[%s] Symlink target differs: %s vs %s\n",
output_prefix, ex_linkdest, buf);
ret = 1;
}
break;
default:
fprintf(stderr, "[%s] Invalid length when getting symlink target\n",
output_prefix);
}
} else {
fprintf(stderr, "[%s] Unhandled non-empty file format\n",
output_prefix);
ret = 77;
}
}
#ifdef S_ISCHR
if (S_ISCHR(st_in.st_mode) && st_in.st_rdev != st_out.st_rdev) {
print_diff_x(output_prefix, "Character device rdev differs",
st_in.st_rdev, st_out.st_rdev);
ret = 1;
}
#endif
#ifdef S_ISBLK
if (S_ISBLK(st_in.st_mode) && st_in.st_rdev != st_out.st_rdev) {
print_diff_x(output_prefix, "Block device rdev differs",
st_in.st_rdev, st_out.st_rdev);
ret = 1;
}
#endif
if (st_in.st_mode != st_out.st_mode) {
print_diff_x(output_prefix, "Mode differs",
st_in.st_mode, st_out.st_mode);
ret = 1;
}
if (st_in.st_uid != st_out.st_uid) {
print_diff(output_prefix, "UID differs",
st_in.st_uid, st_out.st_uid);
ret = 1;
}
if (st_in.st_gid != st_out.st_gid) {
print_diff(output_prefix, "GID differs",
st_in.st_gid, st_out.st_gid);
ret = 1;
}
if (st_in.st_mtime != st_out.st_mtime) {
print_diff(output_prefix, "mtime (in seconds) differs",
st_in.st_mtime, st_out.st_mtime);
ret = 1;
}
return ret;
}
int print_gpios(struct pci_dev *sb, int show_all, int show_diffs)
{
int i, j, size, defaults_size = 0;
const io_register_t *gpio_registers;
const gpio_default_t *gpio_defaults = NULL;
uint32_t gpio_diff;
if (show_diffs && !show_all)
printf("\n========== GPIO DIFFS ===========\n\n");
else
printf("\n============= GPIOS =============\n\n");
switch (sb->device_id) {
case PCI_DEVICE_ID_INTEL_Z68:
case PCI_DEVICE_ID_INTEL_P67:
case PCI_DEVICE_ID_INTEL_H67:
case PCI_DEVICE_ID_INTEL_Q65:
case PCI_DEVICE_ID_INTEL_QS67:
case PCI_DEVICE_ID_INTEL_Q67:
case PCI_DEVICE_ID_INTEL_B65:
case PCI_DEVICE_ID_INTEL_C202:
case PCI_DEVICE_ID_INTEL_C204:
case PCI_DEVICE_ID_INTEL_C206:
case PCI_DEVICE_ID_INTEL_H61:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = pch_gpio_registers;
size = ARRAY_SIZE(pch_gpio_registers);
gpio_defaults = cp_pch_desktop_defaults;
defaults_size = ARRAY_SIZE(cp_pch_desktop_defaults);
break;
case PCI_DEVICE_ID_INTEL_UM67:
case PCI_DEVICE_ID_INTEL_HM65:
case PCI_DEVICE_ID_INTEL_HM67:
case PCI_DEVICE_ID_INTEL_QM67:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = pch_gpio_registers;
size = ARRAY_SIZE(pch_gpio_registers);
gpio_defaults = cp_pch_mobile_defaults;
defaults_size = ARRAY_SIZE(cp_pch_mobile_defaults);
break;
case PCI_DEVICE_ID_INTEL_Z77:
case PCI_DEVICE_ID_INTEL_Z75:
case PCI_DEVICE_ID_INTEL_Q77:
case PCI_DEVICE_ID_INTEL_Q75:
case PCI_DEVICE_ID_INTEL_B75:
case PCI_DEVICE_ID_INTEL_H77:
case PCI_DEVICE_ID_INTEL_C216:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = pch_gpio_registers;
size = ARRAY_SIZE(pch_gpio_registers);
gpio_defaults = pp_pch_desktop_defaults;
defaults_size = ARRAY_SIZE(pp_pch_desktop_defaults);
break;
case PCI_DEVICE_ID_INTEL_QM77:
case PCI_DEVICE_ID_INTEL_QS77:
case PCI_DEVICE_ID_INTEL_HM77:
case PCI_DEVICE_ID_INTEL_UM77:
case PCI_DEVICE_ID_INTEL_HM76:
case PCI_DEVICE_ID_INTEL_HM75:
case PCI_DEVICE_ID_INTEL_HM70:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = pch_gpio_registers;
size = ARRAY_SIZE(pch_gpio_registers);
gpio_defaults = pp_pch_mobile_defaults;
defaults_size = ARRAY_SIZE(pp_pch_mobile_defaults);
break;
case PCI_DEVICE_ID_INTEL_ICH10R:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = ich10_gpio_registers;
size = ARRAY_SIZE(ich10_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_ICH9DH:
case PCI_DEVICE_ID_INTEL_ICH9DO:
case PCI_DEVICE_ID_INTEL_ICH9R:
case PCI_DEVICE_ID_INTEL_ICH9:
case PCI_DEVICE_ID_INTEL_ICH9M:
case PCI_DEVICE_ID_INTEL_ICH9ME:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = ich9_gpio_registers;
size = ARRAY_SIZE(ich9_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_ICH8:
case PCI_DEVICE_ID_INTEL_ICH8M:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = ich8_gpio_registers;
size = ARRAY_SIZE(ich8_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_ICH7:
case PCI_DEVICE_ID_INTEL_ICH7M:
case PCI_DEVICE_ID_INTEL_ICH7DH:
case PCI_DEVICE_ID_INTEL_ICH7MDH:
case PCI_DEVICE_ID_INTEL_NM10:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = ich7_gpio_registers;
size = ARRAY_SIZE(ich7_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_ICH6:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = ich6_gpio_registers;
size = ARRAY_SIZE(ich6_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_ICH5:
gpiobase = pci_read_word(sb, 0x58) & 0xfffc;
gpio_registers = ich5_gpio_registers;
size = ARRAY_SIZE(ich5_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_ICH4:
case PCI_DEVICE_ID_INTEL_ICH4M:
gpiobase = pci_read_word(sb, 0x58) & 0xfffc;
gpio_registers = ich4_gpio_registers;
size = ARRAY_SIZE(ich4_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_ICH2:
gpiobase = pci_read_word(sb, 0x58) & 0xfffc;
gpio_registers = ich2_gpio_registers;
size = ARRAY_SIZE(ich2_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_ICH:
case PCI_DEVICE_ID_INTEL_ICH0:
gpiobase = pci_read_word(sb, 0x58) & 0xfffc;
gpio_registers = ich0_gpio_registers;
size = ARRAY_SIZE(ich0_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_I63XX:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = i631x_gpio_registers;
size = ARRAY_SIZE(i631x_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_3400_DESKTOP:
case PCI_DEVICE_ID_INTEL_3400_MOBILE:
case PCI_DEVICE_ID_INTEL_P55:
case PCI_DEVICE_ID_INTEL_PM55:
case PCI_DEVICE_ID_INTEL_H55:
case PCI_DEVICE_ID_INTEL_QM57:
case PCI_DEVICE_ID_INTEL_H57:
case PCI_DEVICE_ID_INTEL_HM55:
case PCI_DEVICE_ID_INTEL_Q57:
case PCI_DEVICE_ID_INTEL_HM57:
case PCI_DEVICE_ID_INTEL_3400_MOBILE_SFF:
case PCI_DEVICE_ID_INTEL_B55_A:
case PCI_DEVICE_ID_INTEL_QS57:
case PCI_DEVICE_ID_INTEL_3400:
case PCI_DEVICE_ID_INTEL_3420:
case PCI_DEVICE_ID_INTEL_3450:
case PCI_DEVICE_ID_INTEL_B55_B:
gpiobase = pci_read_word(sb, 0x48) & 0xfffc;
gpio_registers = i631x_gpio_registers;
size = ARRAY_SIZE(i631x_gpio_registers);
break;
case PCI_DEVICE_ID_INTEL_82371XX:
printf("This southbridge has GPIOs in the PM unit.\n");
return 1;
case 0x1234: // Dummy for non-existent functionality
printf("This southbridge does not have GPIOBASE.\n");
return 1;
default:
printf("Error: Dumping GPIOs on this southbridge is not (yet) supported.\n");
return 1;
}
printf("GPIOBASE = 0x%04x (IO)\n\n", gpiobase);
j = 0;
for (i = 0; i < size; i++) {
if (show_all)
print_reg(&gpio_registers[i]);
if (show_diffs &&
(j < defaults_size) &&
(gpio_defaults[j].addr == gpio_registers[i].addr)) {
gpio_diff = get_diff(&gpio_registers[i],
gpio_defaults[j].def);
if (gpio_diff) {
if (!show_all)
print_reg(&gpio_registers[i]);
print_diff(&gpio_registers[i],
gpio_defaults[j].def, gpio_diff);
if (!show_all)
printf("\n");
}
j++;
}
}
return 0;
}
static void
captured_mi_execute_command (struct ui_out *uiout, void *data)
{
struct captured_mi_execute_command_args *args =
(struct captured_mi_execute_command_args *) data;
struct mi_parse *context = args->command;
struct mi_timestamp cmd_finished;
switch (context->op)
{
case MI_COMMAND:
/* A MI command was read from the input stream. */
if (mi_debug_p)
/* FIXME: gdb_???? */
fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
context->token, context->command, context->args);
/* FIXME: cagney/1999-09-25: Rather than this convoluted
condition expression, each function should return an
indication of what action is required and then switch on
that. */
args->action = EXECUTE_COMMAND_DISPLAY_PROMPT;
if (do_timings)
current_command_ts = context->cmd_start;
args->rc = mi_cmd_execute (context);
if (do_timings)
timestamp (&cmd_finished);
if (!target_can_async_p () || !target_executing)
{
/* Print the result if there were no errors.
Remember that on the way out of executing a command, you have
to directly use the mi_interp's uiout, since the command could
have reset the interpreter, in which case the current uiout
will most likely crash in the mi_out_* routines. */
if (args->rc == MI_CMD_DONE)
{
fputs_unfiltered (context->token, raw_stdout);
fputs_unfiltered ("^done", raw_stdout);
mi_out_put (uiout, raw_stdout);
mi_out_rewind (uiout);
/* Have to check cmd_start, since the command could be
-enable-timings. */
if (do_timings && context->cmd_start)
print_diff (context->cmd_start, &cmd_finished);
fputs_unfiltered ("\n", raw_stdout);
}
else if (args->rc == MI_CMD_ERROR)
{
if (mi_error_message)
{
fputs_unfiltered (context->token, raw_stdout);
fputs_unfiltered ("^error,msg=\"", raw_stdout);
fputstr_unfiltered (mi_error_message, '"', raw_stdout);
xfree (mi_error_message);
mi_error_message = NULL;
fputs_unfiltered ("\"\n", raw_stdout);
}
mi_out_rewind (uiout);
}
else
mi_out_rewind (uiout);
}
else if (sync_execution)
{
/* Don't print the prompt. We are executing the target in
synchronous mode. */
args->action = EXECUTE_COMMAND_SUPRESS_PROMPT;
return;
}
break;
case CLI_COMMAND:
{
char *argv[2];
/* A CLI command was read from the input stream. */
/* This "feature" will be removed as soon as we have a
complete set of mi commands. */
/* Echo the command on the console. */
fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
/* Call the "console" interpreter. */
argv[0] = "console";
argv[1] = context->command;
args->rc = mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
/* If we changed interpreters, DON'T print out anything. */
if (current_interp_named_p (INTERP_MI)
|| current_interp_named_p (INTERP_MI1)
|| current_interp_named_p (INTERP_MI2)
|| current_interp_named_p (INTERP_MI3))
{
if (args->rc == MI_CMD_DONE)
{
fputs_unfiltered (context->token, raw_stdout);
fputs_unfiltered ("^done", raw_stdout);
mi_out_put (uiout, raw_stdout);
mi_out_rewind (uiout);
fputs_unfiltered ("\n", raw_stdout);
args->action = EXECUTE_COMMAND_DISPLAY_PROMPT;
}
else if (args->rc == MI_CMD_ERROR)
{
if (mi_error_message)
{
fputs_unfiltered (context->token, raw_stdout);
fputs_unfiltered ("^error,msg=\"", raw_stdout);
fputstr_unfiltered (mi_error_message, '"', raw_stdout);
xfree (mi_error_message);
mi_error_message = NULL;
fputs_unfiltered ("\"\n", raw_stdout);
}
mi_out_rewind (uiout);
}
else
mi_out_rewind (uiout);
}
break;
}
}
return;
}
/*
* verify_license -- compare 'license' with 'pattern' and check correctness
* of the copyright line
*/
static int
verify_license(const char *path_to_check, char *pattern, const char *filename)
{
char buffer[LICENSE_MAX_LEN];
char *license, *copyright;
int file_to_check;
ssize_t ret;
int year_first, year_last;
int min_year_first = YEAR_INIT_MIN;
int max_year_last = YEAR_INIT_MAX;
char *err_str = NULL;
const char *name_to_print = filename ? filename : path_to_check;
if ((file_to_check = open(path_to_check, O_RDONLY)) == -1) {
ERROR("open(): %s: %s", strerror(errno), path_to_check);
return -1;
}
memset(buffer, 0, sizeof(buffer));
ret = read(file_to_check, buffer, LICENSE_MAX_LEN);
close(file_to_check);
if (ret == -1) {
ERROR("read(): %s: %s", strerror(errno), name_to_print);
return -1;
}
if (analyze_license(path_to_check, buffer, &license) == -1)
return -1;
/* check the copyright notice */
copyright = buffer;
while ((copyright = strstr(copyright, COPYRIGHT)) != NULL) {
copyright += COPYRIGHT_LEN;
/* skip the copyright symbol '(c)' if any */
if (strncmp(copyright, COPYRIGHT_SYMBOL,
COPYRIGHT_SYMBOL_LEN) == 0)
copyright += COPYRIGHT_SYMBOL_LEN;
/* look for the first year */
if (!isdigit(*copyright)) {
err_str = "no digit just after the 'Copyright ' string";
break;
}
year_first = atoi(copyright);
if (year_first < YEAR_MIN || year_first > YEAR_MAX) {
err_str = "the first year is wrong";
break;
}
copyright += YEAR_LEN;
if (year_first < min_year_first)
min_year_first = year_first;
if (year_first > max_year_last)
max_year_last = year_first;
/* check if there is the second year */
if (*copyright == ',')
continue;
else if (*copyright != '-') {
err_str = "'-' or ',' expected after the first year";
break;
}
copyright++;
/* look for the second year */
if (!isdigit(*copyright)) {
err_str = "no digit after '-'";
break;
}
year_last = atoi(copyright);
if (year_last < YEAR_MIN || year_last > YEAR_MAX) {
err_str = "the second year is wrong";
break;
}
copyright += YEAR_LEN;
if (year_last > max_year_last)
max_year_last = year_last;
if (*copyright != ',') {
err_str = "',' expected after the second year";
break;
}
}
if (!err_str && min_year_first == YEAR_INIT_MIN)
err_str = "no 'Copyright ' string found";
if (err_str)
/* found an error in the copyright notice */
ERROR2("%s:1: error: incorrect copyright notice: %s",
name_to_print, err_str);
/* now check the license */
if (memcmp(license, pattern, strlen(pattern)) != 0) {
ERROR2("%s:1: error: incorrect license", name_to_print);
print_diff(license, pattern, strlen(pattern));
return -1;
}
if (err_str)
return -1;
/* all checks passed */
if (min_year_first != max_year_last && max_year_last != YEAR_INIT_MAX) {
printf("%i-%i\n", min_year_first, max_year_last);
} else {
printf("%i\n", min_year_first);
}
return 0;
}
/**
* This is the customized diff program designed to compare grf files.
*/
int main_GrfDiff(int argc,char* const argv[]) {
if (argc==1) {
usage();
return SUCCESS_RETURN_CODE;
}
VersatileEncodingConfig vec=VEC_DEFAULT;
int val,index=-1;
char output[FILENAME_MAX]="";
bool only_verify_arguments = false;
UnitexGetOpt options;
while (EOF!=(val=options.parse_long(argc,argv,optstring_GrfDiff,lopts_GrfDiff,&index))) {
switch(val) {
case 'V': only_verify_arguments = true;
break;
case 'h': usage();
return SUCCESS_RETURN_CODE;
case 1: {
strcpy(output,options.vars()->optarg);
break;
}
case 'k': if (options.vars()->optarg[0]=='\0') {
error("Empty input_encoding argument\n");
return USAGE_ERROR_CODE;
}
decode_reading_encoding_parameter(&(vec.mask_encoding_compatibility_input),options.vars()->optarg);
break;
case 'q': if (options.vars()->optarg[0]=='\0') {
error("Empty output_encoding argument\n");
return USAGE_ERROR_CODE;
}
decode_writing_encoding_parameter(&(vec.encoding_output),&(vec.bom_output),options.vars()->optarg);
break;
case ':': index==-1 ? error("Missing argument for option -%c\n",options.vars()->optopt) :
error("Missing argument for option --%s\n",lopts_GrfDiff[index].name);
return USAGE_ERROR_CODE;
case '?': index==-1 ? error("Invalid option -%c\n",options.vars()->optopt) :
error("Invalid option --%s\n",options.vars()->optarg);
return USAGE_ERROR_CODE;
}
index=-1;
}
if (options.vars()->optind!=argc-2) {
error("Invalid arguments: rerun with --help\n");
return USAGE_ERROR_CODE;
}
if (only_verify_arguments) {
// freeing all allocated memory
return SUCCESS_RETURN_CODE;
}
U_FILE* f=U_STDOUT;
if (output[0]!='\0') {
/* Since the output is supposed to be a diff-like one, there is no point
* in outputing in a variable encoding, so we force UTF8 */
f=u_fopen(UTF8,output,U_WRITE);
if (f==NULL) {
error("Cannot create file %s\n",output);
return DEFAULT_ERROR_CODE;
}
}
Grf* a=load_Grf(&vec,argv[options.vars()->optind]);
if (a==NULL) {
if (f!=U_STDOUT) {
u_fclose(f);
}
return DEFAULT_ERROR_CODE;
}
Grf* b=load_Grf(&vec,argv[options.vars()->optind+1]);
if (b==NULL) {
free_Grf(a);
if (f!=U_STDOUT) {
u_fclose(f);
}
return DEFAULT_ERROR_CODE;
}
GrfDiff* diff=grf_diff(a,b);
free_Grf(a);
free_Grf(b);
print_diff(f,diff);
if (f!=U_STDOUT) {
u_fclose(f);
}
int different=diff->diff_ops->nbelems!=0;
free_GrfDiff(diff);
return different;
}
int main(int argc, char **argv) {
int i,j;
int initial,fixup,spec2k6,legend;
int num_benchmarks;
char temp_input[BUFSIZ];
parse_command_line(argc,argv,
&num_runs,&initial,
&legend,&spec2k6,&num_benchmarks);
if (initial) fixup=FIXUP_NONE;
else fixup=FIXUP_ALL;
machines=spec2k_machines;
printf("\\begin{table*}[tbp]\n");
printf("\\begin{sf}\n");
printf("\\begin{scriptsize}\n");
printf("\\begin{center}\n");
printf("\\begin{tabular}{|l||r||r|r|r||");
for(i=0;i<REAL_MACHINES;i++) {
if (!(!machines[i].is_spec2k6&&spec2k6)) {
printf("r|");
}
}
printf("}\n");
printf("\\hline\n");
printf("Benchmark & ");
printf("\\parbox[b]{1.2cm}{\\flushright Overall\\\\Standard\\\\Deviation\\\\(mean)} & ");
printf("\\begin{sideways}\\parbox{2cm}{Pin}\\end{sideways} &");
printf("\\begin{sideways}\\parbox{2cm}{Qemu}\\end{sideways} &");
printf("\\begin{sideways}\\parbox{2cm}{Valgrind}\\end{sideways} ");
for(i=0;i<REAL_MACHINES;i++) {
if (!(!machines[i].is_spec2k6&&spec2k6)) {
printf("& ");
printf("\\begin{sideways}\\parbox{2cm}{");
printf("%s",machines[i].processor2);
printf("\\\\%s",machines[i].processor1);
printf("}\\end{sideways} ");
}
}
printf("\\\\\n");
printf("\\hline\n");
our_stats=calloc(sizeof(struct stats),num_benchmarks);
for(j=0;j<num_benchmarks;j++) {
load_stats(num_runs,spec2k6,our_stats,argv[(j*2)+BENCH_START],
argv[(j*2)+BENCH_START+1],argv[TREE_ARG],j,fixup);
}
for(j=0;j<num_benchmarks;j++) {
if (!strcmp("makerand",argv[(j*2)+BENCH_START+1])) {
strcpy(temp_input,"mkrnd");
}
else if (!strcmp("default",argv[(j*2)+BENCH_START+1])) {
strcpy(temp_input," ");
}
else if (!strcmp("foreman_baseline",argv[(j*2)+BENCH_START+1])) {
strcpy(temp_input,"forebase");
}
else if (!strcmp("foreman_main",argv[(j*2)+BENCH_START+1])) {
strcpy(temp_input,"foremain");
}
else if (!strcmp("sss_main",argv[(j*2)+BENCH_START+1])) {
strcpy(temp_input,"sss");
}
else {
strcpy(temp_input,argv[(j*2)+BENCH_START+1]);
}
printf("%s %s &",argv[(j*2)+BENCH_START],temp_input);
/* mean */
print_diff((long long)(our_stats[j].bench_stdev),LO,MID,HI);
//print_commas( (long long)(our_stats[j].bench_stdev));
printf(" & ");
/* PIN */
if (!our_stats[j].machine_mean_valid[PIN]) {
print_blank();
}
else {
print_diff((long long)(our_stats[j].machine_stdev[PIN]),LO,MID,HI);
print_num_points(our_stats[j].num_points[PIN]);
}
printf(" & ");
/* QEMU */
if (!our_stats[j].machine_mean_valid[QEMU]) {
print_blank();
}
else {
print_diff((long long)(our_stats[j].machine_stdev[QEMU]),LO,MID,HI);
print_num_points(our_stats[j].num_points[QEMU]);
}
printf(" & ");
if (!our_stats[j].machine_mean_valid[VALGRIND]) {
print_blank();
}
else {
print_diff((long long)(our_stats[j].machine_stdev[VALGRIND]),LO,MID,HI);
print_num_points(our_stats[j].num_points[VALGRIND]);
}
for(i=0;i<REAL_MACHINES;i++) {
if (!(!machines[i].is_spec2k6&&spec2k6)) {
printf(" & ");
if (!our_stats[j].machine_mean_valid[i]) {
print_blank();
} else {
print_diff((long long)(our_stats[j].machine_stdev[i]),LO,MID,HI);
print_num_points(our_stats[j].num_points[i]);
}
}
}
printf("\\\\\n");
if (j%5==4) printf("\\hline\n");
}
printf("\\hline\n");
printf("\\end{tabular}\n");
printf("\\end{center}\n");
return 0;
}
static
bool
run_output_check(const output_check oc, const atf::fs::path& path,
const std::string& stdxxx)
{
bool result;
if (oc.type == oc_empty) {
const bool is_empty = file_empty(path);
if (!oc.negated && !is_empty) {
std::cerr << "Fail: " << stdxxx << " not empty\n";
print_diff(atf::fs::path("/dev/null"), path);
result = false;
} else if (oc.negated && is_empty) {
std::cerr << "Fail: " << stdxxx << " is empty\n";
result = false;
} else
result = true;
} else if (oc.type == oc_file) {
const bool equals = compare_files(path, atf::fs::path(oc.value));
if (!oc.negated && !equals) {
std::cerr << "Fail: " << stdxxx << " does not match golden "
"output\n";
print_diff(atf::fs::path(oc.value), path);
result = false;
} else if (oc.negated && equals) {
std::cerr << "Fail: " << stdxxx << " matches golden output\n";
cat_file(atf::fs::path(oc.value));
result = false;
} else
result = true;
} else if (oc.type == oc_ignore) {
result = true;
} else if (oc.type == oc_inline) {
atf::fs::path path2 = atf::fs::path(atf::config::get("atf_workdir"))
/ "inline.XXXXXX";
temp_file temp(path2);
temp.write(decode(oc.value));
temp.close();
const bool equals = compare_files(path, temp.get_path());
if (!oc.negated && !equals) {
std::cerr << "Fail: " << stdxxx << " does not match expected "
"value\n";
print_diff(temp.get_path(), path);
result = false;
} else if (oc.negated && equals) {
std::cerr << "Fail: " << stdxxx << " matches expected value\n";
cat_file(temp.get_path());
result = false;
} else
result = true;
} else if (oc.type == oc_match) {
const bool matches = grep_file(path, oc.value);
if (!oc.negated && !matches) {
std::cerr << "Fail: regexp " + oc.value + " not in " << stdxxx
<< "\n";
cat_file(path);
result = false;
} else if (oc.negated && matches) {
std::cerr << "Fail: regexp " + oc.value + " is in " << stdxxx
<< "\n";
cat_file(path);
result = false;
} else
result = true;
} else if (oc.type == oc_save) {
INV(!oc.negated);
std::ifstream ifs(path.c_str(), std::fstream::binary);
ifs >> std::noskipws;
std::istream_iterator< char > begin(ifs), end;
std::ofstream ofs(oc.value.c_str(), std::fstream::binary
| std::fstream::trunc);
std::ostream_iterator <char> obegin(ofs);
std::copy(begin, end, obegin);
result = true;
} else {