int main(int argc, char **argv){
if(argc == 3)
{
char netbuffer[16];
char maskbuffer[16];
uint32_t number, numbermask;
int result = readnumber(argv[1], &number);
if(result != 1)
{
fprintf(stderr, "%s needs two arguments (unsigned int)\n", argv[0]);
exit(-1);
}
result = readnumber(argv[2], &numbermask);
if(result != 1)
{
fprintf(stderr, "%s needs two arguments (unsigned int)\n", argv[0]);
exit(-1);
}
uint32_t mask = numbertonetmask(numbermask, maskbuffer);
numbertosubnet(number, mask, netbuffer);
printf("Network is %s\n, ", netbuffer);
printf("Mask is %s\n", maskbuffer);
} else {
fprintf(stderr, "%s needs two arguments (unsigned int)\n", argv[0]);
exit(-1);
}
}
static void
parse_number(void)
{
unreadch();
push_number(readnumber(&bmachine.readstack[bmachine.readsp],
bmachine.ibase));
}
void select_insert(unsigned int* number_of_nodes)
{
unsigned int select = 0;
do{
printf("\n\navailable insert options are:\n");
printf("0\tcancel\n");
printf("1\tpopulate\n");
printf("2\tinsert an element\n");
readdigit(&select, "select an operation:");
if(1 == select){
if(0 == *number_of_nodes){
puts("the tree is empty, first create a tree root\nfailed.");
}else if(1 <= *number_of_nodes){
unsigned int number=0;
do{
readnumber(&number, NUM_OF_NODES_DIGITS, "enter a number of nodes");
}while((number < 0) || (number > MAX_NODES));
populate_tree(number_of_nodes, number);
printf("the tree was populated and now contains %d elements\ndone.\n", *number_of_nodes);
}else{
printf("%d elements\nfailed.\n", *number_of_nodes);
}
break;
}else if(2 == select){
if(0 == *number_of_nodes){
puts("the tree is empty, first create a tree root");
}else if(MAX_NODES == *number_of_nodes){
printf("the tree is stuffed, it already contains %d nodes, (max. %d nodes possible)\n", *number_of_nodes, MAX_NODES);
}else{
puts("enter a data value for the new node");
if(0 > add_element(number_of_nodes)){
puts("failed.");
}else{
printf("%d elements\ndone.\n", *number_of_nodes);
}
}
break;
}
}while(0 != select);
}
static int
readserie(int first, number **head)
{
int cur = first;
int length = 0;
number *next;
number **tail = head;
while ((next = readnumber(cur - '0', &cur)) != (number *)0) {
*tail = next;
tail = &next->next;
length++;
while ((cur != EOF) && !isdigit(cur)) {
if (cur == '\n') {
curline++;
} else if (cur == '.') {
return length;
}
cur = fgetc(fpin);
}
}
return length;
}
int main(int argc, char** argv)
{
// shm_key
key_t shm_key;
readlongnumber((unsigned long*) &shm_key, KEY_SIZE, "enter a key for the shared memory with up to 7 digits:");
// size
unsigned int size;
readnumber(&size, KEY_SIZE, "enter a size of shared memory");
// shm_flag
int shm_flag;
{
unsigned int tmp_flag=0;
do{
tmp_flag = 0;
puts("1\tIPC_CREAT");
puts("2\tIPC_EXCL");
puts("3\towner read");
puts("4\towner write");
puts("5\tgroup read");
puts("6\tgroup write");
puts("7\tother read");
puts("8\tother write");
readdigit(&tmp_flag, "set the flag:");
}while( (1 > tmp_flag) || (8 < tmp_flag));
switch (tmp_flag){
case 1:
puts("IPC_CREAT");
shm_flag = IPC_CREAT;
break;
case 2:
puts("IPC_EXCL");
shm_flag = IPC_EXCL;
break;
case 3:
fprintf(stderr, "owner read (%#8.8o)\n", 0400);
shm_flag = 0400;
break;
case 4:
fprintf(stderr, "owner write (%#8.8o)\n", 0200);
shm_flag = 0200;
break;
case 5:
fprintf(stderr, "group read (%#8.8o)\n", 040);
shm_flag = 040;
break;
case 6:
fprintf(stderr, "group write (%#8.8o)\n", 020);
shm_flag = 020;
break;
case 7:
fprintf(stderr, "other read (%#8.8o)\n", 04);
shm_flag = 04;
break;
case 8:
fprintf(stderr, "owner read (%#8.8o)\n", 02);
shm_flag = 02;
break;
default:
puts("try again");
break;
}
}
// shmget
fprintf(stderr, "shmget(%ld, %d, %#o)\n", (long) shm_key, size, shm_flag);
int shm_id;
if(-1 == (shm_id = shmget(shm_key, size, shm_flag))){
perror("shmget failed");
exit(EXIT_FAILURE);
}else{
fprintf(stderr, "shmget returned %d\n", shm_id);
}
puts("READY.");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int ii=0, ncol=0, nrow=0, nl=0, nc=0, posi=0, posj=0, posk=0;
//int nclust=atoi(argv[2]);
MRI_IMAGE *im = NULL;
double *dar = NULL;
double **D = NULL;
//int **mask = NULL;
double** distmatrix = NULL;
//from command.c
int i = 1;
char* filename = 0;
char* jobname = 0;
int l = 0;
int k = 0;
int kh = 3;
int r = 1;
int s = 0;
int x = 2;
int y = 1;
int Rows, Columns;
char distmetric = 'u';
char arraymetric = '\0';
char method = 'm';
char cg = '\0';
char ca = '\0';
int ng = 0;
int na = 0;
while (i < argc)
{ const char* const argument = argv[i];
i++;
if (strlen(argument)<2)
{ printf("ERROR: missing argument\n");
return 0;
}
if (argument[0]!='-')
{ printf("ERROR: unknown argument\n");
return 0;
}
if(!strcmp(argument,"--version") || !strcmp(argument,"-v"))
{ display_version();
return 0;
}
if(!strcmp(argument,"--help") || !strcmp(argument,"-h"))
{ display_help();
return 0;
}
if(!strcmp(argument,"-cg"))
{ if (i==argc || strlen(argv[i])>1 || !strchr("am",argv[i][0]))
{ printf ("Error reading command line argument cg\n");
return 0;
}
cg = argv[i][0];
i++;
continue;
}
if(!strcmp(argument,"-ca"))
{ if (i==argc || strlen(argv[i])>1 || !strchr("am",argv[i][0]))
{ printf ("Error reading command line argument ca\n");
return 0;
}
ca = argv[i][0];
i++;
continue;
}
if(!strcmp(argument,"-ng"))
{ ng = 1;
continue;
}
if(!strcmp(argument,"-na"))
{ na = 1;
continue;
}
switch (argument[1])
{ case 'l': l=1; break;
case 'u':
{ if (i==argc)
{ printf ("Error reading command line argument u: "
"no job name specified\n");
return 0;
}
jobname = setjobname(argv[i],0);
i++;
break;
}
case 'f':
{ if (i==argc)
{ printf ("Error reading command line argument f: "
"no file name specified\n");
return 0;
}
filename = argv[i];
i++;
break;
}
case 'g':
{ int g;
if (i==argc)
{ printf ("Error reading command line argument g: parameter missing\n");
return 0;
}
g = readnumber(argv[i]);
if (g < 0 || g > 9)
{ printf ("Error reading command line argument g: "
"should be between 0 and 9 inclusive\n");
return 0;
}
i++;
distmetric = getmetric(g);
break;
}
case 'k':
{ if (i==argc)
{ printf ("Error reading command line argument k: "
"parameter missing\n");
return 0;
}
k = readnumber(argv[i]);
if (k < 1)
{ printf ("Error reading command line argument k: "
"a positive integer is required\n");
return 0;
}
i++;
break;
}
case 'c':
{ if (i==argc)
{ printf ("Error reading command line argument h: parameter missing\n");
return 0;
}
kh = readnumber(argv[i]);
if (kh < 1)
{ printf ("Error reading command line argument h: a positive integer is required\n");
return 0;
}
i++;
break;
}
case 'r':
{ if (i==argc)
{ printf ("Error reading command line argument r: parameter missing\n");
return 0;
}
r = readnumber(argv[i]);
if (r < 1)
{ printf ("Error reading command line argument r: "
"a positive integer is required\n");
return 0;
}
i++;
break;
}
case 'm':
{ if (i==argc || strlen(argv[i])>1 || !strchr("msca",argv[i][0]))
{ printf ("Error reading command line argument m: should be 'm', 's', 'c', or 'a'\n");
return 0;
}
method = argv[i][0];
i++;
break;
}
default: printf ("Unknown option\n");
}
}
if(jobname==0) jobname = setjobname(filename,1);
/* else
{ display_help();
return 0;
}
*/
if (argc < 2) {
display_help();
return 0;
}
//printf("num of clusters %d \n",nclust);
fprintf(stderr,"Patience, reading %s...\n ", filename);
im = mri_read_double_1D (filename);
/* ZIAD I get this warning
Aclustering.c:408: warning: passing argument 1 of mri_read_double_1D
discards qualifiers from pointer target type
Andrej: filename was declared as (const char *),
but the function expects (char *) */
if (!im) {
fprintf(stderr,"Error: Failed to read matrix data from %s\n",
argv[2]);
return(-1);
}
ncol = im->ny;
nrow = im->nx;
fprintf (stderr,"Have %d cols, %d rows\nNow...\n", ncol, nrow);
/* now just get the array and kill the rest */
dar = MRI_DOUBLE_PTR(im);
/* make sure that pointer is set to NULL in im, or risk hell */
mri_clear_data_pointer(im);
if (im) mri_free(im); im = NULL; /* now kill im */
/* for double loop*/
D = (double **)calloc(sizeof(double*), nrow-1);
for (ii=0;ii<(nrow-1);++ii) {
D[ii] = (double *)calloc(sizeof(double), ncol-1);
}
for (nl=1; nl<nrow; ++nl) {
for (nc=1; nc<ncol; ++nc) {
D[nl-1][nc-1] = dar[nl+nc*nrow];
}
//fprintf(stdout,"\n");
}
//show_data(nrows, ncols, data, mask);
//example_mean_median(nrows, ncols, data, mask);
//distmatrix = example_distance_gene(nrows, ncols, data, mask);
//if (distmatrix) example_hierarchical(nrows, ncols, data, mask, distmatrix);
//example_distance_array(nrows, ncols, data, mask);
if(k>0) example_kmeans(nrow-1, ncol-1, D, k, r, distmetric, jobname);
else
{
distmatrix = example_distance_gene(nrow-1, ncol-1, D); // ZIAD: goes2 SIGKILL error
if (distmatrix)
example_hierarchical(nrow-1, ncol-1, D, jobname, kh, distmatrix);
}
free(dar); dar = NULL; /* done with input array */
// To free D
for (ii=0;ii<(nrow-1);++ii) {
if (D[ii]) free(D[ii]);
}
free(D);
free(jobname);
//free();
fprintf (stderr,"\n");
return 0;
}
int main(int argc, char** argv)
{
// in case generate shared memory to pointer area_addr
// address work area
char *area_addr = NULL;
// work area
register int area_id=0;
// ptr to current state entry
register struct state *pState=NULL;
// SIGSEGV state hold area func ptr
void (*savefunc) ();
// action to be performed
register int action=0;
while(0 != (action = ask())){
if(0 < nap){
fprintf(stderr, "currently attached segments");
fprintf(stderr, " shm_id address\n");
fprintf(stderr, "------- ---------\n");
pState = &attached_segments[nap+1];
while(--pState != attached_segments){
fprintf(stderr, "%6d", pState->shm_id);
fprintf(stderr, "%#11x", (unsigned int) pState->shm_addr);
fprintf(stderr, " Read%s\n", (pState->shm_flag & SHM_RDONLY) ? "-Only" : "/Write");
}
fprintf(stderr, "\n");
}else{
fprintf(stderr, "no segments are currently attached\n");
switch(action){
case 1:
// 1 - verify that there is space for another attach
if(nap == MAXnap){
fprintf(stderr, "this simple example will only allow %d attached segments\n", MAXnap);
break;
}
// get the arguments, make the call, report the result and update the current state array
pState = &attached_segments[++nap];
readnumber(&pState->shm_id, ID_DIGITS, "enter shm_id of segment to attach:");
readstring(pState->shm_addr, ADDR_DIGITS, "enter shm_addr");
fprintf(stderr, "meaningful shm_flag vlaues are:\n");
fprintf(stderr, "1\tSHM_RDONLY (%d)\n", SHM_RDONLY);
fprintf(stderr, "2\tSHM_RND (%d)\n", SHM_RND);
unsigned int select=0;
unsigned int askagain=0;
do{
askagain=0;
readdigit(&select, "select a shm_flag");
switch(select){
case 1:
puts("SHM_RDONLY");
pState->shm_flag = SHM_RDONLY;
break;
case 2:
puts("SHM_RND");
pState->shm_flag = SHM_RND;
break;
default:
puts("wrong input - try again");
askagain = 1;
break;
}
}while(askagain);
fprintf(stderr, "now attach the segment - shmat(%d, %#x, %#o)\n"
, pState->shm_id, (unsigned int) pState->shm_addr, pState->shm_flag);
if(0 > (pState->shm_addr = shmat(pState->shm_id, pState->shm_addr, pState->shm_flag))){
perror("shmat() failed");
--nap; // decrement, because already incremented above, for new pointer element!
}else{
fprintf(stderr, "shmat returned %#8.8x\n", (unsigned int) pState->shm_addr);
}
break;
case 2:
// 2 - shmdt requested
/*
get the address, make the call, report the results and make the
internal state match
//*/
readstring(area_addr, ADDR_DIGITS, "enter detach shm_addr");
if(-1 == (area_id = shmdt(area_addr))){
perror("shmdt failed");
}else{
fprintf(stderr, "shmdt returned %d\n", area_id);
for(pState = attached_segments, area_id = nap; --area_id; ++pState){
if(0 != (pState->shm_addr = area_addr))
*pState = attached_segments[--nap];
}
}
break;
case 3:
if(nap == 0) break;
readstring(area_addr, ADDR_DIGITS, "enter address of an attached segment");
if(good_addr(area_addr))
fprintf(stderr, "string @ %#x is '%s'\n",(unsigned int) area_addr, area_addr);
break;
case 4:
if(nap == 0) break;
readstring(area_addr, ADDR_DIGITS, "enter address of an attached segment");
/*
set up SIGSEGV signal handler to trap attempts to write into a read-only
attached segment
//*/
savefunc = signal(SIGSEGV, signalhandler);
if(setjmp(segvbuf)){
fprintf(stderr, "SIGSEGV signal caught: write aborted\n");
fflush(stdin);
signal(SIGSEGV, savefunc);
}else{
if(good_addr(area_addr)){
fflush(stdin);
readstring(area_addr, AREA_DIGITS, "enter one line to e copied to the shared segment attached");
// TODO: check
if(NULL == strncpy(pState->shm_addr, (char*) -1, sizeof(char*))){
perror("strncpy to shared memory failed");
break;
}
}
}
break;
}
}
}
// not reached
puts("READY.");
exit(EXIT_SUCCESS);
}
