Example #1
0
void
case_skiplist_pop()
{
    struct skiplist *skiplist = skiplist(NULL);
    struct skiplist_iter *iter = skiplist_iter(skiplist);
    assert(skiplist != NULL && iter != NULL);
    int v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5, v6 = 6, v7 = 7,
        v8 = 8, v9 = 9;
    assert(skiplist_push(skiplist, 3, (void *)(&v3)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 9, (void *)(&v9)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 7, (void *)(&v7)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 2, (void *)(&v2)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 6, (void *)(&v6)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 5, (void *)(&v5)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 8, (void *)(&v8)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 1, (void *)(&v1)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 4, (void *)(&v4)) == SKIPLIST_OK);
    assert(skiplist_len(skiplist) == 9);
    assert(skiplist_level(skiplist) > 0);
    assert(skiplist_last(skiplist)->score == 9);
    assert(skiplist_pop(skiplist, 3) == &v3);
    assert(skiplist_pop(skiplist, 4) == &v4);
    assert(skiplist_pop(skiplist, 9) == &v9);
    assert(skiplist_pop(skiplist, 1) == &v1);
    assert(skiplist_len(skiplist) == 5);
    assert(skiplist_first(skiplist)->score == 2);
    assert(skiplist->head->forwards[skiplist->level-1] != NULL);
    skiplist_iter_free(iter);
    skiplist_free(skiplist);
}
Example #2
0
void
case_skiplist_popfirst()
{
    struct skiplist *skiplist = skiplist(NULL);
    struct skiplist_iter *iter = skiplist_iter(skiplist);
    assert(skiplist != NULL && iter != NULL);
    int v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5, v6 = 6, v7 = 7,
        v8 = 8, v9 = 9;
    assert(skiplist_push(skiplist, 3, (void *)(&v3)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 9, (void *)(&v9)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 7, (void *)(&v7)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 2, (void *)(&v2)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 6, (void *)(&v6)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 5, (void *)(&v5)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 8, (void *)(&v8)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 1, (void *)(&v1)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 4, (void *)(&v4)) == SKIPLIST_OK);
    assert(skiplist_len(skiplist) == 9);
    assert(skiplist_level(skiplist) > 0);
    assert(skiplist_popfirst(skiplist) == &v1);
    assert(skiplist_popfirst(skiplist) == &v2);
    assert(skiplist_popfirst(skiplist) == &v3);
    assert(skiplist_popfirst(skiplist) == &v4);
    assert(skiplist_len(skiplist) == 5);
    assert(skiplist_level(skiplist) > 0);
    assert(skiplist->head->forwards[skiplist->level-1] != NULL);
    struct skiplist_node *first = skiplist_iter_next(iter);
    struct skiplist_node *second = skiplist_iter_next(iter);
    assert(first->score == 5);
    assert(second->score == 6);
    assert(first->backward == skiplist->head);
    assert(first->forwards[0] == second);
    assert(second->backward == first);
    assert(skiplist->tail != first && skiplist->tail != second);
    assert(skiplist_popfirst(skiplist) == &v5);
    assert(skiplist_popfirst(skiplist) == &v6);
    assert(skiplist_popfirst(skiplist) == &v7);
    assert(skiplist_popfirst(skiplist) == &v8);
    assert(skiplist_last(skiplist)->score == 9);
    assert(skiplist_popfirst(skiplist) == &v9);
    assert(skiplist_last(skiplist) == NULL);
    assert(skiplist_level(skiplist) == 1);
    assert(skiplist_len(skiplist) == 0);
    skiplist_iter_free(iter);
    skiplist_free(skiplist);
}
Example #3
0
// test WCValSkipList<int>
void test_val_skip_list() {
    WCValSkipList<int> skiplist( WCSKIPLIST_PROB_QUARTER
                               , WCDEFAULT_SKIPLIST_MAX_PTRS
                               , &val_skip_list_alloc
                               , &val_skip_list_dealloc );

    for( int i = 0; i < NumTestElems; i++ ) {
        skiplist.insert( test_elems[ i ] );
    }

    WCValSkipListIter<int> iter( skiplist );
    while( ++iter ) {
        cout << iter.current() << " ";
    }
    cout << "\n\n\n";
    skiplist.clear();
}
Example #4
0
void
case_skiplist_push()
{
    struct skiplist *skiplist = skiplist(NULL);
    struct skiplist_iter *iter = skiplist_iter(skiplist);
    assert(skiplist != NULL && iter != NULL);
    assert(skiplist_push(skiplist, 3, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 9, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 7, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 2, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 6, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 5, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 8, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 1, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 4, NULL) == SKIPLIST_OK);
    assert(skiplist_len(skiplist) == 9);
    assert(skiplist_level(skiplist) > 0);
    assert(skiplist_iter_next(iter)->score == 1);
    assert(skiplist_iter_next(iter)->score == 2);
    assert(skiplist_iter_next(iter)->score == 3);
    assert(skiplist_iter_next(iter)->score == 4);
    assert(skiplist_iter_next(iter)->score == 5);
    assert(skiplist_iter_next(iter)->score == 6);
    assert(skiplist_iter_next(iter)->score == 7);
    assert(skiplist_iter_next(iter)->score == 8);
    assert(skiplist_iter_next(iter)->score == 9);
    assert(skiplist_first(skiplist)->score == 1);
    assert(skiplist_last(skiplist)->score == 9);
    skiplist_iter_rewind(iter);
    struct skiplist_node *first = skiplist_iter_next(iter);
    struct skiplist_node *second = skiplist_iter_next(iter);
    struct skiplist_node *last = skiplist_last(skiplist);
    assert(skiplist->head->forwards[0] == first);
    assert(first != skiplist->head);
    assert(first->forwards[0] == second);
    assert(second->backward == first);
    assert(first->backward == skiplist->head);
    assert(last->backward != NULL);
    assert(last->forwards[0] == NULL);
    skiplist_iter_free(iter);
    skiplist_free(skiplist);
}
Example #5
0
void
case_skiplist_base()
{
    struct skiplist *skiplist = skiplist(NULL);
    assert(skiplist != NULL);
    assert(skiplist->len == 0);
    assert(skiplist->head != NULL);
    assert(skiplist->tail == skiplist->head);
    assert(skiplist->level == 1);
    assert(skiplist_push(skiplist, 2, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 1, NULL) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 3, NULL) == SKIPLIST_OK);
    assert(skiplist_len(skiplist) == 3);
    assert(skiplist_level(skiplist) <= SKIPLIST_LEVEL_MAX);
    assert(skiplist->tail->score == 3);
    skiplist_clear(skiplist);
    assert(skiplist_level(skiplist) == 1);
    assert(skiplist_len(skiplist) == 0);
    assert(skiplist->head != NULL);
    assert(skiplist->tail == skiplist->head);
    skiplist_free(skiplist);
}
Example #6
0
void
case_skiplist_get()
{
    struct skiplist *skiplist = skiplist(NULL);
    int v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5, v6 = 6, v7 = 7,
        v8 = 8, v9 = 9;
    assert(skiplist_push(skiplist, 3, (void *)(&v3)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 9, (void *)(&v9)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 7, (void *)(&v7)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 2, (void *)(&v2)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 6, (void *)(&v6)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 5, (void *)(&v5)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 8, (void *)(&v8)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 1, (void *)(&v1)) == SKIPLIST_OK);
    assert(skiplist_push(skiplist, 4, (void *)(&v4)) == SKIPLIST_OK);
    assert(skiplist_len(skiplist) == 9);
    assert(skiplist_get(skiplist, 8) == &v8);
    assert(skiplist_get(skiplist, 9) == &v9);
    assert(skiplist_get(skiplist, 1) == &v1);
    assert(skiplist_get(skiplist, 2) == &v2);
    assert(skiplist_get(skiplist, 10) == NULL);
    assert(skiplist_get(skiplist, 9999) == NULL);
    skiplist_free(skiplist);
}
Example #7
0
int
main(int argc, char **argv)
{
	int	envc;			/* environment argument count */
	char	**envv;			/* environment argument list */
	FILE	*names;			/* name file pointer */
	int	oldnum;			/* number in old cross-ref */
	char	path[PATHLEN + 1];	/* file path */
	FILE	*oldrefs;	/* old cross-reference file */
	char	*s;
	int	c, i;
	pid_t	pid;

	/* save the command name for messages */
	argv0 = basename(argv[0]);

	/* get the current directory for build() and line-oriented P command */
	if (mygetwd(currentdir) == NULL) {
		(void) fprintf(stderr,
		    "cscope: warning: cannot get current directory name\n");
		(void) strcpy(currentdir, "<unknown>");
	}
	/* initialize any view path; (saves time since currendir is known) */
	vpinit(currentdir);
	dbvpndirs = vpndirs; /* number of directories in database view path */
	/* directories (including current) in database view path */
	dbvpdirs = vpdirs;

	/* the first source directory is the current directory */
	sourcedir(".");

	/* read the environment */
	editor = mygetenv("EDITOR", EDITOR);
	editor = mygetenv("VIEWER", editor);	/* use viewer if set */
	home = getenv("HOME");
	shell = mygetenv("SHELL", SHELL);
	tmpdir = mygetenv("TMPDIR", TMPDIR);
	/* increment nesting depth */
	cscopedepth = atoi(mygetenv("CSCOPEDEPTH", "0"));
	(void) sprintf(path, "CSCOPEDEPTH=%d", ++cscopedepth);
	(void) putenv(stralloc(path));
	if ((s = getenv("CSCOPEOPTIONS")) != NULL) {

		/* parse the environment option string */
		envc = 1;
		envv = mymalloc(sizeof (char *));
		s = strtok(stralloc(s), OPTSEPS);
		while (s != NULL) {
			envv = myrealloc(envv, ++envc * sizeof (char *));
			envv[envc - 1] = stralloc(s);
			s = strtok((char *)NULL, OPTSEPS);
		}
		/* set the environment options */
		options(envc, envv);
	}
	/* set the command line options */
	options(argc, argv);

	/* create the temporary file names */
	pid = getpid();
	(void) sprintf(temp1, "%s/cscope%d.1", tmpdir, (int)pid);
	(void) sprintf(temp2, "%s/cscope%d.2", tmpdir, (int)pid);

	/* if running in the foreground */
	if (signal(SIGINT, SIG_IGN) != SIG_IGN) {

		/* cleanup on the interrupt and quit signals */
		(void) signal(SIGINT, myexit);
		(void) signal(SIGQUIT, myexit);
	}

	/* cleanup on the hangup signal */
	(void) signal(SIGHUP, myexit);
	/* if the database path is relative and it can't be created */
	if (reffile[0] != '/' && access(".", WRITE) != 0) {

		/* if the database may not be up-to-date or can't be read */
		(void) sprintf(path, "%s/%s", home, reffile);
		if (isuptodate == NO || access(reffile, READ) != 0) {

			/* put it in the home directory */
			reffile = stralloc(path);
			(void) sprintf(path, "%s/%s", home, invname);
			invname = stralloc(path);
			(void) sprintf(path, "%s/%s", home, invpost);
			invpost = stralloc(path);
			(void) fprintf(stderr,
			    "cscope: symbol database will be %s\n", reffile);
		}
	}
	/* if the cross-reference is to be considered up-to-date */
	if (isuptodate == YES) {
		if ((oldrefs = vpfopen(reffile, "r")) == NULL) {
			cannotopen(reffile);
			exit(1);
		}
		/*
		 * get the crossref file version but skip the current
		 * directory
		 */
		if (fscanf(oldrefs, "cscope %d %*s", &fileversion) != 1) {
			(void) fprintf(stderr,
			    "cscope: cannot read file version from file %s\n",
			    reffile);
			exit(1);
		}
		if (fileversion >= 8) {

			/* override these command line options */
			compress = YES;
			invertedindex = NO;

			/* see if there are options in the database */
			for (;;) {
				/* no -q leaves multiple blanks */
				while ((c = getc(oldrefs)) == ' ') {
					;
				}
				if (c != '-') {
					(void) ungetc(c, oldrefs);
					break;
				}
				switch (c = getc(oldrefs)) {
				case 'c':	/* ASCII characters only */
					compress = NO;
					break;
				case 'q':	/* quick search */
					invertedindex = YES;
					(void) fscanf(oldrefs,
					    "%ld", &totalterms);
					break;
				case 'T':
					/* truncate symbols to 8 characters */
					dbtruncated = YES;
					truncatesyms = YES;
					break;
				}
			}
			initcompress();

			/* seek to the trailer */
			if (fscanf(oldrefs, "%ld", &traileroffset) != 1) {
				(void) fprintf(stderr,
				    "cscope: cannot read trailer offset from "
				    "file %s\n", reffile);
				exit(1);
			}
			if (fseek(oldrefs, traileroffset, 0) != 0) {
				(void) fprintf(stderr,
				    "cscope: cannot seek to trailer in "
				    "file %s\n", reffile);
				exit(1);
			}
		}
		/*
		 * read the view path for use in converting relative paths to
		 * full paths
		 *
		 * note: don't overwrite vp[n]dirs because this can cause
		 * the wrong database index files to be found in the viewpath
		 */
		if (fileversion >= 13) {
			if (fscanf(oldrefs, "%d", &dbvpndirs) != 1) {
				(void) fprintf(stderr,
				    "cscope: cannot read view path size from "
				    "file %s\n", reffile);
				exit(1);
			}
			if (dbvpndirs > 0) {
				dbvpdirs = mymalloc(
				    dbvpndirs * sizeof (char *));
				for (i = 0; i < dbvpndirs; ++i) {
					if (fscanf(oldrefs, "%s", path) != 1) {
						(void) fprintf(stderr,
						    "cscope: cannot read view "
						    "path from file %s\n",
						    reffile);
						exit(1);
					}
					dbvpdirs[i] = stralloc(path);
				}
			}
		}
		/* skip the source and include directory lists */
		skiplist(oldrefs);
		skiplist(oldrefs);

		/* get the number of source files */
		if (fscanf(oldrefs, "%d", &nsrcfiles) != 1) {
			(void) fprintf(stderr,
			    "cscope: cannot read source file size from "
			    "file %s\n", reffile);
			exit(1);
		}
		/* get the source file list */
		srcfiles = mymalloc(nsrcfiles * sizeof (char *));
		if (fileversion >= 9) {

			/* allocate the string space */
			if (fscanf(oldrefs, "%d", &oldnum) != 1) {
				(void) fprintf(stderr,
				    "cscope: cannot read string space size "
				    "from file %s\n", reffile);
				exit(1);
			}
			s = mymalloc(oldnum);
			(void) getc(oldrefs);	/* skip the newline */

			/* read the strings */
			if (fread(s, oldnum, 1, oldrefs) != 1) {
				(void) fprintf(stderr,
				    "cscope: cannot read source file names "
				    "from file %s\n", reffile);
				exit(1);
			}
			/* change newlines to nulls */
			for (i = 0; i < nsrcfiles; ++i) {
				srcfiles[i] = s;
				for (++s; *s != '\n'; ++s) {
					;
				}
				*s = '\0';
				++s;
			}
			/* if there is a file of source file names */
			if (namefile != NULL &&
			    (names = vpfopen(namefile, "r")) != NULL ||
			    (names = vpfopen(NAMEFILE, "r")) != NULL) {

				/* read any -p option from it */
				while (fscanf(names, "%s", path) == 1 &&
				    *path == '-') {
					i = path[1];
					s = path + 2;	/* for "-Ipath" */
					if (*s == '\0') {
						/* if "-I path" */
						(void) fscanf(names,
						    "%s", path);
						s = path;
					}
					switch (i) {
					case 'p':
						/* file path components */
						/* to display */
						if (*s < '0' || *s > '9') {
							(void) fprintf(stderr,
							    "cscope: -p option "
							    "in file %s: "
							    "missing or "
							    "invalid numeric "
							    "value\n",
							    namefile);
						}
						dispcomponents = atoi(s);
					}
				}
				(void) fclose(names);
			}
		} else {
			for (i = 0; i < nsrcfiles; ++i) {
				if (fscanf(oldrefs, "%s", path) != 1) {
					(void) fprintf(stderr,
					    "cscope: cannot read source file "
					    "name from file %s\n", reffile);
					exit(1);
				}
				srcfiles[i] = stralloc(path);
			}
		}
		(void) fclose(oldrefs);
	} else {
		/* get source directories from the environment */
		if ((s = getenv("SOURCEDIRS")) != NULL) {
			sourcedir(s);
		}
		/* make the source file list */
		srcfiles = mymalloc(msrcfiles * sizeof (char *));
		makefilelist();
		if (nsrcfiles == 0) {
			(void) fprintf(stderr,
			    "cscope: no source files found\n");
			printusage();
			exit(1);
		}
		/* get include directories from the environment */
		if ((s = getenv("INCLUDEDIRS")) != NULL) {
			includedir(s);
		}
		/* add /usr/include to the #include directory list */
		includedir("/usr/include");

		/* initialize the C keyword table */
		initsymtab();

		/* create the file name(s) used for a new cross-reference */
		(void) strcpy(path, reffile);
		s = basename(path);
		*s = '\0';
		(void) strcat(path, "n");
		++s;
		(void) strcpy(s, basename(reffile));
		newreffile = stralloc(path);
		(void) strcpy(s, basename(invname));
		newinvname = stralloc(path);
		(void) strcpy(s, basename(invpost));
		newinvpost = stralloc(path);

		/* build the cross-reference */
		initcompress();
		build();
		if (buildonly == YES) {
			exit(0);
		}
	}
	opendatabase();

	/*
	 * removing a database will not release the disk space if a cscope
	 * process has the file open, so a project may want unattended cscope
	 * processes to exit overnight, including their subshells and editors
	 */
	if (noacttime) {
		(void) signal(SIGALRM, timedout);
		(void) alarm(noacttime);
	}
	/*
	 * if using the line oriented user interface so cscope can be a
	 * subprocess to emacs or samuel
	 */
	if (linemode == YES) {
		if (*pattern != '\0') {		/* do any optional search */
			if (search() == YES) {
				while ((c = getc(refsfound)) != EOF) {
					(void) putchar(c);
				}
			}
		}
		if (onesearch == YES) {
			myexit(0);
		}
		for (;;) {
			char buf[PATLEN + 2];
			if (noacttime) {
				(void) alarm(noacttime);
			}
			(void) printf(">> ");
			(void) fflush(stdout);
			if (fgets(buf, sizeof (buf), stdin) == NULL) {
				myexit(0);
			}
			/* remove any trailing newline character */
			if (*(s = buf + strlen(buf) - 1) == '\n') {
				*s = '\0';
			}
			switch (*buf) {
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':	/* samuel only */
				field = *buf - '0';
				(void) strcpy(pattern, buf + 1);
				(void) search();
				(void) printf("cscope: %d lines\n", totallines);
				while ((c = getc(refsfound)) != EOF) {
					(void) putchar(c);
				}
				break;

			case 'c':	/* toggle caseless mode */
			case ctrl('C'):
				if (caseless == NO) {
					caseless = YES;
				} else {
					caseless = NO;
				}
				egrepcaseless(caseless);
				break;

			case 'r':	/* rebuild database cscope style */
			case ctrl('R'):
				freefilelist();
				makefilelist();
				/* FALLTHROUGH */

			case 'R':	/* rebuild database samuel style */
				rebuild();
				(void) putchar('\n');
				break;

			case 'C':	/* clear file names */
				freefilelist();
				(void) putchar('\n');
				break;

			case 'F':	/* add a file name */
				(void) strcpy(path, buf + 1);
				if (infilelist(path) == NO &&
				    vpaccess(path, READ) == 0) {
					addsrcfile(path);
				}
				(void) putchar('\n');
				break;

			case 'P':	/* print the path to the files */
				if (prependpath != NULL) {
					(void) puts(prependpath);
				} else {
					(void) puts(currentdir);
				}
				break;

			case 'q':	/* quit */
			case ctrl('D'):
			case ctrl('Z'):
				myexit(0);

			default:
				(void) fprintf(stderr,
				    "cscope: unknown command '%s'\n", buf);
				break;
			}
		}
		/* NOTREACHED */
	}
	/* pause before clearing the screen if there have been error messages */
	if (errorsfound == YES) {
		errorsfound = NO;
		askforreturn();
	}
	(void) signal(SIGINT, SIG_IGN);	/* ignore interrupts */
	(void) signal(SIGPIPE, SIG_IGN); /* | command can cause pipe signal */
	/* initialize the curses display package */
	(void) initscr();	/* initialize the screen */
	setfield();	/* set the initial cursor position */
	entercurses();
	(void) keypad(stdscr, TRUE);	/* enable the keypad */
	dispinit();	/* initialize display parameters */
	putmsg("");	/* clear any build progress message */
	display();	/* display the version number and input fields */

	/* do any optional search */
	if (*pattern != '\0') {
		atfield();		/* move to the input field */
		(void) command(ctrl('A'));	/* search */
		display();		/* update the display */
	} else if (reflines != NULL) {
		/* read any symbol reference lines file */
		(void) readrefs(reflines);
		display();		/* update the display */
	}
	for (;;) {
		if (noacttime) {
			(void) alarm(noacttime);
		}
		atfield();	/* move to the input field */

		/* exit if the quit command is entered */
		if ((c = mygetch()) == EOF || c == ctrl('D') ||
		    c == ctrl('Z')) {
			break;
		}
		/* execute the commmand, updating the display if necessary */
		if (command(c) == YES) {
			display();
		}
	}
	/* cleanup and exit */
	myexit(0);
	/* NOTREACHED */
	return (0);
}