int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len)
{
ssize_t read_size = 0;
size_t alloc_len;
git_buf_clear(buf);
if (!git__is_ssizet(len)) {
giterr_set(GITERR_INVALID, "read too large");
return -1;
}
GITERR_CHECK_ALLOC_ADD(&alloc_len, len, 1);
if (git_buf_grow(buf, alloc_len) < 0)
return -1;
/* p_read loops internally to read len bytes */
read_size = p_read(fd, buf->ptr, len);
if (read_size != (ssize_t)len) {
giterr_set(GITERR_OS, "failed to read descriptor");
git_buf_free(buf);
return -1;
}
buf->ptr[read_size] = '\0';
buf->size = read_size;
return 0;
}
static int read_header_loose(git_rawobj *out, git_buf *loc)
{
unsigned char obj[1024];
int fd, obj_len, error;
assert(out && loc);
if (git_buf_oom(loc))
return -1;
out->data = NULL;
if ((error = fd = git_futils_open_ro(loc->ptr)) < 0 ||
(error = obj_len = p_read(fd, obj, sizeof(obj))) < 0)
goto done;
if (!is_zlib_compressed_data(obj, (size_t)obj_len))
error = read_header_loose_packlike(out, obj, (size_t)obj_len);
else
error = read_header_loose_standard(out, obj, (size_t)obj_len);
if (!error && !git_object_typeisloose(out->type)) {
giterr_set(GITERR_ZLIB, "failed to read loose object header");
error = -1;
goto done;
}
done:
if (fd >= 0)
p_close(fd);
return error;
}
void *print_message_function( void *ptr)
{
char *message;
int i;
//pthread_mutex_lock( &mutex1 ); //for "race condition" no mutex condition
//sleep(1);
message = (char *) ptr;
printf("print_message function \"%s\"\n%lu\n", message, pthread_self());
//p_read("/dev/driver_open0");
p_write("/dev/driver_open0", message);
//sleep(1);
usleep(1);
p_read("/dev/driver_open0");
//pthread_mutex_unlock( &mutex1 ); //for "race condition"
pthread_exit(0);
printf("exit pthread \"%s\"------------\n", message);
}
static int write_file_stream(
git_oid *oid, git_odb *odb, const char *path, git_off_t file_size)
{
int fd, error;
char buffer[4096];
git_odb_stream *stream = NULL;
ssize_t read_len = -1, written = 0;
if ((error = git_odb_open_wstream(
&stream, odb, (size_t)file_size, GIT_OBJ_BLOB)) < 0)
return error;
if ((fd = git_futils_open_ro(path)) < 0) {
git_odb_stream_free(stream);
return -1;
}
while (!error && (read_len = p_read(fd, buffer, sizeof(buffer))) > 0) {
error = git_odb_stream_write(stream, buffer, read_len);
written += read_len;
}
p_close(fd);
if (written != file_size || read_len < 0) {
giterr_set(GITERR_OS, "Failed to read file into stream");
error = -1;
}
if (!error)
error = git_odb_stream_finalize_write(oid, stream);
git_odb_stream_free(stream);
return error;
}
int git_futils_readbuffer_updated(git_fbuffer *obj, const char *path, time_t *mtime, int *updated)
{
git_file fd;
size_t len;
struct stat st;
unsigned char *buff;
assert(obj && path && *path);
if (updated != NULL)
*updated = 0;
if (p_stat(path, &st) < 0)
return git__throw(GIT_ENOTFOUND, "Failed to stat file %s", path);
if (S_ISDIR(st.st_mode))
return git__throw(GIT_ERROR, "Can't read a dir into a buffer");
/*
* If we were given a time, we only want to read the file if it
* has been modified.
*/
if (mtime != NULL && *mtime >= st.st_mtime)
return GIT_SUCCESS;
if (mtime != NULL)
*mtime = st.st_mtime;
if (!git__is_sizet(st.st_size+1))
return git__throw(GIT_ERROR, "Failed to read file `%s`. An error occured while calculating its size", path);
len = (size_t) st.st_size;
if ((fd = p_open(path, O_RDONLY)) < 0)
return git__throw(GIT_EOSERR, "Failed to open %s for reading", path);
if ((buff = git__malloc(len + 1)) == NULL) {
p_close(fd);
return GIT_ENOMEM;
}
if (p_read(fd, buff, len) < 0) {
p_close(fd);
free(buff);
return git__throw(GIT_ERROR, "Failed to read file `%s`", path);
}
buff[len] = '\0';
p_close(fd);
if (mtime != NULL)
*mtime = st.st_mtime;
if (updated != NULL)
*updated = 1;
obj->data = buff;
obj->len = len;
return GIT_SUCCESS;
}
static ssize_t p_read_idxb(struct file* filp, char* buf, size_t count, loff_t* f_pos)
{
loff_t pos = ((pipes[1].ct)[CONTEXT]).bpos + (*f_pos);
ssize_t ret = p_read(1, filp, buf, count, &pos);
*f_pos = pos - ((pipes[1].ct)[CONTEXT]).bpos;
return ret;
}
int main(int argc, char * argv[]) {
FILE * f_in = fopen(argv[1], "r");
process p_arr[20];
int i = 0;
p_arr[i] = p_read(f_in);
while (p_arr[i].delay != -1) {
i++;
p_arr[i] = p_read(f_in);
}
const int com_num = i;
for (int j = 0; j < com_num; j++) {
for (int i = 0; i < com_num - 1 - j; i++) {
if (p_arr[i].delay > p_arr[i + 1].delay) {
process swap = p_arr[i + 1];
p_arr[i + 1] = p_arr[i];
p_arr[i] = swap;
}
}
}
for (int i = 0; i < com_num; i++) {
printf("%s %d\n", p_arr[i].com_text, p_arr[i].delay);
}
int cur_delay = p_arr[0].delay;
for (int i = 0; i < com_num; i++) {
int pid = fork();
// printf("%s\n", p_arr[i].com_text);
if (pid == 0) {
usleep(cur_delay);
execlp(p_arr[i].com_text, p_arr[i].com_text, NULL);
// FIXME: code after execlp never executes in a case execlp had no error
// FIXME: waitpid takes pid as first
int * status;
waitpid(p_arr[i].delay, status, 0);
}
if (i != com_num - 1)
cur_delay = p_arr[i + 1].delay - p_arr[i].delay;
}
fclose(f_in);
return 0;
}
static ssize_t p_read_mdab(struct file* filp, char* buf, size_t count, loff_t* f_pos)
{
#ifdef CONFIG_PROC_PIPE_64_BITS_SUPPORT
if(*f_pos >= pipes[1].mda_size)
#else // CONFIG_PROC_PIPE_64_BITS_SUPPORT
if(*f_pos >= pipes[1].mda->size)
#endif // CONFIG_PROC_PIPE_64_BITS_SUPPORT
return 0;
return p_read(1, filp, buf, count, f_pos);
}
static int lock_file(git_filebuf *file, int flags)
{
if (git_path_exists(file->path_lock) == true) {
if (flags & GIT_FILEBUF_FORCE)
p_unlink(file->path_lock);
else {
giterr_clear(); /* actual OS error code just confuses */
giterr_set(GITERR_OS,
"Failed to lock file '%s' for writing", file->path_lock);
return -1;
}
}
/* create path to the file buffer is required */
if (flags & GIT_FILEBUF_FORCE) {
/* XXX: Should dirmode here be configurable? Or is 0777 always fine? */
file->fd = git_futils_creat_locked_withpath(file->path_lock, 0777, GIT_LOCK_FILE_MODE);
} else {
file->fd = git_futils_creat_locked(file->path_lock, GIT_LOCK_FILE_MODE);
}
if (file->fd < 0)
return -1;
file->fd_is_open = true;
if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == true) {
git_file source;
char buffer[2048];
ssize_t read_bytes;
source = p_open(file->path_original, O_RDONLY);
if (source < 0) {
giterr_set(GITERR_OS,
"Failed to open file '%s' for reading",
file->path_original);
return -1;
}
while ((read_bytes = p_read(source, buffer, sizeof(buffer))) > 0) {
p_write(file->fd, buffer, read_bytes);
if (file->digest)
git_hash_update(file->digest, buffer, read_bytes);
}
p_close(source);
if (read_bytes < 0) {
giterr_set(GITERR_OS, "Failed to read file '%s'", file->path_original);
return -1;
}
}
return 0;
}
void haggle(double price,OBJECT_REC item) {
double oprice;
double offer;
char buffer[80];
oprice = price;
while (price != 0) {
gotoxy(15,23); textcolor(14); txt_write("Your offer ? ");
gotoxy(28,23);
p_read(buffer);
sscanf(buffer,"%lf",&offer);
if (offer == 0) price = 0;
if (offer>=(price-1) && price>0) {
if (offer>player.gold) {
gotoxy(15,21); textcolor(15);
txt_write("But you do not have that much!!");
price = 0;
}
else {
player.gold -= offer;
item.level = -1; /* Indicates object is known */
inventory(&item);
price = 0;
}
}
else if (price>0) {
if (price<=oprice*0.9) {
gotoxy(15,21); textcolor(14);
txt_write(" ");
gotoxy(15,21); textcolor(14);
sprintf(buffer,"But I can go no lower than %.0f",price);
txt_write(buffer);
}
else {
price = price*(1-u_random(5)/100);
gotoxy(15,21); textcolor(14);
txt_write(" ");
gotoxy(15,21); textcolor(14);
switch (u_random(5)) {
case 0:txt_write("Don't you think that a little low, how about ");
break;
case 1:txt_write("I have a wife & kids to feed, how about ");
break;
case 2:txt_write("But look at the workmanship, say ");
break;
case 3:txt_write("But there is none better anywhere, say ");
break;
case 4:txt_write("Must I starve to serve thee, For you ");
break;
}
sprintf(buffer,"%.0f",price);
txt_write(buffer);
}
}
}
} /* void haggle(double price,int item) */
tileset::tileset(std::string const& tsd_file_name)
{
p_read(tsd_file_name);
// Calculate vertics and indices for tileset
std::vector<vertex::pos2_tex2> vertices;
std::vector<GLuint> indices;
uvec2 const& texture_dim = p_texture->get_dimensions();
uvec2 const num_tiles = texture_dim / p_tile_size;
p_num_tiles = num_tiles.x() * num_tiles.y();
// Dimensions of a single tile when entire tileset is considered using coordinates [0, 1]
vec2 const tile_tex_coord_dim = vec2((float)p_tile_size) / vec2(texture_dim);
uvec2 curr_tile;
for(curr_tile.y() = 0; curr_tile.y() < num_tiles.y(); ++curr_tile.y())
{
for(curr_tile.x() = 0; curr_tile.x() < num_tiles.x(); ++curr_tile.x())
{
// Since size = current max index + 1, the index of the first vertex we add is equal to
// the size of the vector before it is added.
size_t curr_tile_base_vertex = vertices.size();
// Calculate the texture coordinates for this tile
vec2 tc_min = vec2(curr_tile) * tile_tex_coord_dim;
vec2 tc_max = tc_min + tile_tex_coord_dim;
vertices.emplace_back( vec2{-0.5f, -0.5f}, vec2{tc_min.x(), tc_max.y()} );
vertices.emplace_back( vec2{ 0.5f, -0.5f}, vec2{tc_max.x(), tc_max.y()} );
vertices.emplace_back( vec2{ 0.5f, 0.5f}, vec2{tc_max.x(), tc_min.y()} );
vertices.emplace_back( vec2{-0.5f, 0.5f}, vec2{tc_min.x(), tc_min.y()} );
GLuint bottom_left_index = curr_tile_base_vertex + 0;
GLuint bottom_right_index = curr_tile_base_vertex + 1;
GLuint top_right_index = curr_tile_base_vertex + 2;
GLuint top_left_index = curr_tile_base_vertex + 3;
indices.emplace_back(bottom_left_index);
indices.emplace_back(bottom_right_index);
indices.emplace_back(top_left_index);
indices.emplace_back(top_left_index);
indices.emplace_back(bottom_right_index);
indices.emplace_back(top_right_index);
}
}
p_tile_vertices.set_data(
vertices.data(),
vertices.size(),
indices.data(),
indices.size(),
GL_STATIC_DRAW);
}
void width_read(void) /* Read in the PostScript font# record
fo_line_def.SolFont from
WIDTHS.xx, convert wids to points or remain-
ders. Maintain the 10 most-recently-used
converted fonts in a 10-entry structure. */
{
int i;
for (Widindex=0;Widindex<10;Widindex++) /* Search for needed font/size
among 10 in mem: Must match*/
{
if (Widval[Widindex].fontnum != fo_line_def.SolFont) /* font number */
continue;
if (Widval[Widindex].setsize == Holdss) /* and set-size. */
return;
}
/*
The converted font we need is not in memory. Build it in entry zero
of the 10-entry widths structure, sliding entries 1,2... into entries 2,3....
*/
for (Widindex=8; Widindex>=0; Widindex--) /* Loop to open entry 0. */
{
Widval[Widindex+1].fontnum = Widval[Widindex].fontnum;
Widval[Widindex+1].setsize = Widval[Widindex].setsize;
for (i=0; i<255; i++)
Widval[Widindex+1].roundoffs[i]=Widval[Widindex].roundoffs[i];
}
if (fo_line_def.SolFont != current_font) /* If only setsize changed, */
/* font may be in mem now. */
{ /* No: */
err = p_read((char *)&widths_data, 1024,1,wdfd,
fo_line_def.SolFont, SW_WIDTH);
if( !err)
stop("Read of width failed, can't find that font, err"," ",0);
FontBase = widths_data.font_base; /* Save for universal use. */
if (FontBase < 10)
stop("Font is empty in width file"," ",0);
current_font = fo_line_def.SolFont; /* Remember which font in mem */
}
/* CONVERT & STORE THE FONT IN INDEX 0: */
Widindex = 0;
Widval[0].fontnum = fo_line_def.SolFont; /* Font number */
Widval[0].setsize = Holdss; /* Set size */
for(i=0;i<243;i++) /* Convert every char wid to its
remainder lost by H&J. */
Widval[0].roundoffs[i] =
(widths_data.char_width[i] * Holdss) % FontBase;
for(i=243;i<256;i++) /* Fixed spaces have no error. */
Widval[0].roundoffs[i] = 0;
}
static void test_file_contents(const char *path, const char *expectedcontents)
{
int fd;
char buffer[1024] = {0};
size_t expectedlen, actuallen;
fd = p_open(path, O_RDONLY);
cl_assert(fd >= 0);
expectedlen = strlen(expectedcontents);
actuallen = p_read(fd, buffer, 1024);
cl_git_pass(p_close(fd));
cl_assert_equal_sz(actuallen, expectedlen);
cl_assert_equal_s(buffer, expectedcontents);
}
int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type)
{
int hdr_len;
char hdr[64], buffer[2048];
git_hash_ctx ctx;
ssize_t read_len = 0;
int error = 0;
if (!git_object_typeisloose(type)) {
giterr_set(GITERR_INVALID, "Invalid object type for hash");
return -1;
}
if ((error = git_hash_ctx_init(&ctx)) < 0)
return -1;
hdr_len = git_odb__format_object_header(hdr, sizeof(hdr), size, type);
if ((error = git_hash_update(&ctx, hdr, hdr_len)) < 0)
goto done;
while (size > 0 && (read_len = p_read(fd, buffer, sizeof(buffer))) > 0) {
if ((error = git_hash_update(&ctx, buffer, read_len)) < 0)
goto done;
size -= read_len;
}
/* If p_read returned an error code, the read obviously failed.
* If size is not zero, the file was truncated after we originally
* stat'd it, so we consider this a read failure too */
if (read_len < 0 || size > 0) {
giterr_set(GITERR_OS, "Error reading file for hashing");
error = -1;
goto done;
}
error = git_hash_final(out, &ctx);
done:
git_hash_ctx_cleanup(&ctx);
return error;
}
void clar__assert_equal_file(
const char *expected_data,
size_t expected_bytes,
int ignore_cr,
const char *path,
const char *file,
int line)
{
char buf[4000];
ssize_t bytes, total_bytes = 0;
int fd = p_open(path, O_RDONLY | O_BINARY);
cl_assert(fd >= 0);
if (expected_data && !expected_bytes)
expected_bytes = strlen(expected_data);
while ((bytes = p_read(fd, buf, sizeof(buf))) != 0) {
clar__assert(
bytes > 0, file, line, "error reading from file", path, 1);
if (ignore_cr)
bytes = strip_cr_from_buf(buf, bytes);
if (memcmp(expected_data, buf, bytes) != 0) {
int pos;
for (pos = 0; pos < bytes && expected_data[pos] == buf[pos]; ++pos)
/* find differing byte offset */;
p_snprintf(
buf, sizeof(buf), "file content mismatch at byte %"PRIdZ,
(ssize_t)(total_bytes + pos));
p_close(fd);
clar__fail(file, line, path, buf, 1);
}
expected_data += bytes;
total_bytes += bytes;
}
p_close(fd);
clar__assert(!bytes, file, line, "error reading from file", path, 1);
clar__assert_equal(file, line, "mismatched file length", 1, "%"PRIuZ,
(size_t)expected_bytes, (size_t)total_bytes);
}
int git_hashsig_create_fromfile(
git_hashsig **out,
const char *path,
git_hashsig_option_t opts)
{
char buf[4096];
ssize_t buflen = 0;
int error = 0, fd;
hashsig_in_progress prog = HASHSIG_IN_PROGRESS_INIT;
git_hashsig *sig = hashsig_alloc(opts);
GITERR_CHECK_ALLOC(sig);
if ((fd = git_futils_open_ro(path)) < 0) {
git__free(sig);
return fd;
}
while (!error) {
if ((buflen = p_read(fd, buf, sizeof(buf))) <= 0) {
if ((error = (int)buflen) < 0)
giterr_set(GITERR_OS,
"Read error on '%s' calculating similarity hashes", path);
break;
}
error = hashsig_add_hashes(sig, buf, buflen, &prog);
}
p_close(fd);
if (!error)
error = hashsig_finalize_hashes(sig);
if (!error)
*out = sig;
else
git_hashsig_free(sig);
return error;
}
int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len)
{
ssize_t read_size = 0;
git_buf_clear(buf);
if (git_buf_grow(buf, len + 1) < 0)
return -1;
/* p_read loops internally to read len bytes */
read_size = p_read(fd, buf->ptr, len);
if (read_size != (ssize_t)len) {
giterr_set(GITERR_OS, "Failed to read descriptor");
return -1;
}
buf->ptr[read_size] = '\0';
buf->size = read_size;
return 0;
}
static void test_file_contents_internal(
const char *path, const char *expectedcontents, bool strip_cr)
{
int fd;
char data[1024] = {0};
git_buf buf = GIT_BUF_INIT;
size_t expectedlen = strlen(expectedcontents);
fd = p_open(path, O_RDONLY);
cl_assert(fd >= 0);
buf.ptr = data;
buf.size = p_read(fd, buf.ptr, 1024);
cl_git_pass(p_close(fd));
if (strip_cr)
strip_cr_from_buf(&buf);
cl_assert_equal_i((int)expectedlen, (int)buf.size);
cl_assert_equal_s(expectedcontents, buf.ptr);
}
static int write_file_stream(
git_oid *oid, git_odb *odb, const char *path, git_off_t file_size)
{
int fd, error;
char buffer[4096];
git_odb_stream *stream = NULL;
if ((error = git_odb_open_wstream(
&stream, odb, (size_t)file_size, GIT_OBJ_BLOB)) < 0)
return error;
if ((fd = git_futils_open_ro(path)) < 0) {
stream->free(stream);
return -1;
}
while (!error && file_size > 0) {
ssize_t read_len = p_read(fd, buffer, sizeof(buffer));
if (read_len < 0) {
giterr_set(
GITERR_OS, "Failed to create blob. Can't read whole file");
error = -1;
}
else if (!(error = stream->write(stream, buffer, read_len)))
file_size -= read_len;
}
p_close(fd);
if (!error)
error = stream->finalize_write(oid, stream);
stream->free(stream);
return error;
}
int main(int argc, char *argv[])
{
p_mem_t shared_mem, results_mem;
uint32_t eram_base;
char results[1024] = { '\0' };
int device_cols, device_rows, nside;
p_dev_t dev;
p_prog_t prog;
p_team_t team;
p_coords_t size;
p_coords_t start = { .row = 0, .col = 0 };
unsigned int msize;
float seed;
unsigned int addr; //, clocks;
size_t sz;
int verbose=0;
double tdiff[3];
int result, retval = 0;
msize = 0x00400000;
get_args(argc, argv);
fo = stderr;
fi = stdin;
printf( "------------------------------------------------------------\n");
printf( "Calculating: C[%d][%d] = A[%d][%d] * B[%d][%d]\n", _Smtx, _Smtx, _Smtx, _Smtx, _Smtx, _Smtx);
seed = 0.0;
if(verbose){
printf( "Seed = %f\n", seed);
}
dev = p_init(P_DEV_EPIPHANY, 0);
if (p_error(dev)) {
fprintf(stderr, "Error initializing PAL\n");
return p_error(dev);
}
device_cols = p_query(dev, P_PROP_COLS);
device_rows = p_query(dev, P_PROP_ROWS);
// Use min size
nside = device_cols > device_rows ? device_cols : device_rows;
if (nside < 4) {
fprintf(stderr, "Error: Too small device, need at least 4x4\n");
return 1;
}
// Either 1024, 256, 64, or 16 cores (side must be power of two),
nside = nside >= 32 ? 32 : nside >= 16 ? 16 : nside >= 8 ? 8 : 4;
size.row = nside;
size.col = nside;
team = p_open4(dev, P_TOPOLOGY_2D, &start, &size);
printf("Using team of size %d\n", p_team_size(team));
if (p_error(team)) {
fprintf(stderr, "Error opening team\n");
return p_error(team);
}
prog = p_load(dev, ar.elfFile, 0);
eram_base = (unsigned) p_query(dev, P_PROP_MEMBASE);
shared_mem = p_map(dev, eram_base, msize);
// Clear mailbox contents
memset(&Mailbox, 0, sizeof(Mailbox));
p_write(&shared_mem, &Mailbox, 0, sizeof(Mailbox), 0);
// Generate operand matrices based on a provided seed
matrix_init((int)seed);
#ifdef __WIPE_OUT_RESULT_MATRIX__
// Wipe-out any previous remains in result matrix (for verification)
addr = offsetof(shared_buf_t, C[0]);
sz = sizeof(Mailbox.C);
if(verbose){
printf( "Writing C[%uB] to address %08x...\n", (unsigned) sz, addr);
}
p_write(&shared_mem, (void *) Mailbox.C, addr, sz, 0);
#endif
/* Wallclock time */
clock_gettime(CLOCK_MONOTONIC, &timer[0]);
/* Clock CPUTIME too. We don't want to indicate failure just
* because the system was under high load. */
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[4]);
// Copy operand matrices to Epiphany system
addr = offsetof(shared_buf_t, A[0]);
sz = sizeof(Mailbox.A);
if(verbose){
printf( "Writing A[%uB] to address %08x...\n", (unsigned) sz, addr);
}
p_write(&shared_mem, (void *) Mailbox.A, addr, sz, 0);
addr = offsetof(shared_buf_t, B[0]);
sz = sizeof(Mailbox.B);
if(verbose){
printf( "Writing B[%uB] to address %08x...\n", (unsigned) sz, addr);
}
p_write(&shared_mem, (void *) Mailbox.B, addr, sz, 0);
// Call the Epiphany matmul() function
if(verbose){
printf( "GO Epiphany! ... ");
}
if(verbose){
printf("Loading program on Epiphany chip...\n");
}
p_arg_t args[] = { &nside, sizeof(nside), true };
if (p_run(prog, "matmul", team, 0, p_team_size(team), 1, args, 0)) {
fprintf(stderr, "Error loading Epiphany program.\n");
exit(1);
}
// Read result matrix and timing
addr = offsetof(shared_buf_t, C[0]);
sz = sizeof(Mailbox.C);
if(verbose){
printf( "Reading result from address %08x...\n", addr);
}
p_read(&shared_mem, (void *) Mailbox.C, addr, sz, 0);
clock_gettime(CLOCK_MONOTONIC, &timer[1]);
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[5]);
// Calculate a reference result
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[2]);
#ifndef __DO_STRASSEN__
matmul(Mailbox.A, Mailbox.B, Cref, _Smtx);
#else
matmul_strassen(Mailbox.A, Mailbox.B, Cref, _Smtx);
#endif
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[3]);
addr = offsetof(shared_buf_t, core.clocks);
sz = sizeof(Mailbox.core.clocks);
if(verbose){
printf( "Reading time from address %08x...\n", addr);
}
p_read(&shared_mem, &Mailbox.core.clocks, addr, sizeof(Mailbox.core.clocks), 0);
// clocks = Mailbox.core.clocks;
// Calculate the difference between the Epiphany result and the reference result
matsub(Mailbox.C, Cref, Cdiff, _Smtx);
tdiff[0] = (timer[1].tv_sec - timer[0].tv_sec) * 1000 + ((double) (timer[1].tv_nsec - timer[0].tv_nsec) / 1000000.0);
// tdiff[0] = ((double) clocks) / eMHz * 1000;
tdiff[1] = (timer[3].tv_sec - timer[2].tv_sec) * 1000 + ((double) (timer[3].tv_nsec - timer[2].tv_nsec) / 1000000.0);
tdiff[2] = (timer[5].tv_sec - timer[4].tv_sec) * 1000 + ((double) (timer[5].tv_nsec - timer[4].tv_nsec) / 1000000.0);
// If the difference is 0, then the matrices are identical and the
// calculation was correct
if (iszero(Cdiff, _Smtx))
{
printf( "Epiphany(time) %9.1f msec (@ %03d MHz)\n", tdiff[0], eMHz);
printf( "Host(time) %9.1f msec (@ %03d MHz)\n", tdiff[1], aMHz);
printf( "------------------------------------------------------------\n");
printf( "TEST \"matmul-16\" PASSED\n");
retval = 0;
} else {
printf( "\n\nERROR: C_epiphany is different from C_host !!!\n");
printf( "TEST \"matmul-16\" FAILED\n");
retval = 1;
}
#if 0
#ifdef __DUMP_MATRICES__
printf( "\n\n\n");
printf( "A[][] = \n");
matprt(Mailbox.A, _Smtx);
printf( "B[][] = \n");
matprt(Mailbox.B, _Smtx);
printf( "C[][] = \n");
matprt(Mailbox.C, _Smtx);
printf( "Cref[][] = \n");
matprt(Cref, _Smtx);
int i, j;
for (i=0; i<_Nside; i++)
for (j=0; j<_Nside; j++)
{
e_read(pEpiphany, i, j, 0x2000+0*sizeof(float), &Aepi[(i*_Score+0)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x2000+2*sizeof(float), &Aepi[(i*_Score+1)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x4000+0*sizeof(float), &Bepi[(i*_Score+0)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x4000+2*sizeof(float), &Bepi[(i*_Score+1)*_Smtx + j*_Score], 2*sizeof(float));
}
printf( "Aepi[][] = \n");
matprt(Aepi, _Smtx);
printf( "Bepi[][] = \n");
matprt(Bepi, _Smtx);
#endif
#endif
// p_unmap ...
p_close(team);
p_finalize(dev);
return retval;
}
// Initialize operand matrices
void matrix_init(int seed)
{
int i, j, p;
p = 0;
for (i=0; i<_Smtx; i++)
for (j=0; j<_Smtx; j++)
Mailbox.A[p++] = (i + j + seed) % _MAX_MEMBER_;
p = 0;
for (i=0; i<_Smtx; i++)
for (j=0; j<_Smtx; j++)
Mailbox.B[p++] = ((i + j) * 2 + seed) % _MAX_MEMBER_;
p = 0;
for (i=0; i<_Smtx; i++)
for (j=0; j<_Smtx; j++)
Mailbox.C[p++] = 0x8dead;
return;
}
pass2()
{
int saved[12] ;
int i ;
char line[LINELEN] ;
char *tail, *arg, *temp, *temp2, *temp3 ;
/* start pass 3 */
switch_down(1) ;
saved[0] = saved[1] = saved[2] = saved[3] = 0 ;
saved[4] = saved[5] = saved[6] = saved[7] = saved[8] = 0 ;
saved[9] = saved[10] = saved[11] = 0 ;
ln1 = alloc(LINELEN) ;
ln2 = alloc(LINELEN) ;
ln3 = alloc(LINELEN) ;
ln4 = alloc(LINELEN) ;
ln5 = alloc(LINELEN) ;
ln6 = alloc(LINELEN) ;
p_read(ln1) ;
p_read(ln2) ;
p_read(ln3) ;
p_read(ln4) ;
p_read(ln5) ;
while ( p_read(ln6) ) {
/* inc or dec top or second on stack */
if ( strcmp(Ldhl0,ln1) == 0 ||
strcmp(Ldhl2,ln1) == 0 ||
strcmp(Ldhl4,ln1) == 0 ||
strcmp(Ldhl6,ln1) == 0 ) {
if ( strcmp("\tADD HL,SP",ln2) == 0 &&
strcmp(Pushhl,ln3) == 0 &&
strcmp("\tCALL ccgint",ln4) == 0 &&
(strcmp(Inchl,ln5) == 0 || strcmp(Dechl,ln5) == 0) &&
strcmp("\tCALL ccpint",ln6) == 0 ) {
if ( strcmp(Ldhl6,ln1) == 0 ) {
c_write(Popix);
c_write(Popde);
c_write(Popbc);
}
else if ( strcmp(Ldhl4,ln1) == 0 ) {
c_write(Popde);
c_write(Popbc);
}
else if ( strcmp(Ldhl2,ln1) == 0 ) {
c_write(Popbc);
}
c_write(Pophl);
c_write(ln5);
if ( strcmp(Ldhl6,ln1) == 0 ) {
c_write(Pushhl);
c_write(Pushbc);
c_write(Pushde);
strcpy(ln1,Pushix);
++saved[3];
}
else if ( strcmp(Ldhl4,ln1) == 0 ) {
c_write(Pushhl);
c_write(Pushbc);
strcpy(ln1,Pushde);
++saved[2];
}
else if ( strcmp(Ldhl2,ln1) == 0 ) {
c_write(Pushhl);
strcpy(ln1,Pushbc);
++saved[1];
}
else {
strcpy(ln1,Pushhl);
++saved[0] ;
}
p_read(ln2);
p_read(ln3);
p_read(ln4);
p_read(ln5);
p_read(ln6);
}
}
/* check for comparison against small constant and jump */
if ( strcmp(Exdehl, ln1) == 0 &&
(arg=match(Ldhl, ln2)) &&
(strcmp("\tCALL cceq",ln3) == 0 || strcmp("\tCALL ccne",ln3) == 0) )
if ( strcmp("\tLD A,H", ln4) == 0 &&
strcmp("\tOR L", ln5) == 0 &&
((tail=match("\tJP NZ,",ln6)) || (tail=match("\tJP Z,",ln6)))) {
if ( (i=chk_arg(arg)) != 0 ) {
if ( strcmp("\tCALL cceq",ln3) == 0 ) {
if ( match("\tJP NZ,",ln6 ) ) {
strcpy(line, "\tJP Z,") ;
}
else {
strcpy(line, "\tJP NZ,") ;
}
strcat(line, tail) ;
strcpy(ln6, line) ;
}
temp = ln1 ;
temp2 = ln2 ;
temp3 = ln3 ;
ln1 = ln4 ;
ln2 = ln5 ;
ln3 = ln6 ;
ln4 = temp ;
ln5 = temp2 ;
ln6 = temp3 ;
p_read(ln4) ;
p_read(ln5) ;
p_read(ln6) ;
++saved[3+i] ;
}
}
/* lh hl,0 after test has ensured hl is zero */
if ( strcmp("\tLD A,H", ln1) == 0 ) {
if ( strcmp("\tOR L", ln2) == 0 ) {
if ( match("\tJP NZ,", ln3) ) {
if ( strcmp(Ldhl0, ln4) == 0 ) {
temp = ln4 ;
ln4 = ln5 ;
ln5 = ln6 ;
ln6 = temp ;
p_read(ln6) ;
++saved[9] ;
}
}
}
}
/* return TOS, one item on stack */
if ( strcmp(Pophl, ln3) == 0 ) {
if ( strcmp(Pushhl, ln4) == 0 ) {
if ( strcmp(Popbc, ln5) == 0 ) {
if ( strcmp(Ret, ln6) == 0 ) {
strcpy(ln4, Ret) ;
p_read(ln5) ;
p_read(ln6) ;
++saved[10] ;
}
}
}
}
/* return TOS, two items on stack */
if ( strcmp(Pophl, ln2) == 0 ) {
if ( strcmp(Pushhl, ln3) == 0 ) {
if ( strcmp(Popbc, ln4) == 0 ) {
if ( strcmp(Popbc, ln5) == 0 ) {
if ( strcmp(Ret, ln6) == 0 ) {
strcpy(ln3, Popbc) ;
strcpy(ln4, Ret) ;
p_read(ln5) ;
p_read(ln6) ;
++saved[11] ;
}
}
}
}
}
c_write(ln1);
temp = ln1;
ln1 = ln2;
ln2 = ln3;
ln3 = ln4;
ln4 = ln5;
ln5 = ln6;
ln6 = temp;
if (cpm(CONIN, 255) == CTRLC) exit() ;
}
c_write(ln1);
c_write(ln2);
c_write(ln3);
c_write(ln4);
c_write(ln5);
puts("INC or DEC top of stack "); putdec(saved[0]) ;
putchar('\n') ;
puts("INC or DEC 2nd top of stack "); putdec(saved[1]) ;
putchar('\n') ;
puts("INC or DEC 3rd top of stack "); putdec(saved[2]) ;
putchar('\n') ;
puts("INC or DEC 4th top of stack "); putdec(saved[3]) ;
putchar('\n') ;
puts("Test for == or != zero "); putdec(saved[4]) ;
putchar('\n') ;
puts("Test for == or != +/-1 "); putdec(saved[5]) ;
putchar('\n') ;
puts("Test for == or != +/-2 "); putdec(saved[6]) ;
putchar('\n') ;
puts("Test for == or != +/-3 "); putdec(saved[7]) ;
putchar('\n') ;
puts("Test for == or != constant "); putdec(saved[8]) ;
putchar('\n') ;
puts("LD HL,0 when HL is zero "); putdec(saved[9]) ;
putchar('\n') ;
puts("Return TOS, one item on stack "); putdec(saved[10]) ;
putchar('\n') ;
puts("Return TOS, two on stack "); putdec(saved[11]) ;
putchar('\n') ;
putchar('\n') ;
i = saved[0]*9 + saved[1]*7 + saved[2]*5 + saved[3] ;
i += saved[4]*7 + saved[5]*6 + saved[6]*5 + saved[7]*4 ;
i += saved[8]*3 + saved[9]*3 + saved[10]*2 + saved[11]*2 ;
pr_total(i);
Total += i ;
}
static int job_setup(void)
{
int length, i, c;
int16 stds_buff[240];
Pfd sysfd;
int temp_reg_length = 0;
int temp_trim = 0;
float fcolor;
int ii;
char pdfword[8192];
char pdftmp[8192];
char pdfc[5];
char *p;
PdfActive = 0; /* Assume no PDF style given, thus
no PDF output desired. */
/* Clear PDF values - Set defaults for menu items left blank */
/* (all assuming that PDF output is active). */
pdflinkctr = 0;
pdflinkAtSOL = 0;
job_link.btype=3; /* none */
job_link.weight=1;
job_link.bcolor=000000000; /* White */
strcpy(job_link.ocolor,"0 0 0");
job_link.dashlen=4;
job_link.dashgap=4;
job_link.radius=0;
pdf_info.title[0] = '\0';
pdf_info.auth[0] = '\0';
pdf_info.subj[0] = '\0';
pdf_info.keyw[0] = '\0';
pdf_info.creator[0] = '\0';
pdf_info.date1[0] = '\0';
pdf_info.date2[0] = '\0';
pdf_docview.initpage=1;
pdf_docview.initdisp=2; /* page only */
pdf_docview.initsize=2; /* fit zoom */
pdf_docview.initzoom=0; /* full screen */
pdf_note_disp=0;
pdf_note_length=60;
pdf_note_depth=60;
pdf_note_color=255255255;
strcpy(pdf_note_ocolor,"1 1 1");
pdf_output_lev = 9; /* all levels */
pdf_crop_cw = pdf_crop_cd = 0; /* No crop box. */
pdf_crop_dw = pdf_crop_dd = 0;
pdf_crop_cox = pdf_crop_coy = pdf_crop_cex = pdf_crop_cey = 0;
pdf_crop_dox = pdf_crop_doy = pdf_crop_dex = pdf_crop_dey = 0;
set_traces(msg[7].answer);
#ifdef TRACE
if(debugger_trace)
{
for (i=0; i<KEYWORD_COUNT; i++)
p_info(PI_TRACE, "i= %d, Keyword %s, Value= %s \n",
i,msg[i].keyword,msg[i].answer);
}
#endif
if (msg[68].answer[0])
LockFlag = 0;
else
LockFlag = 1;
FirstGal = 0;
LastGal = 1000000;
if ( !msg[6].answer[0])
{ /* no Tree name present */
if( !msg[7].answer[0])
{ /* no traces change */
p_info(PI_ELOG, "ERROR - 'Tree' name missing, program exit \n");
exit(1);
}
return(1); /* change traces only */
}
length = strlen(msg[6].answer);
if( length >= MAX_NAME)
{
p_info(PI_ELOG, "ERROR- 'Tree' name '%s' exceeds %d characters, program exit.\n",
msg[6].answer, MAX_NAME - 1);
exit(1);
}
strcpy(TreeName, msg[6].answer);
if ( !msg[4].answer[0])
{ /* sub-dir name missing */
if( msg[2].answer[0] )
{ /* need subdir name if it is a galley */
p_info(PI_ELOG, "ERROR - 'Dir' name is missing, program exit \n");
exit(1);
}
else
{ /* create SubDirName if not present for unit */
if( !msg[3].answer[0] )
{ /* need subdir name if it is a galley */
p_info(PI_ELOG, "ERROR - 'Dir' name is missing, program exit \n");
exit(1);
}
else /* use unit name for project */
sprintf(SubDirName,"%s.prj",msg[3].answer);
}
}
else
{
length = strlen(msg[4].answer);
if( length >= MAX_NAME)
{
p_info(PI_ELOG, "ERROR - 'Dir' name '%s' exceeds %d characters, program exit.\n",
msg[4].answer, MAX_NAME - 1);
exit(1);
}
strcpy(SubDirName, msg[4].answer);
}
if ( p_get_data_name ( TreeName, SubDirName, UserdataPath, 0 ) )
{
p_info(PI_ELOG, "ERROR - missing file '/Penta/%s/desks/%s/.data', program exit.\n",
TreeName, SubDirName);
exit(1);
}
#ifdef TRACE
if (debugger_trace)
p_info(PI_TRACE, "path to userdata is '%s' \n",UserdataPath);
#endif
if ((sysfd = p_open(TreeName,USERDATA,UserdataPath,"standards","r")) == 0)
{
p_info(PI_ELOG, "ERROR - file 'standards' is missing, program exit.\n");
exit(1);
}
if ( !(p_read((char *)stds_buff, 240, 1, sysfd, 0, BS16) ) )
{
p_info(PI_ELOG, "ERROR - cannot read file 'standards', program exit.\n");
exit(1);
}
p_close(sysfd);
HorizontalBase = stds_buff[35];
VerticalBase = stds_buff[74];
Jrule = (int)stds_buff[95];
if ( !Jrule)
Jrule = 10;
BookPrint = 0;
if ( msg[2].answer[0])
{ /* galley name */
length = strlen(msg[2].answer);
if( length >= MAX_NAME)
{
p_info(PI_ELOG, "ERROR - 'Galley' name '%s' exceeds %d characters, program exit. \n",
msg[2].answer, MAX_NAME - 1);
exit(1);
}
strcpy(JobName, msg[2].answer); /* we have a galley name */
FileType = 0; /* Galley output */
FirstPage = 0;
} /* end galley name */
else if ( msg[3].answer)
{ /* use the unit name */
length = strlen(msg[3].answer);
if( length >= MAX_NAME)
{
p_info(PI_ELOG, "ERROR - 'Unit' name '%s' exceeds %d characters, program exit.\n",
msg[3].answer, MAX_NAME);
exit(1);
}
FileType = 1; /* must be a unit name */
strcpy(JobName, msg[3].answer);
FirstPage = -1; /* (assume no start/end pgs given) */
LastPage = -1;
if (strstr(msg[8].answer, ".prj"))
{ /* Child-project name is passed instead of first pg#.
Store project name, set doing-book flag: */
strcpy (FirstProjofBook, msg[8].answer);
strcpy (LastProjofBook, FirstProjofBook);
BookPrint = 1;
if (strstr(msg[9].answer, ".prj"))
strcpy (LastProjofBook, msg[9].answer);
}
else if (msg[8].answer[0]) /* Regular starting page # */
{
FirstPage = atol(msg[8].answer);
if (msg[9].answer[0]) /* Regular ending page # */
LastPage = atol(msg[9].answer);
}
if ( msg[18].answer[0])
{ /* only use for debugging */
FirstPage = atol(msg[18].answer);
if ( !msg[19].answer[0])
LastPage = -1;
else
LastPage = atol(msg[19].answer);
}
if ( msg[33].answer[0]) /* Layout */
strcpy (msg[21].answer, msg[33].answer);
if ( msg[21].answer[0]) /* FirstMaster */
{
length = strlen(msg[21].answer);
if( length >= MAX_NAME)
{
p_info(PI_ELOG, "ERROR - 'FirstMaster' name '%s' exceeds %d characters, program exit. \n",
msg[21].answer, MAX_NAME - 1);
exit(1);
}
strcpy(PageName, msg[21].answer); /* we have a layout name */
MasterNameFlag = 1;
FirstPage = 0;
LastPage = 0;
}
else
{
MasterNameFlag = 0;
PageName[0] = 0;
}
if(psinit())
exit(1);
} /* end unit name */
else
{
p_info (PI_ELOG, "ERROR - missing 'Galley' or 'Unit' name, program exit. \n");
exit(1);
}
if (msg[5].answer[0])
{ /* printer name */
length = strlen(msg[5].answer);
if( length >= MAX_NAME)
{
p_info(PI_ELOG, "ERROR - 'PrinterName' '%s' exceeds %d characters, program exit. \n",
msg[5].answer, MAX_NAME - 1);
exit(1);
}
strcpy(PrinterName, msg[5].answer);
}
else
strcpy(PrinterName, "\0\0");
lnumbers = atoi(msg[10].answer);
suppresslp=0;
if ( msg[11].answer[0])
{
length = strlen(msg[11].answer);
if( length >= MAX_NAME)
{
p_info(PI_ELOG, "ERROR - 'ColorTable' name '%s' exceeds %d characters, program exit. \n",
msg[11].answer, MAX_NAME - 1);
exit(1);
}
strcpy(ColorTableName, msg[11].answer);
}
else
strcpy(ColorTableName, "colortable");
init_color();
p_info(PI_INFO, "Postprint starting Tree: '%s', Dir: '%s', Job: '%s' \n",TreeName,SubDirName,JobName);
if ( msg[12].answer[0])
GalleySlugFlag = atoi(msg[12].answer); /* use keyword with 0 or 1 */
else
{ /* no keyword, use defaults */
if ( FileType)
GalleySlugFlag = 0; /* default is no print slug if Unit */
else
GalleySlugFlag = 1; /* default is print slug if Galley */
}
if ( msg[13].answer[0])
strcpy(PsfTableName, msg[13].answer); /* name of PSFTABLE */
else
strcpy(PsfTableName, "psftable");
Orient = 0; /* portrait is default */
if ( msg[14].answer[0])
{ /* p or P = portrait, l or L = landscape */
switch (msg[14].answer[0])
{
case 'P':
case 'p':
Orient = 0; /* portrait */
break;
case 'L':
case 'l':
Orient = 90; /* landscape */
break;
default:
p_info(PI_ELOG, "ERROR - Orient '%s' invalid, defaulting to portrait.\n",
msg[14].answer);
break;
}
}
if ( msg[15].answer[0])
{ /* KeyScale */
if ( (msg[15].answer[0] & 0xdf) == 'X')
KeyScale = -1; /* defined as 'X' */
else
KeyScale = atoi(msg[15].answer);
}
else
KeyScale = -2; /* not defined */
if ( msg[16].answer[0]) /* KeyScaleX */
KeyScaleX = atoi(msg[16].answer);
else
KeyScaleX = -1;
if ( msg[17].answer[0]) /* KeyScaleY */
KeyScaleY = atoi(msg[17].answer);
else
KeyScaleY = -1;
KeyOutputType = 0; /* default is composite */
if ( msg[20].answer[0] == '1')
{
#if LPMfloat
if ( LPMK[LPM_PWS1] || LPMK[LPM_PWS2] )
#else
if ( (LPMK & LPM_PWS1) || (LPMK & LPM_PWS2) )
#endif
p_info(PI_ELOG, "ERROR - Color separation not allowed on a Personal Workstation.\n");
else
#if ! LPMfloat
if((LPMK & LPM_SpotColor))
#endif
KeyOutputType = 1; /* color separation */
}
if ( msg[23].answer[0]) /* Header */
setpage_allowed =
atoi(msg[23].answer); /* 1 means dump page width and height */
else
setpage_allowed = -1;
MultiPagesUp = 0; /* default is 1 up */
MultiPagesOddEvenFlag = 0;
MultiOddPage_cc_mask = 0;
if ( msg[24].answer[0]) /* Multi - for 2 pages up */
{ /* non-zero means 2-up */
MultiPagesUp = atoi(msg[24].answer);
if ( !FileType || (FirstPage < 0) ||
( ( FirstPage >= 0) && !(FirstPage & 1) ) )
MultiPagesOddEvenFlag = 0;
else
MultiPagesOddEvenFlag = 1; /* starting Unit on odd page */
}
if ( msg[25].answer[0]) /* PageW */
{
PageW = atoi(msg[25].answer);
PageW_key_flag = 1;
}
else
{
PageW = -1;
PageW_key_flag = 0;
}
if ( msg[26].answer[0]) /* PageD */
{
PageH = atoi(msg[26].answer);
PageD_key_flag = 1;
}
else
{
PageH = -1;
PageD_key_flag = 0;
}
if ( msg[27].answer[0]) /* Pofft */
{
OffT = atoi(msg[27].answer);
Pofft_key_flag = 1;
}
else
{
OffT = -1;
Pofft_key_flag = 0;
}
if ( msg[28].answer[0]) /* Poffb */
{
OffB = atoi(msg[28].answer);
Poffb_key_flag = 1;
}
else
{
OffB = -1;
Poffb_key_flag = 0;
}
if ( msg[29].answer[0]) /* Poffl */
{
OffL = atoi(msg[29].answer);
Poffl_key_flag = 1;
}
else
{
OffL = -1;
Poffl_key_flag = 0;
}
if ( msg[30].answer[0]) /* Poffr */
{
OffR = atoi(msg[30].answer);
Poffr_key_flag = 1;
}
else
{
OffR = -1;
Poffr_key_flag = 0;
}
if ( msg[31].answer[0]) /* Cmyk */
CMYK_Allowed = atoi(msg[31].answer);
else
CMYK_Allowed = -1;
if ( msg[32].answer[0]) /* Hdrup */
header_offset = atoi(msg[32].answer); /* Pts to raise slug line */
else
header_offset = -32760; /* -32760 means no Hdrup keyword */
LYPrintFlag = 0;
if ( msg[34].answer[0]) /* LYP - layout print */
{
if ( !FileType)
{
p_info(PI_ELOG, "ERROR - Cannot do LYP (layout print) for galley, program exit.\n");
exit(1);
}
/* for LayoutPrint, kill other functions */
for (i=0; i<10; i++)
{
if ( !msg[34].answer[i])
break;
if ( msg[34].answer[i] == 'a')
{ /* a means all reports */
LYPrintFlag = -1;
break;
}
c = (msg[34].answer[i] - '0') & 0xf;
if ( (c <= 0) || (c > 9) )
continue;
LYPrintFlag |= 1 << (c -1 );
}
} /* end if(msg[34].answer[0]) */
if (LYPrintFlag)
{
delay_records_flag = -1; /* no sorting for reporting */
GalleySlugFlag = 0;
KeyOutputType = 0;
MultiPagesUp = 0;
lnumbers = 0;
if ( msg[35].answer[0])
{ /* Report directory, used, or both */
Reports = atoi( msg[35].answer);
switch ( Reports)
{
case -1: /* all files in directory and all used */
case 0: /* only those files in directory (default) */
case 1: /* only those files used */
break;
default:
p_info(PI_ELOG, "ERROR - 'Report' Key Word option %s not available. Defaulting to reporting on data base in directory.\n", msg[35].answer);
Reports = 0;
break;
} /* end switch(Reports) */
}
else
Reports = 0; /* default */
}
else
delay_records_flag = 1; /* normal postsript delay */
if ( msg[37].answer[0] == '1')
KeyTrimFlags = 1; /* trim marks */
else
KeyTrimFlags = 0;
if ( msg[36].answer[0] == '1')
KeyTrimFlags |= 2; /* register marks */
if ( (KeyTrimFlags & 1) && !LYPrintFlag )
{ /* set up trim marks */
if ( msg[41].answer[0])
temp_trim = atoi(msg[41].answer);
if ( !temp_trim)
temp_trim = 24; /* default */
trim_mark_width = temp_trim * HorizontalBase;
trim_mark_depth = temp_trim * VerticalBase;
KeyTrimLength = temp_trim;
KeyTrimWeight = 0;
if ( msg[40].answer[0])
KeyTrimWeight = (int )(atof(msg[40].answer) * 20); /* in 1/20 pt */
if ( KeyTrimWeight < 2)
KeyTrimWeight = 2;
}
else
{
trim_mark_width = 0;
trim_mark_depth = 0;
KeyTrimWeight = 0;
KeyTrimLength = 0;
}
if ( (KeyTrimFlags & 2) && !LYPrintFlag )
{ /* set up register marks */
if ( msg[39].answer[0])
temp_reg_length = atoi(msg[39].answer);
if ( !temp_reg_length)
temp_reg_length = 12; /* default */
KeyRegisterLength = temp_reg_length; /* in points */
KeyRegisterWt = 0;
if ( msg[38].answer[0])
KeyRegisterWt = atof(msg[38].answer);
if ( KeyRegisterWt < 0.1)
KeyRegisterWt = .1;
if ( (2 * temp_reg_length) > temp_trim)
{
trim_mark_width = temp_reg_length * HorizontalBase * 2;
trim_mark_depth = temp_reg_length * VerticalBase * 2;
}
}
else
{
KeyRegisterLength = 0;
KeyRegisterWt = 0;
}
if ( (KeyTrimFlags &3) && !LYPrintFlag )
{ /* add 9 point offset */
if (msg[72].answer[0]) /* ie. gap between trim-line & tick */
KeyTrimRegGap = atoi(msg[72].answer);
else
KeyTrimRegGap = 9;
trim_mark_width += (KeyTrimRegGap * HorizontalBase);
trim_mark_depth += (KeyTrimRegGap * VerticalBase);
}
if (msg[73].answer[0])
EpsFlag = atoi(msg[73].answer);
else
EpsFlag=0;
if (msg[74].answer[0])
strcpy(Uname,msg[74].answer);
else
strcpy(Uname,"penta");
if (msg[75].answer[0])
DownLoadFont=1;
else
DownLoadFont=0;
if (msg[76].answer[0])
ResolveOPI=1;
else
ResolveOPI=0;
if (msg[77].answer[0])
job_link.btype=atoi(msg[77].answer);
if (msg[78].answer[0])
job_link.weight=atoi(msg[78].answer);
if (msg[79].answer[0]) {
job_link.bcolor=atoi(msg[79].answer);
strcpy(pdftmp,msg[79].answer);
/* split into chunks of 3 digits */
job_link.ocolor[0] = '\0';
p=pdftmp;
for (ii=1; ii <= 3; ii++) {
strncpy(pdfc,p,3);
fcolor=(atoi(pdfc)/255);
memset(pdfword,0,sizeof(pdfword));
sprintf(pdfword," %.2f",fcolor);
strcat(job_link.ocolor,pdfword);
p+=3;
}
}
if (msg[80].answer[0])
job_link.dashlen=atoi(msg[80].answer);
if (msg[81].answer[0])
job_link.dashgap=atoi(msg[81].answer);
if (msg[82].answer[0])
job_link.radius=atoi(msg[82].answer);
if (msg[83].answer[0])
strcpy(pdf_info.title,msg[83].answer);
if (msg[84].answer[0])
strcpy(pdf_info.auth,msg[84].answer);
if (msg[85].answer[0])
strcpy(pdf_info.subj,msg[85].answer);
if (msg[86].answer[0])
strcpy(pdf_info.keyw,msg[86].answer);
if (msg[87].answer[0])
strcpy(pdf_info.creator,msg[87].answer);
if (msg[88].answer[0])
strcpy(pdf_info.date1,msg[88].answer);
if (msg[89].answer[0])
strcpy(pdf_info.date2,msg[89].answer);
if (msg[90].answer[0])
pdf_docview.initpage = atoi(msg[90].answer);
if (msg[91].answer[0]) /* This is the switch, set by DM print menu: */
{ /* There was a PDF style used in this request. */
PdfActive = 1; /* PDF output is now active. */
pdf_docview.initdisp = atoi(msg[91].answer);
}
if (msg[92].answer[0])
pdf_docview.initsize = atoi(msg[92].answer);
if (msg[93].answer[0])
pdf_docview.initzoom = atoi(msg[93].answer);
if (msg[94].answer[0])
pdf_note_disp = atoi(msg[94].answer);
if (msg[95].answer[0])
pdf_note_length = atoi(msg[95].answer);
if (msg[96].answer[0])
pdf_note_depth = atoi(msg[96].answer);
if (msg[97].answer[0]) {
pdf_note_color=atoi(msg[97].answer);
strcpy(pdftmp,msg[97].answer);
/* split into chunks of 3 digits */
pdf_note_ocolor[0] = '\0';
p=pdftmp;
for (ii=1; ii <= 3; ii++) {
strncpy(pdfc,p,3);
fcolor=(atoi(pdfc)/255);
memset(pdfword,0,sizeof(pdfword));
sprintf(pdfword," %.2f",fcolor);
strcat(pdf_note_ocolor,pdfword);
p+=3;
}
}
if (msg[98].answer[0])
pdf_output_lev = atoi(msg[98].answer);
if (msg[99].answer[0])
pdf_crop_dox = atoi(msg[99].answer);
if (msg[100].answer[0])
pdf_crop_doy = atoi(msg[100].answer);
if (msg[101].answer[0])
pdf_crop_dex = atoi(msg[101].answer);
if (msg[102].answer[0])
pdf_crop_dey = atoi(msg[102].answer);
if (msg[103].answer[0])
pdf_crop_cox = atoi(msg[103].answer);
if (msg[104].answer[0])
pdf_crop_coy = atoi(msg[104].answer);
if (msg[105].answer[0])
pdf_crop_cex = atoi(msg[105].answer);
if (msg[106].answer[0])
pdf_crop_cey = atoi(msg[106].answer);
if (msg[107].answer[0])
pdf_crop_cw = atoi(msg[107].answer);
if (msg[108].answer[0])
pdf_crop_cd = atoi(msg[108].answer);
if (msg[109].answer[0])
pdf_crop_dw = atoi(msg[109].answer);
if (msg[110].answer[0])
pdf_crop_dd = atoi(msg[110].answer);
if (msg[111].answer[0])
pdf_bead = atoi(msg[111].answer);
else
pdf_bead = 0;
MultiPagesFirstIsOdd = MultiPagesOddEvenFlag;
if ( !FileType)
{ /* if galley, see if start & end galley */
if ( msg[42].answer[0])
{
FirstGal = atoi(msg[42].answer);
if (FirstGal < 0)
{
p_info(PI_ELOG, "ERROR - First galley number (%s) less than 0, defaulting to all galleys.\n",
msg[42].answer);
FirstGal = 0;
LastGal = 1000000;
}
else if ( msg[43].answer[0])
{
LastGal = atoi(msg[43].answer);
if (LastGal < FirstGal)
{
p_info(PI_ELOG, "ERROR - Last galley number (%s) less than first galley number (%s), defaulting to all galleys.\n",
msg[43].answer, msg[42].answer);
FirstGal = 0;
LastGal = 1000000;
}
}
else
{
FirstGal = 0;
LastGal = 1000000;
}
} /* end if(msg[42].answer[0]) */
if (!FirstGal && !LastGal)
LastGal = 1000000;
} /* end if(!FileType) */
if ( msg[45].answer[0])
Proof = atoi(msg[45].answer);
else
Proof = 0;
if ( KeyOutputType && msg[46].answer[0])
Plates = (uint32 )atoi(msg[46].answer);
else
Plates = 0xffffffff;
if ( FileType && msg[47].answer[0] && !LYPrintFlag)
SupressBlankPages = atoi(msg[47].answer);
else
SupressBlankPages = 0;
if ( msg[48].answer[0])
Neg = atoi(msg[48].answer);
else
Neg = 0;
if ( msg[49].answer[0])
Mirror = atoi(msg[49].answer);
else
Mirror = 0;
if ( msg[50].answer[0] && !FileType) /* only allowed in galleys */
BcEcFlag = atoi(msg[50].answer); /* non-zero: use BcEc */
else
BcEcFlag = 0; /* Ignore BcEc for this job */
if ( msg[51].answer[0])
{
EditTraceFlag = atoi(msg[51].answer);
if ( (EditTraceFlag < 0) || (EditTraceFlag > 3) )
{
p_info(PI_ELOG, "ERROR - EditTrace '%s' invalid, defaulting to none.\n",
msg[51].answer);
EditTraceFlag = 0;
}
}
else
EditTraceFlag = 0;
EditTraceStarted = 0;
if ( EditTraceFlag)
{ /* only read parameters if needed. */
if ( msg[52].answer[0])
CurInsOffset = (int )(atof(msg[52].answer) * VerticalBase);
else
CurInsOffset = 1.25 * VerticalBase;
if ( msg[53].answer[0])
PreInsOffset = (int )(atof(msg[53].answer) * VerticalBase);
else
PreInsOffset = 2.75 * VerticalBase;
if ( msg[54].answer[0])
CurDelOffset = (int )(atof(msg[54].answer) * VerticalBase);
else
CurDelOffset = 2.25 * VerticalBase;
if ( msg[55].answer[0])
PreDelOffset = (int )(atof(msg[55].answer) * VerticalBase);
else
PreDelOffset = 3.75 * VerticalBase;
if ( msg[56].answer[0])
{
CurInsClr = atoi(msg[56].answer);
if(CurInsClr < -1)
CurInsClr = -1;
}
else
CurInsClr = 1;
if ( msg[57].answer[0])
{
PreInsClr = atoi(msg[57].answer);
if(PreInsClr < -1)
PreInsClr = -1;
}
else
PreInsClr = 1;
if ( msg[58].answer[0])
{
CurDelClr = atoi(msg[58].answer);
if(CurDelClr < -1)
CurDelClr = -1;
}
else
CurDelClr = 1;
if ( msg[59].answer[0])
{
PreDelClr = atoi(msg[59].answer);
if(PreDelClr < -1)
PreDelClr = -1;
}
else
PreDelClr = 1;
if ( msg[60].answer[0])
{
CurInsWeight = (atof(msg[60].answer) * VerticalBase);
if(CurInsWeight <= 0)
CurInsWeight = 1.; /* 1/10 point in VerticalBase units */
}
else
CurInsWeight = .1 * VerticalBase;
if ( msg[61].answer[0])
{
PreInsWeight = atof(msg[61].answer) * VerticalBase;
if(PreInsWeight <= 0)
PreInsWeight = 1.; /* 1/10 point in VerticalBase units */
}
else
PreInsWeight = .1 * VerticalBase;
} /* end if(EditTraceFlag) */
if ( msg[62].answer[0])
{
ChapterPage = atoi(msg[62].answer);
ChapterPageSetFlag = 0;
}
else
{
ChapterPage = 0;
ChapterPageSetFlag = 1;
}
if ( msg[63].answer[0])
IncludeScreens = atoi(msg[63].answer);
else
IncludeScreens = 1; /* If no keyword, set IncludeScreens to 1 */
if (msg[64].answer[0])
LPI = atoi(msg[64].answer);
else
LPI = 0; /* Use ColorTable */
if ( msg[65].answer[0]) /* Number of Copies */
NumCopies = atoi(msg[65].answer);
else
NumCopies = 1;
if ( msg[66].answer[0]) /* ClipPaths */
ClipPathFlag = atoi(msg[66].answer);
else
ClipPathFlag = 0;
if ( msg[67].answer[0]) /* Collate */
CollateFlag = atoi(msg[67].answer);
else
CollateFlag = 0;
if ( msg[69].answer[0]) /* Page width in inches */
PageWInch = atoi(msg[69].answer);
else
PageWInch = 0;
if ( msg[70].answer[0]) /* Page Depth in inches */
PageDInch = atoi(msg[70].answer);
else
PageDInch = 0;
if ( msg[71].answer[0]) /* Switch: Do galley breaks in pp/pq extracts */
DoExtractBreaks = atoi(msg[71].answer);
else
DoExtractBreaks = 1;
if ( msg[120].answer[0]) /* 1= Distill to PDF (done by .psh script)
0= don't */
DistillFlag = atoi(msg[120].answer);
else
DistillFlag = 0;
if ( msg[121].answer[0] && lnumbers)
/* += Put out line stats w/ line# (galley md only)
5+=Do so, and use val as their pt-size.
0= don't */
LineStats = atoi(msg[121].answer);
else
LineStats = 0;
return(0);
} /* end function */
int git_futils_readbuffer_updated(git_buf *buf, const char *path, time_t *mtime, int *updated)
{
git_file fd;
size_t len;
struct stat st;
assert(buf && path && *path);
if (updated != NULL)
*updated = 0;
if ((fd = git_futils_open_ro(path)) < 0)
return fd;
if (p_fstat(fd, &st) < 0 || S_ISDIR(st.st_mode) || !git__is_sizet(st.st_size+1)) {
p_close(fd);
giterr_set(GITERR_OS, "Invalid regular file stat for '%s'", path);
return -1;
}
/*
* If we were given a time, we only want to read the file if it
* has been modified.
*/
if (mtime != NULL && *mtime >= st.st_mtime) {
p_close(fd);
return 0;
}
if (mtime != NULL)
*mtime = st.st_mtime;
len = (size_t) st.st_size;
git_buf_clear(buf);
if (git_buf_grow(buf, len + 1) < 0) {
p_close(fd);
return -1;
}
buf->ptr[len] = '\0';
while (len > 0) {
ssize_t read_size = p_read(fd, buf->ptr, len);
if (read_size < 0) {
p_close(fd);
giterr_set(GITERR_OS, "Failed to read descriptor for '%s'", path);
return -1;
}
len -= read_size;
buf->size += read_size;
}
p_close(fd);
if (updated != NULL)
*updated = 1;
return 0;
}
void test_pack_indexer__fix_thin(void)
{
git_indexer *idx = NULL;
git_transfer_progress stats = { 0 };
git_repository *repo;
git_odb *odb;
git_oid id, should_id;
cl_git_pass(git_repository_init(&repo, "thin.git", true));
cl_git_pass(git_repository_odb(&odb, repo));
/* Store the missing base into your ODB so the indexer can fix the pack */
cl_git_pass(git_odb_write(&id, odb, base_obj, base_obj_len, GIT_OBJ_BLOB));
git_oid_fromstr(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18");
cl_assert_equal_oid(&should_id, &id);
cl_git_pass(git_indexer_new(&idx, ".", 0, odb, NULL, NULL));
cl_git_pass(git_indexer_append(idx, thin_pack, thin_pack_len, &stats));
cl_git_pass(git_indexer_commit(idx, &stats));
cl_assert_equal_i(stats.total_objects, 2);
cl_assert_equal_i(stats.received_objects, 2);
cl_assert_equal_i(stats.indexed_objects, 2);
cl_assert_equal_i(stats.local_objects, 1);
git_oid_fromstr(&should_id, "fefdb2d740a3a6b6c03a0c7d6ce431c6d5810e13");
cl_assert_equal_oid(&should_id, git_indexer_hash(idx));
git_indexer_free(idx);
git_odb_free(odb);
git_repository_free(repo);
/*
* The pack's name/hash only tells us what objects there are,
* so we need to go through the packfile again in order to
* figure out whether we calculated the trailer correctly.
*/
{
unsigned char buffer[128];
int fd;
ssize_t read;
struct stat st;
const char *name = "pack-fefdb2d740a3a6b6c03a0c7d6ce431c6d5810e13.pack";
fd = p_open(name, O_RDONLY);
cl_assert(fd != -1);
cl_git_pass(p_stat(name, &st));
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL, NULL));
read = p_read(fd, buffer, sizeof(buffer));
cl_assert(read != -1);
p_close(fd);
cl_git_pass(git_indexer_append(idx, buffer, read, &stats));
cl_git_pass(git_indexer_commit(idx, &stats));
cl_assert_equal_i(stats.total_objects, 3);
cl_assert_equal_i(stats.received_objects, 3);
cl_assert_equal_i(stats.indexed_objects, 3);
cl_assert_equal_i(stats.local_objects, 0);
git_indexer_free(idx);
}
}
