Exemple #1
0
    void nullpointer1()
    {
        checkNullPointer("int foo(const Token *tok)\n"
                         "{\n"
                         "    while (tok);\n"
                         "    tok = tok->next();\n"
                         "}\n");
        ASSERT_EQUALS("[test.cpp:4]: (error) Possible null pointer dereference\n", errout.str());

        checkNullPointer("void foo()\n"
                         "{\n"
                         "    for (const Token *tok = tokens; tok; tok = tok->next())\n"
                         "    {\n"
                         "        while (tok && tok->str() != \";\")\n"
                         "            tok = tok->next();\n"
                         "    }\n"
                         "}\n");
        ASSERT_EQUALS("[test.cpp:3]: (error) Possible null pointer dereference\n", errout.str());

        checkNullPointer("void foo()\n"
                         "{\n"
                         "    for (const Token *tok = tokens; tok; tok = tok ? tok->next() : NULL)\n"
                         "    {\n"
                         "        while (tok && tok->str() != \";\")\n"
                         "            tok = tok->next();\n"
                         "    }\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());
    }
Exemple #2
0
    // Dereferencing a pointer and then checking if it is null
    void nullpointer4()
    {
        // errors..
        checkNullPointer("void foo(int *p)\n"
                         "{\n"
                         "    *p = 0;\n"
                         "    if (!p)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("[test.cpp:3]: (error) Possible null pointer dereference\n", errout.str());

        // no error
        checkNullPointer("void foo()\n"
                         "{\n"
                         "    int *p;\n"
                         "    f(&p);\n"
                         "    if (!p)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        checkNullPointer("void foo()\n"
                         "{\n"
                         "    int **p = f();\n"
                         "    if (!p)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        checkNullPointer("void foo(int *p)\n"
                         "{\n"
                         "    if (x)\n"
                         "        p = 0;\n"
                         "    else\n"
                         "        *p = 0;\n"
                         "    if (!p)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        checkNullPointer("void foo(int x)\n"
                         "{\n"
                         "    int a = 2 * x;"
                         "    if (x == 0)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());
    }
Exemple #3
0
void Card::setStatic()
{
    if(state->isActive())
    {
        delete state;
        CardState *nState = new CardStateStatic(this);
        checkNullPointer(nState);
        state = nState;
    }
}
Exemple #4
0
 void nullpointer2()
 {
     // Null pointer dereference can only happen with pointers
     checkNullPointer("void foo()\n"
                      "{\n"
                      "    Fred fred;\n"
                      "    while (fred);\n"
                      "    fred.hello();\n"
                      "}\n");
     ASSERT_EQUALS("", errout.str());
 }
Exemple #5
0
Card::Card(unsigned short num, GameWindow *window, QWidget *parent)
    : QWidget(parent),
      number(num), gameWindow(window)
{
    state = new CardStateStatic(this);
    checkNullPointer(state);

    std::string path = std::string(Card::IMG_PATH) + std::to_string(number) + std::string(Card::IMG_EXT);

    QPixmap logo(path.c_str());
    logo = logo.scaledToHeight(Card::DEFAULT_HEIGHT);

    int height = logo.height(),
        width = logo.width();
    resize(width, height);

    label = new QLabel(this);
    checkNullPointer(label, [=]() {
        delete state;
    });
    label->setGeometry(0, 0, width, height);
    label->setPixmap(logo);
    label->show();
}
Exemple #6
0
/* read one or more query files specified with an option -i */
void getFileNames(int argc, char *argv[], char list[], char c, char ***fileNames, int *cntFiles, int *arg) {
  char **r;
  int numberOfFiles = 1;

  // get all file names (supposition: file name cannot start with -)
  while ((*arg + numberOfFiles) < argc && argv[*arg + numberOfFiles][0] != '-') {
    *fileNames = (char **)erealloc(*fileNames, numberOfFiles * sizeof (char *));
    r = *fileNames;
    r[numberOfFiles - 1] = argv[*arg + numberOfFiles];
    checkNullPointer(c, r[numberOfFiles - 1]);
    ++ numberOfFiles;
  }
  *cntFiles = numberOfFiles - 1; // set the argument
  checkMultipleArgDef(list, c);
	
  // position of the new argument (-1 because arg is increased by 1 as the last step of while loop)
  *arg = *arg + numberOfFiles - 1;
}
Exemple #7
0
Args *getArgs(int argc, char *argv[]){
  Args *args;
  //	char **r;
  char c;
  int arg;
  //	int numberOfFiles;
  char list[256] = {0}; // options are not yet set

  args = (Args *)emalloc(sizeof(Args));

  args->i = NULL;
  args->j = NULL;
  args->o = NULL;
  args->h = 0;
  args->p = 0;  
  args->e = 0;
  args->d = NULL;
  args->n = NAMELENGTH;
  args->D = DEFAULT_D;
  args->w = DEFAULT_W;
  args->c = 0; 
  args->q = 10000;
  args->W = NULL;
  args->P = 1-DEFAULT_P;
  args->v = 0;
  arg = 1;
  args->m = DEFAULT_M;
  args->t = 0;
  args->r = 0;
  args->s = 0;
  args->f = -1;

  // if none of the options is set as an argument, then take o1
  args->o1 = 0;
  args->o2 = 0;
  args->I = NULL;
  args->M = 0; // default min window sum to be considered relevant

  while(arg < argc){
    c = argv[arg][1];
    switch (c){
    case 'i':                           /* query file; if the option -d is included */ 
      checkNullPointer(c, argv[arg]);
      //args->i = argv[arg];            /* then search for the query file: (1) in the program's dir (2) in the directory specified with -d*/
      // read one or more query files specified with an option -i
      getFileNames(argc, argv, list, c, &args->i, &args->queryFileNumber, &arg);
      break;
				      
    case 'j':                           /* subject files */
      /* check that -d and -j option are used mutually exclusive! */
      if (args->d) {
	eprintf("Options -d and -j are mutually exclusive");
      }
      else {
	getFileNames(argc, argv, list, c, &args->j, &args->subjectFileNumber, &arg);
	break;
      }

    case 'd':                           /* directory where the subject files are saved and possibly the query file */
      if (args->j) {
	eprintf("Options -d and -j are mutually exclusive");
      }
      else {
	args->d = argv[++arg];
	checkNullPointer(c, args->d);
	checkMultipleArgDef(list, c);
	break;
      }

    case 'o':                           /* output file */
      checkNullPointer(c, argv[++arg]);
      args->o = argv[arg];
      checkMultipleArgDef(list, c);
      break;

    case 'n':                            /* number of characters from header line printed */
      checkNullPointer(c, argv[++arg]);
      args->n = atoi(argv[arg]);
      if(args->n < 0) {
	args->n = INT_MAX;
      }
      checkMultipleArgDef(list, c);
      break;

    case 'D':                            /* maximum depth of suffix tree */
      args->D = atoi(argv[++arg]);
      checkNullPointer(c, argv[arg]);
      checkMultipleArgDef(list, c);
      break;
				
    case 'w':                             /* window width and window increment */
      checkNullPointer(c, argv[++arg]);
      args->w = atoi(argv[arg]);
      checkMultipleArgDef(list, c);
      break;
			
    case 'c':                             /* sliding window increment */
      checkNullPointer(c, argv[++arg]);
      args->c = atoi(argv[arg]);
      checkMultipleArgDef(list, c);
      break;

    case 'v':                           /* print program version test */
      args->v = 1;
      break;
      
    case 'h':                           /* print help */
      args->h = 1;
      break;

    case 'W':                            /* output file where window analysis for all subjects are printed */
      args->W = argv[++arg];
      checkNullPointer(c, args->W);
      checkMultipleArgDef(list, c);
      break;

    case 'P':                            /* fraction of random shustrings excluded from analysis */
      args->P = atof(argv[++arg]);
      if (args->P < 0) {
	args->P = 0;
      }
      else if(args->P > 1) {
	args->P = 1;
      }
      args->P = 1 - args->P;
      break;

    case 'q':                            /* fast search - size of mini list*/
      args->q = atol(argv[++arg]);
      if (args->q < 0) {
	args->q = 1000;
      }
      break;

    case 'm':                            /* multiplier for maxshulen by chance alone -- used for defining significant intervals */
      args->m = atol(argv[++arg]);
      if (args->m < 0) {
	args->m = DEFAULT_M;
      }
      break;

    case 't':                           /* print run-time information */
      args->t = 1;
      break;

    case 'r':                           /* print runner(s)-up information */
      args->r = 1;
      break;

    case 'f':                            /* minimal length of recombination fragment */
      args->f = atoi(argv[++arg]);
      //if (args->f < 0) {
      //	args->f = (int)args->w;
      //}
      break;

    case 'o1':                           /* each annotation has the same subject set over all windows within annotation */
      args->o1 = 1;
      break;

    case 'o2':                           /* subject set of an annotation is a subset of all windows within annotation */
      args->o2 = 1;
      break;


    case 'M':                           /* minimal sum: max shulen by chance alone x window size */
      args->M = 1;
      break;

    case 'I':                            /* name of input file that contains list of intervals; used for windows analysis based on precomputed intervals */
      args->I = argv[++arg];
      checkNullPointer(c, args->I);
      checkMultipleArgDef(list, c);
      break;

    default:
      printf("# unknown argument: %c\n", c);
      args->e = 1;
      return args;
    } // end switch
		
    arg++;  
  } // end while

  // allowed stdin?
  // if (!args->i) {
  //   printf("ERROR[gt]: Query file must be specified using -i option!\n");
  //   args->e = 1;
  //}
  if (args->c == 0) {
    args->c = (int)((float)args->w/10. + 0.5);
  }
  if (args->f < 0) {
    //args->f = (int)args->c;
    args->f = (int)((float)args->w / 4. + 0.5);
  }

  if (args->w < args->c) {
    printf("ERROR: Sliding window increment is greater than window size\n");
    args->e = 1;
  }

  if (!args->o1 && !args->o2) {
    args->o1 = 1; // when none of the options is set, set o1 as default
  }
  else if (args->o1 && args->o2) {
    printf("ERROR: Options 1 and 2 are mutually exclusive\n");
    args->e = 1;
  }

  if (args->o && args->I) {
    printf("Interval analysis exists, so it won't be computed again (-o will be ignored)\n");
  }

  return args;
}
extern "C" JNIEXPORT int
JVM_handle_linux_signal(int sig,
                        siginfo_t* info,
                        void* ucVoid,
                        int abort_if_unrecognized) {
  // in fact this isn't ucontext_t* at all, but struct sigcontext*
  // but Linux porting layer uses ucontext_t, so to minimize code change
  // we cast as needed
  ucontext_t* ucFake = (ucontext_t*) ucVoid;
  sigcontext* uc = (sigcontext*)ucVoid;

  Thread* t = ThreadLocalStorage::get_thread_slow();

  SignalHandlerMark shm(t);

  // Note: it's not uncommon that JNI code uses signal/sigset to install
  // then restore certain signal handler (e.g. to temporarily block SIGPIPE,
  // or have a SIGILL handler when detecting CPU type). When that happens,
  // JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To
  // avoid unnecessary crash when libjsig is not preloaded, try handle signals
  // that do not require siginfo/ucontext first.

  if (sig == SIGPIPE || sig == SIGXFSZ) {
    // allow chained handler to go first
    if (os::Linux::chained_handler(sig, info, ucVoid)) {
      return true;
    } else {
      if (PrintMiscellaneous && (WizardMode || Verbose)) {
        char buf[64];
        warning("Ignoring %s - see bugs 4229104 or 646499219",
                os::exception_name(sig, buf, sizeof(buf)));
      }
      return true;
    }
  }

  JavaThread* thread = NULL;
  VMThread* vmthread = NULL;
  if (os::Linux::signal_handlers_are_installed) {
    if (t != NULL ){
      if(t->is_Java_thread()) {
        thread = (JavaThread*)t;
      }
      else if(t->is_VM_thread()){
        vmthread = (VMThread *)t;
      }
    }
  }

  // decide if this trap can be handled by a stub
  address stub = NULL;
  address pc = NULL;
  address npc = NULL;

  //%note os_trap_1
  if (info != NULL && uc != NULL && thread != NULL) {
    pc = address(SIG_PC(uc));
    npc = address(SIG_NPC(uc));

    // Check to see if we caught the safepoint code in the
    // process of write protecting the memory serialization page.
    // It write enables the page immediately after protecting it
    // so we can just return to retry the write.
    if ((sig == SIGSEGV) && checkSerializePage(thread, (address)info->si_addr)) {
      // Block current thread until the memory serialize page permission restored.
      os::block_on_serialize_page_trap();
      return 1;
    }

    if (checkPrefetch(uc, pc)) {
      return 1;
    }

    // Handle ALL stack overflow variations here
    if (sig == SIGSEGV) {
      if (checkOverflow(uc, pc, (address)info->si_addr, thread, &stub)) {
        return 1;
      }
    }

    if (sig == SIGBUS &&
        thread->thread_state() == _thread_in_vm &&
        thread->doing_unsafe_access()) {
      stub = StubRoutines::handler_for_unsafe_access();
    }

    if (thread->thread_state() == _thread_in_Java) {
      do {
        // Java thread running in Java code => find exception handler if any
        // a fault inside compiled code, the interpreter, or a stub

        if ((sig == SIGSEGV) && checkPollingPage(pc, (address)info->si_addr, &stub)) {
          break;
        }

        if ((sig == SIGBUS) && checkByteBuffer(pc, &stub)) {
          break;
        }

        if ((sig == SIGSEGV || sig == SIGBUS) &&
            checkVerifyOops(pc, (address)info->si_addr, &stub)) {
          break;
        }

        if ((sig == SIGSEGV) && checkZombie(uc, &pc, &stub)) {
          break;
        }

        if ((sig == SIGILL) && checkICMiss(uc, &pc, &stub)) {
          break;
        }

        if ((sig == SIGFPE) && checkFPFault(pc, info->si_code, thread, &stub)) {
          break;
        }

        if ((sig == SIGSEGV) &&
            checkNullPointer(pc, (intptr_t)info->si_addr, thread, &stub)) {
          break;
        }
      } while (0);

      // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in
      // and the heap gets shrunk before the field access.
      if ((sig == SIGSEGV) || (sig == SIGBUS)) {
        checkFastJNIAccess(pc, &stub);
      }
    }

    if (stub != NULL) {
      // save all thread context in case we need to restore it
      thread->set_saved_exception_pc(pc);
      thread->set_saved_exception_npc(npc);
      set_cont_address(uc, stub);
      return true;
    }
  }

  // signal-chaining
  if (os::Linux::chained_handler(sig, info, ucVoid)) {
    return true;
  }

  if (!abort_if_unrecognized) {
    // caller wants another chance, so give it to him
    return false;
  }

  if (pc == NULL && uc != NULL) {
    pc = os::Linux::ucontext_get_pc((ucontext_t*)uc);
  }

  // unmask current signal
  sigset_t newset;
  sigemptyset(&newset);
  sigaddset(&newset, sig);
  sigprocmask(SIG_UNBLOCK, &newset, NULL);

  VMError err(t, sig, pc, info, ucVoid);
  err.report_and_die();

  ShouldNotReachHere();
}
Exemple #9
0
    // Dereferencing a struct and then checking if it is null
    void nullpointer3()
    {
        // errors..
        checkNullPointer("void foo(struct ABC *abc)\n"
                         "{\n"
                         "    int *a = abc->a;\n"
                         "    if (!abc)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("[test.cpp:3]: (error) Possible null pointer dereference\n", errout.str());

        // ok dereferencing in a condition
        checkNullPointer("void foo(struct ABC *abc)\n"
                         "{\n"
                         "    if (abc && abc->a);\n"
                         "    if (!abc)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        // ok to use a linked list..
        checkNullPointer("void foo(struct ABC *abc)\n"
                         "{\n"
                         "    abc = abc->next;\n"
                         "    if (!abc)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        // reassign struct..
        checkNullPointer("void foo(struct ABC *abc)\n"
                         "{\n"
                         "    a = abc->a;\n"
                         "    abc = abc->next;\n"
                         "    if (!abc)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        checkNullPointer("void foo(struct ABC *abc)\n"
                         "{\n"
                         "    a = abc->a;\n"
                         "    f(&abc);\n"
                         "    if (!abc)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        // goto..
        checkNullPointer("void foo(struct ABC *abc)\n"
                         "{\n"
                         "    if (!abc)\n"
                         "        goto out;"
                         "    a = abc->a;\n"
                         "    return;\n"
                         "out:\n"
                         "    if (!abc)\n"
                         "        ;\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        // loops..
        checkNullPointer("void freeAbc(struct ABC *abc)\n"
                         "{\n"
                         "    while (abc)\n"
                         "    {\n"
                         "        struct ABC *next = abc->next;\n"
                         "        if (abc) delete abc;\n"
                         "        abc = next;\n"
                         "    }\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());

        checkNullPointer("void foo(struct ABC *abc)\n"
                         "{\n"
                         "    int a = abc->a;"
                         "    do\n"
                         "    {\n"
                         "        if (abc)\n"
                         "            abc = abc->next;\n"
                         "        --a;\n"
                         "    }\n"
                         "    while (a > 0)\n"
                         "}\n");
        ASSERT_EQUALS("", errout.str());
    }
Exemple #10
0
void checkMultipleArgDef(char list[], char c) {
#elif WIN
static void checkMultipleArgDef(char list[], char c) {
#endif

	if(!list[(int)c]){
	  list[(int)c] = 1;
	}
	else {
	  printf("Warning: -%c multiply defined\n", c); // or error ???????
  }
}

/* check whether an argument is a null pointer */
#if UNIX
void checkNullPointer(char c, char *arg) {	
#elif WIN
static void checkNullPointer(char c, char *arg) {	
#endif

	if (!arg) {
		eprintf("[ERROR] Option -%c: argument is NULL!\n", c);
	}
}



Args *getArgs(int argc, char *argv[]){
  Args *args;
	char **r;
  char c;
  int arg = 1;
	int numberOfFiles = 0;
	char list[256] = {0}; // options are not yet set

  args = (Args *)emalloc(sizeof(Args));

  args->j = NULL;
  args->o = NULL;
  args->h = 0;
	args->p = 0;  
  args->e = 0;
  args->t = 0;
  args->g = 0;
	args->d = NULL;
	args->n = NULL;
  args->D = DEFAULT_D;
	args->subjectFileNumber = 0;
  
	/* Parameters for the divergence calculation */
	/* When this values are all set to 0, then the Kr results are the same as for the original divergence calculation from the old kr program */
	/* These default values are set to increase the speed of the divergence calculation, with keeping the Kr results with relative error < 1%*/
	args->E = DEFAULT_E;
  args->T = DEFAULT_T;
  args->M = DEFAULT_M;
  
	//args->P = 0.5;  
	/* best tree results ? with args->P == 0 */
	args->P = 0;

	if (arg == argc) {
		return args;
	}

	while (arg < argc) {

		if (argv[arg][0] == '-') {
			c = argv[arg][1];
			switch (c) {
				case 'j':                           /* subject files */
					/* check that -d and -j option are used mutually exclusive! */
					if (args->d) {
						eprintf("Options -d and -j are mutually exclusive!");
					}
					else if (numberOfFiles > 0) {
						eprintf("Input files were already defined!");
					}
					else {
						// get all query subject names
						// (supposition: file name cannot start with -)
						numberOfFiles = 1;
						while ((arg + numberOfFiles) < argc && argv[arg + numberOfFiles][0] != '-') {
							args->j = (char **)erealloc(args->j, numberOfFiles * sizeof (char *));
							r = args->j;
							r[numberOfFiles - 1] = argv[arg + numberOfFiles];
							checkNullPointer(c, r[numberOfFiles - 1]);
							++ numberOfFiles;
						}
						args->subjectFileNumber = numberOfFiles - 1; // set the argument
						if (args->subjectFileNumber == 0) {
							checkNullPointer(c, NULL);
						}
						checkMultipleArgDef(list, c);
						
						// position of the new argument (-1 because arg is increased by 1 as the last step of while loop)
						arg = arg + numberOfFiles - 1;
						break;
					}

				case 'd':                           /* directory where the subject files are saved and possibly the query file */
					if (args->j) {
						eprintf("Options -d and -j are mutually exclusive!");
					}
					else {
						args->d = argv[++arg];
						if (args->d[0] == '-') {
							args->d = NULL;
						}
						checkNullPointer(c, args->d);
						checkMultipleArgDef(list, c);
						break;
					}

				case 'o':                           /* output file */
					checkNullPointer(c, argv[++arg]);
					args->o = argv[arg];
					checkMultipleArgDef(list, c);
					break;

				case 'n':                           /* output file - phylip/neighbor format */
					checkNullPointer(c, argv[++arg]);
					args->n = argv[arg];
					checkMultipleArgDef(list, c);
					break;

					//case 'n':                            /* number of characters from header line printed */
				//	checkNullPointer(c, argv[++arg]);
				//	args->n = atoi(argv[arg]);
				//	if(args->n < 0) {
				//		args->n = INT_MAX;
				//	}
		 //     checkMultipleArgDef(list, c);
			//    break;

				case 'D':                            /* maximum depth of suffix tree */
					args->D = atoi(argv[++arg]);
					checkNullPointer(c, argv[arg]);
					checkMultipleArgDef(list, c);
					break;

				case 'p':                           /* print program information test */
					args->p = 1;
					break;

				case 'g':                           /* use global GC content */
					args->g = 1;
					break;
	      
				case 'h':                           /* print help */
					args->h = 1;
					break;
							
				case 't':                           /* print run-time */
					args->t = 1;
					break;

				case 'P':                            /* fraction of random shustrings excluded from analysis */
					args->P = atof(argv[++arg]);
					if (args->P < 0) {
						args->P = 0;
					}
					else if(args->P > 1) {
						args->P = 1;
					}
					break;

				/* parameters for the divergence calculation */
				case 'E':                            /* function divergence: errd */
					args->E = atof(argv[++arg]);
					if (args->E < 0) {
						args->E = 0;
					}
					else if (args->E > 1) {
						args->E = DEFAULT_E;
					}
					break;

				case 'T':                            /* function expShulen: t1 */
					args->T = atof(argv[++arg]);
					if (args->T < 0) {
						args->T = 0;
					}
					else if (args->T > 1) {
						args->T = DEFAULT_T;
					}
					break;

				case 'M':                            /* function pmax: m_t */
					args->M = atof(argv[++arg]);
					if (args->M < 0) {
						args->M = 0;
					}
					else if (args->M > 1) {
						args->M = DEFAULT_M;
					}
					break;

				default:
					printf("# unknown argument: %c\n", c);
					args->e = 1;
					return args;
			} // end switch
		}
		else {
			// get all query subject names - "fake" option '*'
			// (supposition: file name cannot start with -)
			numberOfFiles = 0;
			while (arg < argc && argv[arg][0] != '-') {
				args->j = (char **)erealloc(args->j, (numberOfFiles + 1)* sizeof (char *));
				r = args->j;
				r[numberOfFiles] = argv[arg];
				checkNullPointer('*', r[numberOfFiles]);
				++ numberOfFiles;
				++ arg;
			}
			args->subjectFileNumber = numberOfFiles; // set the argument
			if (args->subjectFileNumber == 0) {
				checkNullPointer('*', NULL);
			}
			checkMultipleArgDef(list, '*');
			
			// position of the new argument (-1 because arg is increased by 1 as the last step of while loop, and -1 because it again increases in the while-loop)
			arg = arg - 1;		
		}

		arg++;  
	} 
	return args;
}


void printUsage(char *version){
  printf("kr version %s ", version);
  printf("distributed under the GNU General Public License.\n");
  printf("purpose: estimate pairwise distances, K_r, from DNA sequences\n");
	printf("usage: %s [options] [filenames]\n", progname());
  printf("   or: %s [options] -j <FILE(s)> \n", progname());
  printf("   or: %s [options] -d <DIRECTORY> \n", progname());
  printf("options:\n");
  printf("\t[-o <FILE> write output to FILE; default: FILE=stdout]\n");  
  printf("\t[-n <FILE> write detailed output to FILE]\n");  
  printf("\t[-t print run-time in the detailed output file; printed only when option -n is used]\n");
  
	printf("\t[-D <NUM> maximum depth of suffix tree; default: %d]\n", DEFAULT_D);
	printf("\t[-P <NUM> fraction of random shustrings excluded from analysis; P e [0, 1]; default: 0]\n");  
  
	printf("\t[-E <NUM> relative divergence error; default: %lf]\n", DEFAULT_E);
	printf("\t[-T <NUM> relative error of the average shustring length; default: %lf]\n", DEFAULT_T);
	printf("\t[-M <NUM> threshold for small values of logarithm; default: %lf]\n", DEFAULT_M);
	printf("\t[-g use global GC content (fast); default: use pairwise GC content (slow, accurate)]\n");
	printf("\t[-p print information about program]\n");			     
  printf("\t[-h print this help message]\n");
}