diff --git a/bash/xwm_test/xwm_test.sh b/bash/xwm_test/xwm_test.sh new file mode 100755 index 0000000..ce70338 --- /dev/null +++ b/bash/xwm_test/xwm_test.sh @@ -0,0 +1,7 @@ +#!/bin/bash +export ID_WIN="$(xwininfo | grep "Window id" | cut -d\" -f2)" +echo $ID_WIN +x=1 +wmctrl -r "$ID_WIN" -e 1,-1,-1,1,1; +time for i in `seq 1024`;do (( x++ ));wmctrl -r "$ID_WIN" -e 1,0,0,$x,$x;done + diff --git a/c/fopen_too_many_files/fopen_too_many_files b/c/fopen_too_many_files/fopen_too_many_files new file mode 100755 index 0000000..83f5fee Binary files /dev/null and b/c/fopen_too_many_files/fopen_too_many_files differ diff --git a/c/fopen_too_many_files/fopen_too_many_files.c b/c/fopen_too_many_files/fopen_too_many_files.c new file mode 100644 index 0000000..126225d --- /dev/null +++ b/c/fopen_too_many_files/fopen_too_many_files.c @@ -0,0 +1,17 @@ +#include +#include + +int main(int argc, char *argv[]) +{ + int i; + + for (i = 0; i < 65536; i++) + if (!fopen("fopen_too_many_files.c", "rb")) { + printf("ulimit = %d\n", i); + break; + } + + printf("Hello, world!\n"); + + return EXIT_SUCCESS; +} diff --git a/c/fork_ex/fork_address_space b/c/fork_ex/fork_address_space new file mode 100755 index 0000000..69231f6 Binary files /dev/null and b/c/fork_ex/fork_address_space differ diff --git a/c/fork_ex/fork_address_space.c b/c/fork_ex/fork_address_space.c new file mode 100644 index 0000000..9eb5b13 --- /dev/null +++ b/c/fork_ex/fork_address_space.c @@ -0,0 +1,16 @@ +#include +#include +#include + +int main(int argc, char *argv[]) +{ + int a; + + for (a = 0; a < 3; a++) + fork(); + + printf("%lu\n", (unsigned long)&a); + + return EXIT_SUCCESS; +} + diff --git a/c/liblist/examples/Makefile b/c/liblist/examples/Makefile new file mode 100644 index 0000000..4eaf681 --- /dev/null +++ b/c/liblist/examples/Makefile @@ -0,0 +1,49 @@ +# Makefile for generic linked list examples. +# +# Last edited: Tue Jul 28 15:36:13 1992 by bcs (Bradley C. Spatz) on wasp +# +# Copyright (C) 1992 Bradley C. Spatz, bcs@ufl.edu +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +# +# +#CC = /local/bin/gcc +#CFLAGS = $(INCLUDES) -fstrength-reduce -finline-functions +PACKAGE_VERSION=2.3.1 +CFLAGS += $(INCLUDES) +INCLUDES= -I.. +LIBS = -L.. -llist +#LIBS = -L .. -llist # Use this for HP-UX; great loader guys! +#add macro for ranlib 4/96 *kob* - ranlib doesn't exist on solaris +RANLIB = ls +# +all: listtest queuetest stacktest + (cd cache; make) + +listtest: listtest.o ../liblist.a + $(CC) $(CFLAGS) -o listtest listtest.o $(LIBS) + +queuetest: queuetest.o ../liblist.a + $(CC) $(CFLAGS) -o queuetest queuetest.o $(LIBS) + +stacktest: stacktest.o ../liblist.a + $(CC) $(CFLAGS) -o stacktest stacktest.o $(LIBS) + +listtest.o: ../list.h +queuetest.o: ../queue.h +stacktest.o: ../stack.h +clean: + rm -f listtest queuetest stacktest *.o core + (cd cache; make clean) diff --git a/c/liblist/examples/cache/cache.c b/c/liblist/examples/cache/cache.c new file mode 100644 index 0000000..83397ff --- /dev/null +++ b/c/liblist/examples/cache/cache.c @@ -0,0 +1,146 @@ +/* cache.c -- routines to implement a generic, list(3)-based cache package. + * + * Last edited: Tue Jul 28 15:41:47 1992 by bcs (Bradley C. Spatz) on wasp + * + * Copyright (C) 1992, Bradley C. Spatz, bcs@ufl.edu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * We define the following routines here: + * + * CACHE *cache_init(max_elements) + * char *cache_enter(cache, data, bytes, removed) + * char *cache_check(cache, data, match) + * void cache_free(cache, dealloc) + * + * for + * + * CACHE *cache; + * char *data; + * int max_elements, max_size, bytes; + * char **removed; + * int match(data, curr) + * char *data; + * char *curr; + * void dealloc(data) + * char *data; + * + * We base this package on the list(3) package. + * + * Keep a data structure that is essentially a list. We'll add new + * elements to the front of the list and remove old elements from the end + * of the list. We'll optimize searches for MRU (Most Recently Used) and + * we'll dispose of elements when we need space by using LRU. Finally, + * we'll always promote the element on a hit to the front of the list. + * + * We'll allow the user to control the size of the cache in terms of + * cache elements. This limit will be determined at cache creation. + */ + +static char brag[] = "$$Version: cache " "PACKAGE_VERSION" " Copyright (C) 1992 Bradley C. Spatz"; + +#include +#include +#include "cache.h" + +CACHE *cache_init(int max_elements) +{ + CACHE *new_cache; + + /* Allocate, initialize, and return a new cache. Return NULL if + * the malloc or list initialization fails. + */ + if ((new_cache = (CACHE *) malloc(sizeof(CACHE))) == NULL) { + return(NULL); + } + new_cache->max_elements = max_elements; + if ((new_cache->list = list_init()) == NULL) { + /* The list creation fragged, so release the cache descriptor. */ + free(new_cache); + return(NULL); + } + + return(new_cache); +} + + +void *cache_enter(CACHE *cache, void *data, int bytes, void **removed) +{ + char *new_element; + + /* Add a new element to the front of our list. This is easy, because + * we're using the list(3) package; our intentions exactly. + * Try and add the new element. If that succeeds, then check for a + * full cache. If full, remove the element at the rear of the list. + * We return a pointer to the newly inserted element or NULL if the + * insert failed. We also return a pointer to the removed element + * if we did indeed remove one. + */ + *removed = NULL; + new_element = list_insert_before(cache->list, data, bytes); + if (new_element != NULL) { + if (list_size(cache->list) > cache->max_elements) { + *removed = (char *) list_remove_rear(cache->list); + } + } + + return(new_element); +} + + +void *cache_check(CACHE *cache, void *data, cache_match_func_t match) +{ + char *found; + + /* Check for an empty cache. */ + if (list_size(cache->list) == 0) { + return(NULL); + } + + /* Ok. Search the list for the element, starting from the front + * of our list. If the traversal finds the element, then promote it to + * the front if it's not already there, and return a pointer to the element. + * Otherwise, return NULL. In either case, make sure to reset the + * current element pointer back to the front of the list. + */ + if (list_traverse(cache->list, data, match, + (LIST_FRNT | LIST_FORW | LIST_ALTR)) == LIST_OK) { + /* We found what we're looking for. */ + if (list_curr(cache->list) != list_front(cache->list)) { + fprintf(stderr, "cache_check: moving found to front.\n"); + found = (char *) list_remove_curr(cache->list); + list_mvfront(cache->list); + list_insert_before(cache->list, found, 0); + return(found); + } + else { + return(list_front(cache->list)); + } + } + else { + /* We did not find the element. */ + list_mvfront(cache->list); + return(NULL); + } +} + + +void cache_free(CACHE *cache, cache_dealloc_func_t dealloc) +{ + /* First free up the list, and then the cache descriptor. */ + list_free(cache->list, dealloc); + free(cache); +} diff --git a/c/liblist/examples/cache/cachetest b/c/liblist/examples/cache/cachetest new file mode 100755 index 0000000..df4edb2 Binary files /dev/null and b/c/liblist/examples/cache/cachetest differ diff --git a/c/liblist/examples/cache/cachetest.c b/c/liblist/examples/cache/cachetest.c new file mode 100644 index 0000000..1f1aaca --- /dev/null +++ b/c/liblist/examples/cache/cachetest.c @@ -0,0 +1,131 @@ +/* cachetest.c -- test program for generic cache package + * + * Last edited: Tue Jul 28 15:42:57 1992 by bcs (Bradley C. Spatz) on wasp + * + * Copyright (C) 1992, Bradley C. Spatz, bcs@ufl.edu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +static char brag[] = "$$Version: cachetest " "PACKAGE_VERSION" " Copyright (C) 1992 Bradley C. Spatz"; + +#include +#include +#include "cache.h" + +#define MAX_ELEMENTS 3 + +int match(); + +main() +{ + CACHE *cache; + char cmd[2]; + int val, *pval; + + /* Print some instructions. */ + printf("This program demonstrates the various cache manipulation\n"); + printf("routines supplied by this package. Although this program\n"); + printf("manipulates a cache of integers, data of any type and size\n"); + printf("(and not just integers) are supported by the routines. See\n"); + printf("the man page for more information.\n\n"); + printf("We illustrate a cache with a maximum size of 3 entries.\n\n"); + + /* Allocate a new cache. */ + cache = cache_init(MAX_ELEMENTS); + print_cache(cache); + + /* Get some commands. */ + printf("\n(e)nter new element, (c)heck for element; (q)uit: "); + while (scanf("%1s", cmd) != EOF) { + switch (cmd[0]) { + case 'e': + printf("Value (int) to enter: "); + if (scanf("%d", &val)) { + /* We ignore the return code here, but in practice, + * we may fail (with a return code of NULL). + */ + cache_enter(cache, &val, sizeof(val), (void **)&pval); + if (pval != NULL) { + printf("%d was removed to make room.\n", *pval); + } + } + break; + case 'c': + printf("Value (int) to check for: "); + if (scanf("%d", &val)) { + pval = (int *) cache_check(cache, (char *) &val, match); + if (pval != NULL) { + printf("%d found!\n", *pval); + } + else { + printf("Not found.\n"); + } + } + break; + case 'q': + cache_free(cache, CACHE_DEALLOC); + exit(0); + break; + default: + printf("'%s' not a recognized command!\n", cmd); + break; + } + print_cache(cache); + printf("\n(e)nter new element, (c)heck for element; (q)uit: "); + } + + exit(0); +} + + +/* Provide a routine to return FALSE (0) if the current element in the cache, + * curr, is equal to the element we are searching for, data. We return + * FALSE, instead of TRUE, because we will use the list_traverse function. + * That function continues if the user-supplied function is TRUE. We want + * to stop when we've found our element. + */ +int match(data, curr) +char *data; +char *curr; +{ + return(((*(int *) data) == (*(int *) curr)) ? FALSE : TRUE); +} + + +/* The following routines make know that the cache is implemented with + * the list(3) package. It makes knowledge of the CACHE structure as + * well. We do this here for illustration only. + */ +int print_element(input, curr) +char *input; +char *curr; +{ + printf(" %d", *(int *) curr); + return(TRUE); +} + +print_cache(cache) +CACHE *cache; +{ + printf("Cache:"); + if (list_empty(cache->list)) + printf(" (empty).\n"); + else { + list_traverse(cache->list, (char *) 0, print_element, + (LIST_FRNT | LIST_FORW | LIST_SAVE)); + printf(".\n"); + } +} diff --git a/c/liblist/examples/listtest b/c/liblist/examples/listtest new file mode 100755 index 0000000..02fd67f Binary files /dev/null and b/c/liblist/examples/listtest differ diff --git a/c/liblist/examples/listtest.c b/c/liblist/examples/listtest.c new file mode 100644 index 0000000..3cc7409 --- /dev/null +++ b/c/liblist/examples/listtest.c @@ -0,0 +1,287 @@ +/* listtest.c -- test program for generic list package + * + * Last edited: Tue Jul 28 15:37:21 1992 by bcs (Bradley C. Spatz) on wasp + * + * Copyright (C) 1992, Bradley C. Spatz, bcs@ufl.edu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +static char brag[] = "$$Version: listtest " "PACKAGE_VERSION" " Copyright (C) 1992 Bradley C. Spatz"; + +#include +#include +#include "../list.h" + +main() +{ + LIST *list; + char cmd[2]; + int val, *pval; + + /* Print some instructions. */ + printf("This program demonstrates the various list manipulation\n"); + printf("routines supplied by this package. Although this program\n"); + printf("manipulates a list of integers, data of any type and size\n"); + printf("(and not just integers) are supported by the routines. See\n"); + printf("the man page for more information.\n\n"); + + /* Allocate a new list. */ + list = list_init(); + printf("Curr = (nil).\n"); + print_list(list); + + /* Get some commands. */ + printf("\n(i)nsert, (r)emove; (m)ove, (f)ront/r(e)ear, (t)raverse, (s)ize, (q)uit: "); + while (scanf("%1s", cmd) != EOF) { + switch (cmd[0]) { + case 'i': + do_insert(list); + break; + case 'r': + do_remove(list); + break; + case 'm': + do_move(list); + break; + case 'f': + pval = (int *) list_front(list); + if (pval == NULL) + printf("Front = (nil)\n"); + else + printf("Front = %d\n", *pval); + break; + case 'e': + pval = (int *) list_rear(list); + if (pval == NULL) + printf("Rear = (nil)\n"); + else + printf("Rear = %d\n", *pval); + break; + case 't': + do_traverse(list); + break; + case 's': + printf("List has %d elements.\n", list_size(list)); + break; + case 'q': + list_free(list, LIST_DEALLOC); + exit(0); + break; + default: + printf("'%s' not a recognized command!\n", cmd); + break; + } + pval = (int *) list_curr(list); + if (pval == NULL) + printf("Curr = (nil)\n"); + else + printf("Curr = %d\n", *pval); + print_list(list); + printf("\n(i)nsert, (r)emove; (m)ove, (f)ront/r(e)ear, (t)raverse, (s)ize, (q)uit: "); + } + + exit(0); +} + + +do_insert(list) +LIST *list; +{ + char cmd[2]; + int val, *bogus; + + printf("insert (b)efore or (a)after: "); + scanf("%1s", cmd); + switch (cmd[0]) { + case 'b': + printf("Value (int) to insert before: "); + if (scanf("%d", &val)) + /* We ignore the return code here, but in practice, + * we may fail (with a return code of NULL). + */ + list_insert_before(list, &val, sizeof(val)); + break; + case 'a': + printf("Value (int) to insert after: "); + if (scanf("%d", &val)) + /* We ignore the return code here, but in practice, + * we may fail (with a return code of NULL). + */ + list_insert_after(list, &val, sizeof(val)); + break; + default: + printf("%c not recognized. Returning to main menu.\n", cmd[0]); + } +} + + +do_remove(list) +LIST *list; +{ + char cmd[2]; + int *pval; + + printf("remove (f)ront, (c)urr, or (r)ear: "); + scanf("%1s", cmd); + switch (cmd[0]) { + case 'f': + pval = (int *) list_remove_front(list); + break; + case 'c': + pval = (int *) list_remove_curr(list); + break; + case 'r': + pval = (int *) list_remove_rear(list); + break; + default: + printf("%c not recognized. Returning to main menu.\n", cmd[0]); + } + + if (pval == NULL) + printf("List is empty!\n"); + else + printf("%d removed.\n", *pval); +} + + +do_move(list) +LIST *list; +{ + char cmd[2]; + + printf("move to (p)revious, (n)ext, (f)ront, or (r)ear: "); + scanf("%1s", cmd); + switch (cmd[0]) { + case 'p': + if (list_mvprev(list) == NULL) + printf("No previous element!\n"); + break; + case 'n': + if (list_mvnext(list) == NULL) + printf("No next element!\n"); + break; + case 'f': + /* We ignore the return code here. */ + list_mvfront(list); + break; + case 'r': + /* We ignore the return code here. */ + list_mvrear(list); + break; + default: + printf("%c not recognized. Returning to main menu.\n", cmd[0]); + } +} + + +/* Routine to print the integer stored at each node. In this example, + * we ignore the first parameter, which might be useful if we were + * searching the list or something. We must return 0 or 1, so we always + * return 1. + */ +int print_element(input, curr) +char *input; +char *curr; +{ + printf(" %d", *(int *) curr); + return(TRUE); +} + + +do_traverse(list) +LIST *list; +{ + char cmd[2]; + int opts=0, rc; + + printf("traverse from (f)ront, (r)ear, or (c)urrent element: "); + scanf("%1s", cmd); + switch (cmd[0]) { + case 'f': + opts = (opts | LIST_FRNT); + break; + case 'r': + opts = (opts | LIST_REAR); + break; + case 'c': + opts = (opts | LIST_CURR); + break; + default: + printf("%c not recognized. Returning to main menu.\n", cmd[0]); + } + + if (cmd[0] == 'c') { + printf("traverse (f)orwards or (b)ackwards: "); + scanf("%1s", cmd); + switch (cmd[0]) { + case 'f': + opts = (opts | LIST_FORW); + break; + case 'b': + opts = (opts | LIST_BACK); + break; + default: + printf("%c not recognized. Returning to main menu.\n", cmd[0]); + } + } + + printf("(a)lter or (p)reserve the current element pointer: "); + scanf("%1s", cmd); + switch (cmd[0]) { + case 'a': + opts = (opts | LIST_ALTR); + break; + case 'p': + opts = (opts | LIST_SAVE); + break; + default: + printf("%c not recognized. Returning to main menu.\n", cmd[0]); + } + + printf("Traversal: "); + rc = list_traverse(list, (char *) 0, print_element, opts); + switch (rc) { + case LIST_EMPTY: + printf("(empty).\n"); + break; + case LIST_OK: + printf(".\n"); + break; + case LIST_EXTENT: + printf(". (extent reached)\n"); + break; + default: + printf("%c not recognized. Returning to main menu.\n", cmd[0]); + } +} + + +/* Routine to print a list of integers, using the traversal function. + * In this example, we send NULL for the second parameter, which might be + * used to specify an element to search for. + */ +print_list(list) +LIST *list; +{ + printf("List:"); + if (list_empty(list)) + printf(" (empty).\n"); + else { + list_traverse(list, (char *) 0, print_element, + (LIST_FRNT | LIST_FORW | LIST_SAVE)); + printf(".\n"); + } +} diff --git a/c/liblist/examples/queuetest b/c/liblist/examples/queuetest new file mode 100755 index 0000000..4634ef3 Binary files /dev/null and b/c/liblist/examples/queuetest differ diff --git a/c/liblist/examples/queuetest.c b/c/liblist/examples/queuetest.c new file mode 100644 index 0000000..a0d4dbd --- /dev/null +++ b/c/liblist/examples/queuetest.c @@ -0,0 +1,120 @@ +/* queuetest.c -- test program for generic queue package. + * + * Last edited: Tue Jul 28 15:38:58 1992 by bcs (Bradley C. Spatz) on wasp + * + * Copyright (C) 1992, Bradley C. Spatz, bcs@ufl.edu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +static char brag[] = "$$Version: queuetest " "PACKAGE_VERSION" " Copyright (C) 1992 Bradley C. Spatz"; + +#include +#include +#include "../queue.h" + +main() +{ + QUEUE *q; + char cmd; + int val, *pval; + + /* Print some instructions. */ + printf("This program demonstrates the various queue manipulation\n"); + printf("routines supplied by this package. Although this program\n"); + printf("manipulates a queue of integers, data of any type and size\n"); + printf("(and not just integers) are supported by the routines. See\n"); + printf("the man page for more information.\n\n"); + + /* Allocate a new queue. */ + q = q_init(); + print_queue(q); + + /* Get some commands. */ + printf("(e)nqueue, (d)equeue, (f)ront, (s)ize, (c)heck, (q)uit: "); + while (scanf("%1s", &cmd) != EOF) { + switch (cmd) { + case 'e': + printf("Value (int) to enqueue: "); + if (scanf("%d", &val)) + /* We ignore the return code here, butin practice, we may + * fail (with a return code of 0). + */ + q_enqueue(q, &val, sizeof(val)); + break; + case 'd': + pval = (int *) q_dequeue(q); + if (pval != NULL) + printf("%d dequeued.\n", *pval); + else + printf("Queue is empty!\n"); + break; + case 'f': + pval = (int *) q_front(q); + if (pval == NULL) + printf("Queue is empty!\n"); + else + printf("%d at front.\n", *pval); + break; + case 's': + val = q_size(q); + printf("Queue has %d element%s.\n", val, ((val == 1) ? "" : "s")); + break; + case 'c': + printf("Queue is%s empty.\n", (q_empty(q) ? "" : " not")); + break; + case 'q': + q_free(q, QUEUE_DEALLOC); + exit(0); + break; + default: + printf("'%c' not a recognized command!\n", cmd); + break; + } + print_queue(q); + printf("\n(e)nqueue, (d)equeue, (f)ront, (s)ize, (c)heck, (q)uit: "); + } + + exit(0); +} + + +/* Routine to print the integer stored at each node. In this example, + * we ignore the first parameter, which might be useful if we were + * searching the list or something. We must return 0 or 1, so we always + * return 1. + */ +int print_element(input, curr) +char *input; +char *curr; +{ + printf(" %d", *(int *) curr); + return(TRUE); +} + + +/* Routine to print a queue of integers. */ +print_queue(queue) +QUEUE *queue; +{ + printf("Queue: "); + if (q_empty(queue)) + printf("(empty)\n"); + else { + list_traverse(queue, (char *) 0, print_element, + (LIST_FRNT | LIST_FORW | LIST_SAVE)); + printf("\n"); + } +} diff --git a/c/liblist/examples/stacktest b/c/liblist/examples/stacktest new file mode 100755 index 0000000..df0dd44 Binary files /dev/null and b/c/liblist/examples/stacktest differ diff --git a/c/liblist/examples/stacktest.c b/c/liblist/examples/stacktest.c new file mode 100644 index 0000000..322f3b4 --- /dev/null +++ b/c/liblist/examples/stacktest.c @@ -0,0 +1,120 @@ +/* stacktest.c -- test program for generic stack package + * + * Last edited: Tue Jul 28 15:38:19 1992 by bcs (Bradley C. Spatz) on wasp + * + * Copyright (C) 1992, Bradley C. Spatz, bcs@ufl.edu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +static char brag[] = "$$Version: stacktest " "PACKAGE_VERSION" " Copyright (C) 1992 Bradley C. Spatz"; + +#include +#include +#include "../stack.h" + +main() +{ + STACK *stack; + char cmd; + int val, *pval; + + /* Print some instructions. */ + printf("This program demonstrates the various stack manipulation\n"); + printf("routines supplied by this package. Although this program\n"); + printf("manipulates a stack of integers, data of any type and size\n"); + printf("(and not just integers) are supported by the routines. See\n"); + printf("the man page for more information.\n\n"); + + /* Allocate a new stack. */ + stack = stack_init(); + print_stack(stack); + + /* Get some commands. */ + printf("(p)ush, p(o)p, (t)op, (s)ize, (c)heck, (q)uit: "); + while (scanf("%1s", &cmd) != EOF) { + switch (cmd) { + case 'p': + printf("Value (int) to push: "); + if (scanf("%d", &val)) + /* We ignore the return code here, but in practice, we may + * fail (with a return code of NULL). + */ + stack_push(stack, &val, sizeof(val)); + break; + case 'o': + pval = (int *) stack_pop(stack); + if (pval != NULL) + printf("%d popped.\n", *pval); + else + printf("Stack is empty!\n"); + break; + case 't': + pval = (int *) stack_top(stack); + if (pval == NULL) + printf("Stack is empty!\n"); + else + printf("%d on top.\n", *pval); + break; + case 's': + val = stack_size(stack); + printf("Stack has %d element%s.\n", val, ((val == 1) ? "":"s")); + break; + case 'c': + printf("Stack is%s empty.\n", (stack_empty(stack) ? "" : " not")); + break; + case 'q': + stack_free(stack, STACK_DEALLOC); + exit(0); + break; + default: + printf("'%c' not a recognized command!\n", cmd); + break; + } + print_stack(stack); + printf("\n(p)ush, p(o)p, (t)op, (s)ize, (c)heck, (q)uit: "); + } + + exit(0); +} + + +/* Routine to print the integer stored at each node. In this example, + * we ignore the first parameter, which might be useful if we were + * searching the list or something. We must return 0 or 1, so we always + * return 1. + */ +int print_element(input, curr) +char *input; +char *curr; +{ + printf(" %d", *(int *) curr); + return(TRUE); +} + + +/* Routine to print a stack of integers. */ +print_stack(stack) +STACK *stack; +{ + printf("Stack: "); + if (stack_empty(stack)) + printf("(empty)\n"); + else { + list_traverse(stack, (char *) 0, print_element, + (LIST_FRNT | LIST_FORW | LIST_SAVE)); + printf("\n"); + } +} diff --git a/c/liblist/list.h b/c/liblist/list.h new file mode 100644 index 0000000..0149b15 --- /dev/null +++ b/c/liblist/list.h @@ -0,0 +1,101 @@ +/* list.h -- data structures and such for generic list package + * + * Last edited: Tue Jul 28 15:29:56 1992 by bcs (Bradley C. Spatz) on wasp + * Updated by Nathan Phillip Brink 2010 + * + * Copyright (C) 1992, Bradley C. Spatz, bcs@ufl.edu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#ifndef _LIBLIST_LIST_H +#define _LIBLIST_LIST_H + +#include + +/* Define a structure to describe the list. */ +struct list; +typedef struct list *list_t; + +/* Define a structure to describe each element in the list. */ +struct list_element; +typedef struct list_element *list_element_t; + +/* + Backwards API compatibility plug. + We're willing to make the API as backwards-compatible as possible + but we are going to enforce opaque handles, eliminating the macros + instead of functions option. + */ +#define LIST_ELEMENT struct list_element +#define LIST struct list + +typedef int (*list_traverse_func_t)(void *data, void *node_data); +typedef void (*list_dealloc_func_t)(void *); + +/** + A default data-freeing function for the LIST_DEALLOC. + */ +void list_free_free(void *); + +/* Prototype ahoy! */ +list_t list_init(); +list_t list_mvprev(list_t); +list_t list_mvnext(list_t); +void *list_insert_before(list_t, void *data, int len); +void *list_insert_after(list_t, void *data, int len); +void *list_remove_front(list_t); +void *list_remove_rear(list_t); +void *list_remove_curr(list_t); +void list_free(list_t, list_dealloc_func_t); + +/* Define some constants for controlling list traversals. We + * bit-code the attributes so they can be OR'd together. + */ +#define LIST_FORW 0 +#define LIST_BACK 2 +#define LIST_FRNT 4 +#define LIST_CURR 8 +#define LIST_REAR (16 | LIST_BACK) /* 16 + 2, since REAR implies BACKwards. */ +#define LIST_SAVE 32 +#define LIST_ALTR 64 + +/* Define some constants for return codes and such. */ +#ifndef TRUE +#define TRUE 1 +#endif +#ifndef FALSE +#define FALSE 0 +#endif +#define LIST_DEALLOC (&list_free_free) +#define LIST_NODEALLOC (list_dealloc_func_t)NULL +#define LIST_EMPTY 0 +#define LIST_OK 1 +#define LIST_EXTENT 2 + +/* Yet more prototypes. */ +void *list_front(list_t); +void *list_curr(list_t); +void *list_rear(list_t); +list_t list_mvfront(list_t); +list_t list_mvrear(list_t); + +int list_empty(list_t); +int list_size(list_t); + +int list_traverse(list_t list, void *data, list_traverse_func_t func, int opts); + +#endif diff --git a/c/liblist/queue.h b/c/liblist/queue.h new file mode 100644 index 0000000..287e5f3 --- /dev/null +++ b/c/liblist/queue.h @@ -0,0 +1,52 @@ +/* queue.h -- present queue abstraction with list primitives. + * + * Last edited: Tue Jul 28 15:34:15 1992 by bcs (Bradley C. Spatz) on wasp + * + * Copyright (C) 1992, Bradley C. Spatz, bcs@ufl.edu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _LIBLIST_QUEUE_H +#define _LIBLIST_QUEUE_H + +#include + +/* define queue objects in terms of list */ +#define queue_t list_t +#define queue_element_t list_element_t + +/* backwards compatibility */ +#define QUEUE LIST +#define QUEUE_ELEMENT LIST_ELEMENT + +/* Now map the queue functions onto the list primitives. The current + * element pointer will always point to the end of the list, which is + * where we add new elements. We remove elements from the front. + * With this model, we map onto the list primitives directly. + */ +#define q_init() list_init() +#define q_enqueue(queue, data, bytes) list_insert_after(queue, data, bytes) +#define q_dequeue(queue) list_remove_front(queue) +#define q_front(queue) list_front(queue) +#define q_size(queue) list_size(queue) +#define q_empty(queue) list_empty(queue) +#define q_free(queue, dealloc) list_free(queue, dealloc) + +/* Define the deallocation constants. */ +#define QUEUE_DEALLOC LIST_DEALLOC +#define QUEUE_NODEALLOC LIST_NODEALLOC + +#endif /* _LIBLIST_QUEUE_H */ diff --git a/c/liblist/stack.h b/c/liblist/stack.h new file mode 100644 index 0000000..e6e443f --- /dev/null +++ b/c/liblist/stack.h @@ -0,0 +1,52 @@ +/* stack.h -- present stack abstraction with list primitives. + * + * Last edited: Tue Jul 28 15:33:54 1992 by bcs (Bradley C. Spatz) on wasp + * + * Copyright (C) 1992, Bradley C. Spatz, bcs@ufl.edu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _LIBLIST_STACK_H +#define _LIBLIST_STACK_H + +#include + +/* Present the stack datatypes in terms of list types (our point exactly). */ +#define stack_t list_t +#define stack_element_t list_element_t + +/* Backwards compatibility */ +#define STACK LIST +#define STACK_ELEMENT LIST_ELEMENT + +/* Now map the stack functions onto the list primitives. The current + * element pointer will always point to front of the list, which is + * where we push and pop. With this model, we can map into the list + * primitives directly. + */ +#define stack_init() list_init() +#define stack_push(stack, data, bytes) list_insert_before(stack, data, bytes) +#define stack_pop(stack) list_remove_front(stack) +#define stack_top(stack) list_front(stack) +#define stack_size(stack) list_size(stack) +#define stack_empty(stack) list_empty(stack) +#define stack_free(stack, dealloc) list_free(stack, dealloc) + +/* Define the deallocation constants. */ +#define STACK_DEALLOC LIST_DEALLOC +#define STACK_NODEALLOC LIST_NODEALLOC + +#endif /* _LIBLIST_STACK_H */ diff --git a/c/list/list_kernel.c b/c/list/list_kernel.c new file mode 100644 index 0000000..3a5ddf5 --- /dev/null +++ b/c/list/list_kernel.c @@ -0,0 +1,23 @@ +#include +#include +#include +#include + +struct mystruct { + int data; + struct list_head mylist; +}; + +struct mystruct first = { + .data = 10, + .mylist = LIST_HEAD_INIT(first.mylist) +}; + +int main(int argc, char *argv[]) +{ + + + + return EXIT_SUCCESS; +} + diff --git a/cpp/boost/dir_recurs/dir_recurs.cpp b/cpp/boost/dir_recurs/dir_recurs.cpp new file mode 100644 index 0000000..3c059c6 --- /dev/null +++ b/cpp/boost/dir_recurs/dir_recurs.cpp @@ -0,0 +1,38 @@ +#include + +#include + +#include + +using namespace std; + +using namespace boost; + +using namespace boost::filesystem; + +static void Process_Files(const path & Path, bool recurse) +{ + cout << "Processing folder " << Path.native_file_string() << "\n"; + directory_iterator end_itr; // default construction yields past-the-end + + for (directory_iterator itr(Path); itr != end_itr; ++itr) { + if (recurse && is_directory(*itr)) { + // Погружаемся на 1 уровень вниз по дереву каталогов + path Deeper(*itr); + Process_Files(Deeper, recurse); + continue; + } + // Файл, путь к которому содержится в filename, можно обрабатывать. + string filename = itr->file_string(); + cout << filename << "\n"; + } + + return; +} + +int main(int argc, char *argv[]) +{ + bool recurse = true; // обходить ли каталоги + Process_Files(current_path(), recurse); + return 0; +} diff --git a/cpp/multithreading/asynch b/cpp/multithreading/asynch new file mode 100755 index 0000000..024bcb5 Binary files /dev/null and b/cpp/multithreading/asynch differ diff --git a/cpp/multithreading/asynch.c b/cpp/multithreading/asynch.c index 1978c3e..01450ef 100644 --- a/cpp/multithreading/asynch.c +++ b/cpp/multithreading/asynch.c @@ -15,7 +15,7 @@ void * Thread( void* pParams ) for ( i = 0; i < 5; i++ ) a[ i ] = num; num++; - //~ struct timespec ts; + //~ struct timespec ts; //~ ts.tv_sec = 0; //~ ts.tv_nsec = 10; //~ nanosleep(&ts,NULL); diff --git a/cpp/multithreading/mutexes b/cpp/multithreading/mutexes new file mode 100755 index 0000000..2d142be Binary files /dev/null and b/cpp/multithreading/mutexes differ diff --git a/cpp/multithreading/pthread_cancel b/cpp/multithreading/pthread_cancel new file mode 100755 index 0000000..6083776 Binary files /dev/null and b/cpp/multithreading/pthread_cancel differ diff --git a/cpp/multithreading/pthread_cancel.cpp b/cpp/multithreading/pthread_cancel.cpp new file mode 100644 index 0000000..f1b82c7 --- /dev/null +++ b/cpp/multithreading/pthread_cancel.cpp @@ -0,0 +1,70 @@ +#include +#include +#include + +extern "C" void thr_yield(void); + +void thr_yield(void) +{ + printf("thr_yield() called\n"); +} + +//extern "C" void printf(...); + +struct X { + int x; + X(int i) { + x = i; + printf("X(%d) constructed.\n", i); + } + ~X() { + printf("X(%d) destroyed.\n", x); + } +}; + +void +free_res(void *i) +{ + printf("Freeing `%d`\n", i); +} + +char *f2(int i) +{ + try { + X dummy(i); + pthread_cleanup_push(free_res, (void *)i); + + if (i == 50) { + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); + pthread_testcancel(); + } + + f2(i + 1); + pthread_cleanup_pop(0); + + } catch (int) { + printf("Error: In handler.\n"); + } + + return "f2"; +} + +void * +thread2(void *tid) +{ + void *sts; + printf("I am new thread :%d\n", pthread_self()); + pthread_cancel((pthread_t)tid); + pthread_join((pthread_t)tid, &sts); + printf("main thread cancelled due to %d\n", sts); + return (sts); +} + +main() +{ + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); + pthread_create(NULL, NULL, thread2, (void *)pthread_self()); + thr_yield(); + printf("Returned from %s\n", f2(0)); +} + diff --git a/cpp/multithreading/pthread_ex b/cpp/multithreading/pthread_ex new file mode 100755 index 0000000..ff8986b Binary files /dev/null and b/cpp/multithreading/pthread_ex differ diff --git a/cpp/multithreading/pthread_ex.c b/cpp/multithreading/pthread_ex.c index 1b7c642..2dd8608 100644 --- a/cpp/multithreading/pthread_ex.c +++ b/cpp/multithreading/pthread_ex.c @@ -12,18 +12,13 @@ static void wait_thread(void) while (time(NULL) == start_time) { /* do nothing except chew CPU slices for up to one second. */ - //usleep(1); - //~ struct timespec - //~ { - //~ time_t tv_sec; /* секунды */ - //~ long tv_nsec; /* наносекунды */ - //~ }; - //~ struct timespec ts; - //~ ts.tv_sec = 0; - //~ ts.tv_nsec = 10; - //~ nanosleep(&ts,NULL); + usleep(10000); + //~ struct timespec ts; + //~ ts.tv_sec = 0; + //~ ts.tv_nsec = 1000; + //~ nanosleep((const struct timespec *)&ts, NULL); } } diff --git a/cpp/multithreading/pthread_ex.geany b/cpp/multithreading/pthread_ex.geany index b970763..285ab48 100644 --- a/cpp/multithreading/pthread_ex.geany +++ b/cpp/multithreading/pthread_ex.geany @@ -16,13 +16,7 @@ long_line_behaviour=1 long_line_column=72 [files] -current_page=6 -FILE_NAME_0=472;C;0;16;1;1;0;/home/kolan/Projects/cpp/multithreading/asynch.c;0 -FILE_NAME_1=328;C;0;16;1;1;0;/home/kolan/Projects/cpp/multithreading/mutexes.c;0 -FILE_NAME_2=1354;C;0;16;1;1;0;/home/kolan/Projects/cpp/multithreading/semabinit.c;0 -FILE_NAME_3=642;C;0;16;1;1;0;/home/kolan/Projects/cpp/multithreading/sem08-1a.c;0 -FILE_NAME_4=2155;C;0;16;1;1;0;/home/kolan/Projects/cpp/multithreading/sem08-1b.c;0 -FILE_NAME_5=100;C;0;16;1;1;0;/home/kolan/Projects/cpp/multithreading/tmp.c;0 +current_page=-1 [build-menu] CFT_00_LB=_Скомпилировать diff --git a/cpp/multithreading/pthread_ex.o b/cpp/multithreading/pthread_ex.o deleted file mode 100644 index fbc1314..0000000 Binary files a/cpp/multithreading/pthread_ex.o and /dev/null differ diff --git a/cpp/multithreading/pthread_ex_cpp b/cpp/multithreading/pthread_ex_cpp new file mode 100755 index 0000000..21fae1c Binary files /dev/null and b/cpp/multithreading/pthread_ex_cpp differ diff --git a/cpp/multithreading/sem08-1a b/cpp/multithreading/sem08-1a new file mode 100755 index 0000000..d2b58ee Binary files /dev/null and b/cpp/multithreading/sem08-1a differ diff --git a/cpp/multithreading/sem08-1b b/cpp/multithreading/sem08-1b new file mode 100755 index 0000000..cde1fb8 Binary files /dev/null and b/cpp/multithreading/sem08-1b differ diff --git a/cpp/multithreading/semabinit b/cpp/multithreading/semabinit new file mode 100755 index 0000000..2e32e54 Binary files /dev/null and b/cpp/multithreading/semabinit differ diff --git a/cpp/multithreading/time_test b/cpp/multithreading/time_test new file mode 100755 index 0000000..139ef99 Binary files /dev/null and b/cpp/multithreading/time_test differ diff --git a/cpp/multithreading/time_test.o b/cpp/multithreading/time_test.o deleted file mode 100644 index 2f5afbe..0000000 Binary files a/cpp/multithreading/time_test.o and /dev/null differ diff --git a/cpp/multithreading/udp_socket b/cpp/multithreading/udp_socket new file mode 100755 index 0000000..0a28614 Binary files /dev/null and b/cpp/multithreading/udp_socket differ diff --git a/cpp/this/this b/cpp/this/this new file mode 100755 index 0000000..efaeaaa Binary files /dev/null and b/cpp/this/this differ diff --git a/cpp/this/this.cpp b/cpp/this/this.cpp new file mode 100644 index 0000000..f144395 --- /dev/null +++ b/cpp/this/this.cpp @@ -0,0 +1,25 @@ +#include +#include + +using namespace std; + +class foo { +public: + void *operator *() { + return NULL; + } + void *bar() { + return &*this; + } +}; + +int main(int argc, char *argv[]) +{ + foo f; + cout << (unsigned long)f.bar() << endl; + cout << (unsigned long)&f << endl; + cout << (unsigned long)*f << endl; + + return EXIT_SUCCESS; +} +