From 8a8bb95fd99ea96279646fdcc634a9bffd2ecd23 Mon Sep 17 00:00:00 2001 From: Kolan Sh Date: Thu, 28 Apr 2011 13:18:02 +0400 Subject: [PATCH] =?UTF-8?q?=D0=BC=D0=BD=D0=BE=D0=B3=D0=BE=D0=BD=D0=B8?= =?UTF-8?q?=D1=82=D0=BA=D0=BE=D0=B2=D0=BE=D1=81=D1=82=D1=8C,=20=D1=81?= =?UTF-8?q?=D0=BF=D0=B8=D1=81=D0=BA=D0=B8,=20=D0=BE=D1=87=D0=B5=D1=80?= =?UTF-8?q?=D0=B5=D0=B4=D0=B8,=20=D1=84=D0=B0=D0=B9=D0=BB=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bash/xwm_test/xwm_test.sh | 7 + c/fopen_too_many_files/fopen_too_many_files | Bin 0 -> 7951 bytes c/fopen_too_many_files/fopen_too_many_files.c | 17 ++ c/fork_ex/fork_address_space | Bin 0 -> 7898 bytes c/fork_ex/fork_address_space.c | 16 + c/liblist/examples/Makefile | 49 +++ c/liblist/examples/cache/cache.c | 146 +++++++++ c/liblist/examples/cache/cachetest | Bin 0 -> 13443 bytes c/liblist/examples/cache/cachetest.c | 131 ++++++++ c/liblist/examples/listtest | Bin 0 -> 13385 bytes c/liblist/examples/listtest.c | 287 ++++++++++++++++++ c/liblist/examples/queuetest | Bin 0 -> 12830 bytes c/liblist/examples/queuetest.c | 120 ++++++++ c/liblist/examples/stacktest | Bin 0 -> 12831 bytes c/liblist/examples/stacktest.c | 120 ++++++++ c/liblist/list.h | 101 ++++++ c/liblist/queue.h | 52 ++++ c/liblist/stack.h | 52 ++++ c/list/list_kernel.c | 23 ++ cpp/boost/dir_recurs/dir_recurs.cpp | 38 +++ cpp/multithreading/asynch | Bin 0 -> 7959 bytes cpp/multithreading/asynch.c | 2 +- cpp/multithreading/mutexes | Bin 0 -> 8184 bytes cpp/multithreading/pthread_cancel | Bin 0 -> 13144 bytes cpp/multithreading/pthread_cancel.cpp | 70 +++++ cpp/multithreading/pthread_ex | Bin 0 -> 8226 bytes cpp/multithreading/pthread_ex.c | 15 +- cpp/multithreading/pthread_ex.geany | 8 +- cpp/multithreading/pthread_ex.o | Bin 14392 -> 0 bytes cpp/multithreading/pthread_ex_cpp | Bin 0 -> 14416 bytes cpp/multithreading/sem08-1a | Bin 0 -> 8047 bytes cpp/multithreading/sem08-1b | Bin 0 -> 8047 bytes cpp/multithreading/semabinit | Bin 0 -> 8044 bytes cpp/multithreading/time_test | Bin 0 -> 8004 bytes cpp/multithreading/time_test.o | Bin 4952 -> 0 bytes cpp/multithreading/udp_socket | Bin 0 -> 8389 bytes cpp/this/this | Bin 0 -> 8538 bytes cpp/this/this.cpp | 25 ++ 38 files changed, 1261 insertions(+), 18 deletions(-) create mode 100755 bash/xwm_test/xwm_test.sh create mode 100755 c/fopen_too_many_files/fopen_too_many_files create mode 100644 c/fopen_too_many_files/fopen_too_many_files.c create mode 100755 c/fork_ex/fork_address_space create mode 100644 c/fork_ex/fork_address_space.c create mode 100644 c/liblist/examples/Makefile create mode 100644 c/liblist/examples/cache/cache.c create mode 100755 c/liblist/examples/cache/cachetest create mode 100644 c/liblist/examples/cache/cachetest.c create mode 100755 c/liblist/examples/listtest create mode 100644 c/liblist/examples/listtest.c create mode 100755 c/liblist/examples/queuetest create mode 100644 c/liblist/examples/queuetest.c create mode 100755 c/liblist/examples/stacktest create mode 100644 c/liblist/examples/stacktest.c create mode 100644 c/liblist/list.h create mode 100644 c/liblist/queue.h create mode 100644 c/liblist/stack.h create mode 100644 c/list/list_kernel.c create mode 100644 cpp/boost/dir_recurs/dir_recurs.cpp create mode 100755 cpp/multithreading/asynch create mode 100755 cpp/multithreading/mutexes create mode 100755 cpp/multithreading/pthread_cancel create mode 100644 cpp/multithreading/pthread_cancel.cpp create mode 100755 cpp/multithreading/pthread_ex delete mode 100644 cpp/multithreading/pthread_ex.o create mode 100755 cpp/multithreading/pthread_ex_cpp create mode 100755 cpp/multithreading/sem08-1a create mode 100755 cpp/multithreading/sem08-1b create mode 100755 cpp/multithreading/semabinit create mode 100755 cpp/multithreading/time_test delete mode 100644 cpp/multithreading/time_test.o create mode 100755 cpp/multithreading/udp_socket create mode 100755 cpp/this/this create mode 100644 cpp/this/this.cpp 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 0000000000000000000000000000000000000000..83f5feec0ee37e9a2c8f2abb266038a97593ff08 GIT binary patch literal 7951 zcmeHMZ)_V`5ue!kcWKk4xt2>?Aba4597^1@N=tf2Ve_xq6ki+CR06JIQ&D`IsscImgk)TZ>_xKxqrf0gxRf?VQ70)Zvf(NXEbtr zZ`aOfs3RJQrDr;3y7zYM?eeGM{@p5Hjo2jl7(8@TH7@yoj9t;Vp?(rh<3Re4#UhbC z=@C&`E(JW|trhi}R?(%lv{i7zR@2|U2Hw5~4yHLd9gmqQE10xQ6EI!ll%2gW5l@6; zkVso8NF*aMYXViNmQ|;Nkr)gHhI;$V-TvMFJ=i|w$fJIgg9@PB(nXZs9>J8-Y_}=b zFs2HUTZYlV#%VZG--T)&xa6AZ8XdUvziD>h&iQN1-Koug7Y*|t!sheOV$8y)%^g z?dOfm+s52qmWM}&78mqt9gM}R!-_5bu1bge6*TyJHcPP?^Ho2s)4+If!SWPtsL--b zI%;HY9U;Zp{W;Ww^g*~ zSUYz8f&TYE=3jx#z5dK!dkS0LGz!;@eM`wDWB!;A|Cy+-F)$zUH3zVy1?DYZTVVc_ zuM^YOO`$0&{y+G)w4n!M?%jg5?J_O<4K4iu^q($aTVAS2-{q9s|9!rN@GuOH$4aGYDc{YDfDb=>^tMBr+G?5 zcGTVs*3;k@@?l{VFY{tTp07Mtb*8$1lTO$=t!H381M3-B&%k;HTp6HO zC?bJvsU!|@P|&u(Aefy(yloXPNpL9SeamAT{0XEk^z?zQ49Q$SOo7@cn0qiC}3SY6tsfi z4^NpB$>4O@oC=|>NZ=p0;>i>`wAmNNu@c)1PDjSkVH}&mn_snUw{tv&+T-!*Y0QK> zNB@hw1C3~m$oNcnbd*Z_BlHgFBpFYFeHaTgR>l6DM@Ol&|DY+Ubdz}~2z@VB;U)Gm zKQA)S&WfZ%B=bPp*@f6W9NS`_^XQ1syjHBZpX0W-YXP3Y0?lQym-#Lq@>y1_MoxVf z|1$6T5Tm&+_OgCtc>$310#y{b^YWka{%ZO22lwTrQzh_9~MRC3>Tjpr(O24|G3PGrF}WOfksz*-*DN>^QM^>aNfQv zT8V!F&a=JbzpX}BRc&m)PZXKE?Z1yW^pIps{mXtkevbVwIYEcLz|@|M zeZh$TiWjaNPnZuNrr{<1mvxQaqgM0(3K<|xO2D>QjGM*(%DkwZ@aQXaycn@OC!LjE zjO5~~`jy4^)N*}XRlT|sQe`iWR(TFNE4}!nmgh@3UJLTvD90ZIc^;JGb)fM&TaIri zuHWVOMv!&69Ir2)_mtzCK-ST6ya8l=EXNy*=N0AnW{~x)9B(SFQ|0*MxbBQOAyxL` zZkMbp&Pp$A#q*if^xp@v4wUOZ0W!bK@n(>DTaIr7nUCc-?e3Qo4bw`vTl{X4S{mmS zo|S(6q~K|SEw1=KxduL>+F9A(=MdLmW&9I}uXZl+yu#~2uhy|tn!De`auci^4=*9E z;pL_a2xx8)WqO{h=J!>FuN+suSwsJ=HSmXsZ-&x1l;?3h{sE1v-hj;K;zJIoi`37%=f`AB3if TUu_b;%1T&$%&DU@l`;4a9a;&) literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..69231f649a9f79aadf206d851faa5a18f1293852 GIT binary patch literal 7898 zcmeHMU2Ggz6}~%TCr%pM8#ig4y2T^00SDC+CrToh5;TtOcw81IxQ>*Hh{?vgwinjB z%kDUGAe0ohC4=MELh#ti5-+?UB9sS9d0?XePDF)*R8dP5X;nzs;8eI2q7|fB&bf2W z?(BG7DkLNxe5IN5bI*6rx&Jfwe!D+>R0#wGCq;Z-ptMkDNR|5*!q_fF(shfi!VsSj zZDJE>>fteD4pNt6+NHP|OdH5f1zHDBn)1_%0TRjv67jfvS13n_6#Z3_L99#d&92B) z2u&&whq1OcNfGF2$uJF492!x^p@=wxa0cO+E>K`hxqetTd@fOWmlOjelno>lRfVE0 zrsKEmDDrQjQ%Q{~8j_L_Od0njz!8KjKALcx!{l$hb}3N(n35L4(v@tI}`Eb)O6=`_o2>12lQ-8-!I!M2q5$^Fmyt~x&60LVK{EE|549lh_cEA z@!qGL@iCZouxY7bhvjKC^q&G6w&R9BHw&kayT|< zD7ra8SC7*L>&B_UqsR8;6!hqM%we86bGM-|15BX>iYau04|C=h4cAKtzyFXXO1pmm z@8)&`IFu(4awlJcwEKG~qw71jr2HL}F~mDLkkJs+zV`;5-+sk(-Z5wXw0eAGa4DCs zH-x!#ZB>$`7l9Oh3V^@Q&toj+Z2cA}$b2bhE2Ud9lzDGDVLG>;MZ*h+JHSp%Jp+hO z19!CxX14jlN(Yi_|5DA;ug#~Hv!Ukp3mAu4%9&36gRM}f9lw+|v-PVWflcO*zp8&5 z*Z_L_^3CgGko4yE7ZE1VpE+~*jRs8!yJZno7+b^7yTQ-RQvT-k`FYpouI7B}uIWtW zm-_Fc*-BI4&ksta+5Y=8xq#DuADN=^{9nwu6ZaS2*klOP`JL%3$s!A{fu-cIJa76y zhEs{hbP}QEuoDgC!@w27jvZPJJLf}1(>WEo)#H2!ZPPvI+#7V>GUqz~wpkN}T~Ky- zZuh&uhxgnzuYIVRFTH2C?fX6UYuNc`*tyr|{I#dF<88Ba-F#{#vtrJk3PDdKLc#EC zG}IafP7BZ4p^otE`A`=$Q+GMaa(_TKTm%p1OtEC|x{Awkb9fj-^*a~IiTBMh@1lYI8Ynt4tOvHzA-EU)4@R7 zw#^OmFdA{+!6yN@AvEY|3iiING~)chgg7kk$B^%xPa)8az_S4Qi$FzWX7j7cE9zX` zrTUjQ^)(r&+ejNNu+ah=EwIr78!hmE-U6^q%EV#%W!CezBY%HxqYR_YkX$3li}1mM zsZPFOUseps{o_F?h0L;IASwUbrBzqveYdE%vfSXo4n7TJdWdK%(Vaw@@HcFMzJqzs zHpzg$1MoW-)1xjCMe@)3JjwhY!~Xccgk{+NWqopF5A7!90F}E+@)gP__5Ymk|Ek|n zlKSa+qOTD3+YR*gepc%kh$Zb*N;{w*&<|?qefs_8SJzp<3b-#PU#bo?1a#x=aK++shx3i&c-s?cq&;XSdf>A zB_aqQE}gK29#6*MZO5kJJq7~grJ@l#BJ|jVHI|7?#;l1bU|ACSsGZ7W!J$jOItrOk zW@Iux3Jz0H47_w%wp-4bELe}GCMTgK{B88#$ZY_^vBBdqtr#Fx&PDKB)SGx5vF?+= z;2356CB*=#a_*o>sq*6a#~S>b(4qciT?{13IHqs;@U3)C)=B|#oLmg!SpEYrsN?!~5WeGM z;@<%**54l|<39s=-bBqQF{sC5efI6O8z%oNUM291XEn+^_F0ECM+?Ud8t_kmPJ@T* z&+7`#uUh^uA^_5`&!JCrjn;Xq5N%p9*5s-XG4GS!Ocf%zT+_a;{C!$&Ul03~;Z;dq zh0)6UkT+9>otpQTYJG#qsfJf2c~xwIeV~?pYx(=s3sPYxHR@{FZxg&OSKBw1?|G{A zO@i0aYJIcd^|4wXg!>A^tCGA5ql?!wZ>9<-=6vr`t$!HSozq^Gcop;-JpS}LC^Wwk zxtu<)(` literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..df4edb20138b5837a3451795b28d142cc58140b6 GIT binary patch literal 13443 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

`*z)R*WS*3zJ2XmyE_pQ ziw4g&oJsuA7q|i)M4j z^oF9oRMPAf6uetpwa;hkBpEg9(;uLVqj3w-!0HRH37nEo&sc7S3Oa~elIa?gVt>TfTo&N@*y>lG^ literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..02fd67f2e69a49ffe489d3b66d667dc254c88395 GIT binary patch literal 13385 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 +#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 0000000000000000000000000000000000000000..4634ef33d5dcebd2c7be77eb40294c59b7188104 GIT binary patch literal 12830 zcmeHNeQ+Grk$>8iY#}U5hz~oMpm8FBl){VbGL8l0Ze>~a2o`Mo!8w84YP>trE?Mm^ zyR$Bfkctyw;zf3%O69H+LZzsrDwWDtxl%bw7zztaa7;eVcc}!`UG7j3NUhH1B67s# z3kQ3@e(&|}%t(82-Ch3ElV-a6_qzMN*E7>IJJX*Yh-?eg)d_9^@fU(5qbV#QwHKoC z15(u3X3-?V;(D=0ECbSjEi8M8DvoJSKy@%})OtbCdTd$UpACc|ksKx>u9N#Je8Y(o|I;g^2pX0Q(~SxiOxf-p*wH*MwedW6>G5jC<)U66 zQ!R=^SJ&I3>rzKU+_mb>spS4m8*fg<*QJu_!ohV1H*Z?EX=5m#32l(^YK0z+vHkA7 z(t_iEnYO2}tkOIk>LzS_F13Jf#&!+1tFc{$jqI+(wh|lJQj98x82ta#XdXOo(z|>S zWjYsW&eT>YB9?>FoM=4qL1P}7HtHJdhb|+G=0o#4@tZF`+&}Qk^D__byYA^@Z>{{d zU;J+69}?jibk%I_aHvmlj}EQR@E}Tfe+|5?hM)JKznK43HS}+&fv>OO=S&U!wHo*n zHSou3;Qcl5V2ycxw1)muHSjy(r&YXF7Hfx~QEi(we%=_Wg5dtL2LA8pYr`4Ucv;w^ z|7(e_6f-NmcwXW{Jn7RHxSmqUyrZt5Xmn&WlaA&cE9XR`B6`Px=q`H%-FB`&W##jB zp7o<-6wN0evb~6tvkus~ybn#L^ENzM!*Jx)AI{l!ly(bYFOsuIGY3dDlXkp4_Gs1_ z^Fm51I-E==y&V9gb&S@#N!SM=Mx)7mCf3^<&Bv_tu*epiJndo$D<`tKWZD^q3c?iA zaT&FeX%V&KmSdq~e?G5pKcZXk z$<;30eV;H~IE}%r%Z0mhV2=yuoJ=;GT{z`mZebTrxtg2l!rggwrwiwNN;dmkIOTY5 zLoS?hAh(1Ir~3l8tPAI3Lw)A>`Nq<1h;Zp;+8svh%<&f+PnB^f01N5G;>)gKSnYglDQ!%f0krA6mvVJ{1C|$>bbC#b0kxU=X#|40Lc{EIYY|( zNv4p_wMzM8BvUBo1myK^4i^96ug&6X=J@OLJNFEpo)*YV=IQ5KB{^Mxd03QggyP$i zlN3X9qM>-TAH$KI?VT};zpA)fk5La#w>)wW%*|tW&Cuv4 z=)^LMKZjCjE&Atfp-wfe(ph-IG)w0Ar%J+U2V9zHof?H}m)A8k$uhj0{3JR`*O53+ zPPLQ!+)fHDO6$UZLF;9uMLs9IK2KBkcU(@E!AWsoW@2Dw{9;{U`P5gSf39Kbagd3R z&piDEs9AiW_^)R1?^Q4l!^620&*86Nj)PdS`#b2LI3bN*GK;S$lU-!eOD50JO_L(> zDxi~?hA8a?r;ftesk1P21>jn;tDDqgDPI}bOwG#y^wE9$9UPSp;c(%oyy`wGUxoSj z#d6ExRS3TttOQ+k9-ePCi=Vn^77O!mKaW67!Gmk;uaQ?AF>&UU+hFQh8i-Gh)q4 zQynvrV!UHE0&n?f#CleZ_Zi?QR|{UKlLCVjf%fLW?0v&;PMpjvVWJ z3Vfvd4fFYTgXZBkoi*$Knet_%_{T``!q(#N`pQ@R+AN14K$vYcclO;Mzl%M_es8tVB%Hk(S?aby1&Ov$Mg`-C-OhYX`HqNk%Y$8V9H!n ze8PpL$H@#EcuKKH@Z5EiL60Q{5GxJ8V_6$a+>p;{(nA-C>5OAMP{=zKvu?x6*>Xym zoWpan4W2CKv>Q)o)M%BM17(p`3UT1Md}qbuHRGdtW( z&u_r;-FS2ajddsN*eAd|*j-3Ew;JMJD}~T?VL{!7lQC@N1s$Dn{3GPjRUE_IBZG{{ z$p^r-)N470eDtG9hQSK(GF&u@fa#Wya~{1T{Z>TfvoYVEkR9S>yaYqh8C$17XSi z;k`1wToL<%N~Yf~)TSH4lJdLiFYA8w>r{wgJpq1qyjp6j?`oQrME+O-S85-UGXK_) zZ)}0^?;n2my-I4~JInI0woTJ}H67OUfToXX`nQ^XQ`4t3eM!?_Y5H4DFKD`~NsV)jrgG3r*mZQ= zi`OD}0duQ*S%Nn;jhCtz_x5fuw&bjM z${sWNL&ol`N)AKGw}kxkm`dPwe8un?jA*r;Re z2X%6aCYYmFHMy(^;T?n>>f187≈BXe3<-;Y~$CgyLgq7%S@JR1bYpqnAihO$$-< z~Z+J&TVW=dWBlL}~0UO(MemSmzZ)ru+p~lxS`=NIj7jSK|J?Eo+I)U6S zt*W&rY_DN)8<@+nu|4OjFKhcQ-9h<`*3R~vH~N8*D%*4Zo7NNNdNO4^X?o7jfq z$MWC!?77~E>yS3GqNcv(h;R7pMO#>Dwkh(gB9*;={O_TM=C3aoSACW;@yE+=|3jZW zeIlf`TGws;Df?%j>mHvz4^r#W_Wtqw@-%em+~fK4{g&&-xIV0MenOWT&+80$_xQ8= zd1ba;s#VT+B~{OVp2yF9_WZn4()N>Vs43eqeZ^;g$QY8EhYU$XN|DN5!xi~oz>zOr z|Gc(8uN8TnY{28P{2CZqe-8tivi*mAIO$SjdIfkMTXyK(HER`f&JBWRJBCT-YlktS zN4k~NqYvEsA(Bg;Kj#%n6N`;Mb+fV`_Br>Due2852Qk}hAiSV6h#B*J(%l)vOpY(A zUtf97_UbnXzF&FqWtHb}FTPyx{l$wnihcUN;l(c#d_VBwO_k?tFTSuYiu!}d{G6A) z`puPkRWH7_i;_nlDJ$mtL-J;~_ysW4CHeYLoT!&vdPwMM> zQ1?@MuL~@kPZ#wE+C;r?y}dQ?i1f2C4ts$c7}vk9A>jJf0Uqxh z>oD-vMdEpv^wW$=pfF}21U(N^yHES45(;L*_hi({<*YGT;OGHlp{R&%{pj6&cMbLn`gy2}AywgIIL!5sR0XN4 zC}a78s?6lN$v<6mN;R2YUsSp2MU+onxasTimv4HzbqQ>(l2% +#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 0000000000000000000000000000000000000000..df0dd44372dc9fc5eaad49e943fe2c0c5630da6d GIT binary patch literal 12831 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 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..024bcb578e1f2ca7a8d0adc22c71318620e27680 GIT binary patch literal 7959 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 EUqcd^H~;_u literal 0 HcmV?d00001 diff --git a/cpp/multithreading/pthread_cancel b/cpp/multithreading/pthread_cancel new file mode 100755 index 0000000000000000000000000000000000000000..6083776de3c4cb1eb8256678cf88958a17005d13 GIT binary patch literal 13144 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 +#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 0000000000000000000000000000000000000000..ff8986b56732a08e0e4b9b5013f07c5d30d003ba GIT binary patch literal 8226 zcmeHMU2GKB6~5lJ&GKWs5Fne7gi*VsriwQPsHll!vrJAQcn0Alj&+yaY9=YSALC<3uHGicll6{mz|x zc4x+3HLBF7a#l0vp6~qJpSkzU&b{B+65Z;ns}oE<@nu2MXrnG6`!2-5GASyoQ!Em? zcucGojX)Z3=~6@7E-`QO*$U54E2A1fhD^Uz2pZRV|5&N593H%NgtifqBk3oAL25P2(} z$mK*KpGqXMV(3UNDgDS)`HjR7cw4k@bC0<`vOcmwHW4=;et!Ij(~q7j{e+--q~R(& zoWvCIi*b~RNZSuidLmoztLUej2P95&gW@ppxX?UODaKZ*@uIoK^Nth&2hMAh@Sp>C z=CP0icdld2fm0n!Ee@R57U|j?xN~h7V;=-c7hq7@j&7B1VXTa?Uk9ej8{S{2iSpVH zaBp6tqeSvBg_@ZzgVx?8nTBHKnw0-YG7a_2q?E6dOkJNjE9KvkOkJKiBjvY9rmoIR zNclX;)Ww-m$n78Y760&cqj=L8`|Iugy?s|E^?)vnE0_8uyK-iME=osW`0>O9^}!f# zScd?{$w|vsz9zdc;iP>=@zx$P9DODWJ5ksUj|@r|G-Ph$_-u&SrBD1u`FBRwjeNLy z%_!O;jPj&WY}g9J@`~R`oAHKDs;KKm?k|@c!YI~JZ3nJS4S^!fYfg}xp!$rlXWnbn zgs_&MBZ%4-xY&Yvu9l~-PB~jQF|nt;T)O*dxoi}tW}BMVh>O85;Bj0A0>z(6(KThg ze_)E^?`gk!USKHN@3g;*ZUv3gFNOo9!!Rtqb&j6O$?F9)MqGRXFN(3Ly3!`7N2|8f%D2vP;3)Yv`k?>4XLMWe@?x&oRwPY>=_6!&68 z1$>GEZczbmv`-#z_2?gRII81e6jR|F(PBJ29Yv`WEn4B*(c+8YyGHT(@U`yZJ#?b8 zuXv}g_>OV9^}7w4D8=rT%hA(o52GAicgwhR&u^Uk&{|Cm(?zuSuW0d3Z}D&4^IG!S;X>_qVSP=#P(b({TwYLWQuZuPsD_#9mL|VTkYS}h9RO!{WL}=3Z4RwgTD=a z0(=Pu?8o4bfWHa80vA!;w|0xVqrtk>OBMtsFwTV23#WvtTF9V#X>jwHPh#>Nk9f~1 ze8-rtcd15#?Y9?PhhEw#KZ=*aH4I$7)KDf09X|C zPsy~TBK~jn zpe+hrwV&~zk^@Rl`JagYV{!dRud+YaRQoZGQs#PZEBTz#+fn}acm7`W*0icom(b&i zZ&ZA%;$KyKNb$ppd*f{D>3K?P*_KFKnT*yE>4qP30Wbv7(SB!6tg ziX8;EayB34QZkLNimZsFGgczfy}7T|iX9S>L+L_fIF=t4k@&GRoNaF9Y|Y_BE}zV# zU4jW+E|H3ngDPcHmWU+NN!+c(QQU_hK$nTfteA)-hRvZ|Y$Rb0$KlJ8hzwepTpktL z?1e!n5i>TD97Kf~guyK$W7}~K=3zaU85zMyc*p3!kypcs)*8>BtWSqj-8b=mtn#{) zM!0<*7tLYzKjqUQRre({DOGRv)uJrXrxyLsVSiq?XBD7JtLnPt^}%u4p}&JU&;Gp5 zZz~{N!(YK-6AHA(*`M=3NGM-RADsuh29(#b1Df@F?(NqIDkHAEdcl>q$r8Ug{ zyl&4a|5eJ5#)ydRnC}NhIe}%)3)hstPEH_dKiP2m2_rg$i%i*{^H5M#$a#qCXMgVh zH$DEG*L3CZI`l*&QttNpe;XK$3AK-i^Lk17b3L}Un%`MIjDpi&H0riW1st`d%3Tdh z<@@|NG*16fcTX@II>;I<5 zpFWL=LTcdtlm7+SI_sy;Vxkt_hm}(G=B&*pKBup+Fe-pZB2* z<>+01UjLi$rS`YsauWN0(FvkVwnWTnUz6*W3U$k=`e&UW%IwE5$-H(LBR;Jfo>h6| zQDC3L#qH;Q(KMg0{{F|H0A2S~=n-wB8h1ZhoAv2)w6ved?@6bUb{fylYhPda|LV4H z5d6M! zR|(DoZuz4)l?RZtrAi6)U&JyvOK7lgf{9cwy z+{STfEI9aUHSjlp&v#BTDe<}U?Q#wKTfmoz>OAE4>Bqo>^Yn|3KIg0V(Hi)dYT!G7 zFY|?juJSvoleAyr4+zckToN))lb~&GqF3Y{`_;gMm?xa)6)cV`e83a`C5k`Kxy@@b zK6_XB8#UtpqK5qyi8qNeYJSSSNQ8S^;`8JaJ_|}5jSPw-v7}|%r$@qO=1?I$D9mlq zU7Ne3=B}+<_iWi~?(NMF470vCqET7{cZ==5Q<>Pth@2@7`Uz%`H27afs&Vu>7JmO?-B8uW8`y6E$}@ X`&`Y9nF;yTN~dscg*>eOv2tTC!o)4Z@8*TuNHL*1^qO;AUj z`IKKu`Q?;fNqIBn3n;&u@)pXkq5N9PucN$`@;1ubDZhd84$5z&{3giPC(9ouM^D9) z1b*pivV2%qMiXc14q_{U+O9Jfo&WUsqvNIDy>aL>u+<20 zO(e$>6YO4>4`Wp7jYE6Lfd(|L$(W$qMqiI@UVcwyUNx3?ohg?lMt7a5 zD_#4@u8GM>rAp1=G}SG95#yOMVMG1OT%wT@(~5g%uAFP1wI&V(jL7He6T9a>^BEoO zD>xFtp0M_l$;mekfsd+{Ii`}MOkqpmWrmUeJL8Wljo3e!@i(6!IlHF{P-7}4B zWE$C1)5!KuBYSfi*$I-Fb5*q#cMkeqALM=^$osie$PRd|es;uHty?_bQ>}f)qS8RC zyJ-!r#P)VS*aEhehBArn?W(n+CRi&LCn6*(qb2Q;I&D#sB}LyW_)*f19bPUF=7R=p z%VgZ_NG3b%yU_N5Y}mS#ztk)Fd3V?^bW%$bE7}v?sWx|d(n=jQ_8K;Swaw0O7+^sM z0?hOVV@HG$(H$AhfB`WXygRmrTB%R9+i77`!ZOvXoto;%2-U-ga59Ag?o?_+#?KdE zZe{X=gRpa})}g$gZC$ly{q-=Onfr;9?RU2pyg?YHZH0Vk7+2hXoqh@HLa%wlQk?4g zSpv#f$LBV^?}$7~KM5R6QhzDbXR6<=wWsRi9y3$@9*aKyUd>d$*P_3y2K|1E{%tkr z^XSU{i`Sq(V)2iCI@9()Y|&p=gZ>j1{k1jd@3H8wu0emVML$`C{yvNT*J{vz&Z57$ z2L1gO{ZtM52Q2#c)}TLb(ce&m{t=7*eKqJGwdmh%(T@R!#~M77%JdFZ*7Jm?x=~g5 z4$Q=mdIVo;K{^2sN0{R9`2u_z;Df0t$kdl1NB{b?Mi^#oq$eOByON4AO? zQ@)&Hj4; zFkAcsgu3Y;UtihU|1tU3&su1RlG*?G7Q)v49*h5G;F|v51I*_C zI$F>R$S-H6e_ZD_|4)#AIsed>>HqJ5p?}lvUF4tnK+y@gGW`oGHvNsHe}yCyS3>85 zGU}V_Z#(Jh=QyEY#@P{}zlZeov)(lN8zS_NkiK~~H2r^z^y>}52c+L3d}A?Y)OUiu zZT$Ap`1KM$4msX8@ObdJ?u+mrn-eI0n*Se1_*ZyY0jXDi2m3$o)d;cw*CPD)&d~qM z5&nBE{&6of+kY&={~q#hj$b3ShqH+Y{r#lR?PR{G|JR84$0`0KDaIkk-zqcyi(%e? z31!Zoqce>ErU?DhGmL*R=-cLB18saVer%E%e>%c{0}+`Isybm?Wg3joZzM&tzs-7o zMEuECT4T@IWOFuk&&JOG>hYX+JP5&si`EO|n^qw{vXZjCV)!)dQ zr9Og-nd;=|le7)Lq#6XoQD3aWaUIkNT*l>8cIT;Tjy{1-#jxh+lc5dA6I*q16rQB2 zlcSoeK|ma}AOc@hg`?$q(LY_pz_o)o*EvVAqn|>EC^AP~Eox!WQ8c(Aq)U#%oBitK z=wDtNj=zZ2$qC-xR|%ZTX>_W{(Z38+F|0X?4grS9;UDKJ9A|iSa`etO6;DAG`}3z_ zeIjF&@Hox;ixH&c=pBq}VeV9JLP88nj$ZLou>ilN8q|C_i$jWIUEyfowsH|S7A=`_ z6dmeA)4JqTJv|2mN70XH6`yyJsRBpQW-}Frc+N49pz0{v4%bXZE`q=jehnA=>{K@Mf_O z^ZDdl*kZ6BuAr?(-}3=~0pUFcehbu_#s188x{3d$!S5%0Hf>pK|6y$>e0t@+!h23G zW89p6qWNuHt=wt65W#;>^TXd4?w`MCJp3JLAd8 z7#~dBKf4M4F2p5qHB8r$*^$=F@UU_>rTng?uA9r}hH^es>9T7L|L1~tL!mST7lzf6 zzKW!y-F4w2%Fkt7w371%at}f+KjeBtTih*KxG*hcbiFN?Q|_v+yY5)t<+`12wNX#s zgidpP>bl!TM%>|Sp_m^6KmJa4dm9AD*R7H@X;GDnC$6blaipt;w$fR~4X0-%2OVV^>5DSbXED+TSH#f0>xXvaU}CJx7E5qjiT@}A+@T$V z@V&-%A=b+%&*K7@@jNf^rBLShe?>T+n3M3~-<-Dy z$9N?FJ;F`?LSY={5%3i%#0=P`V*;1<|0L{ZfXDX#LAW_T9XkJ@7|%w`ZxT4Jea71fH|;DFd}(K$z@?r0Bkb%D zd}#;It(Y)QY3CVXN3QE%2)?xQTY*bE??>1Rbw9~sXg!p(lZS>Q4r ze)2{;`0k4L6MkYg@fP4z&+Sm)`NMpSbGg79kPHd8iIgq{ zU)*lQ(*oz`BE;7VJVs^2(Fg8vn56v;0i?gB{fz>b_Im^#qcYoPk+gp|gOE%6{Qtfv zmiCtkevHa!f0Mwui1JqPg?fn$;17q2vMem?ItaDH#{kb(1i6MV0O a2{Zig^ZW}2&hJf*8aTfj%q2!bHRgf0s@H?x)4iIdI4+-z&J#zTe9S;%^U6*Td@ z#3}ck`|cqhA0KOU*!~%Og!j%p-#zF4IQQ4%dq-dE4c+NMCL+xBtUl5)^necB6wIPn7^*tF-MJ(^{ z#n5#~m3zn;fJAbDm}*s-bG7~N=p&Rqy-ccs2V{cz(*`V=Y8ngdzP(>{T|1_>vT*^g)Y(9mn30DiQ23$AdVp@U(`Q|2E)D9|>`+=k_v0pip z=A4>Zg61x@qgiEg+ZHRC80%0yRQID@ZqFKraF87lwdM6k7r*&b^lx6>(EHD!)+0^b zVzmC51APy^C>3hlzKH_4-)5D52p%(_(o~-vj<(pA^B(l=%73PYz7x*0)4xX@7K`RfUgm^h-02GQbG*LyAUV93HPiGON8;qAd!D2 zZwyGBZ~Ia2Qs|2{VF|e*6E&;$%vtoGLLQZ~V8I2}Q(7O*#3CcKhfCNH!bG3Z6jKz?oIVVYv+L88Bb-k;Yc>t-j|H)J^tSPRM^CXmX2kz zsbnM(*AHm>(LgAtwxq}P-e`64n^9FZZdXI{p)oSOYe3%`rKc6>~ZQIv;=I*4(bi0dMo zh{e)yGHhWfM{F#D5#G_=t!=?n*b(a6-mPu+ZuV|9(nCYQ+r4*)?xCTs?R}cxyQLz- z?>CE>ZM0L;-G!?TfA#WefaJtZ>cq~rNT!J!ge^|IjyX(wvIkfH`UBXC8%3*86msdW zoIid`9NTBTSZT_C$7FBh*O~I`M3=G$6S=Q#gk^)+fIHRskALwXw(3QqL&=dVe}a@t zbSYWi_$?d(PSFpUXnu8Aa%#VVq|ED^_I=*7WyYGYWQ5Zh#Kh~Ka9XD&Qu_p*Nz`wq zMiXv6YuqNB%3@k!!r9l9=P}__2h#=<&Sx*>`Aj&SK}?+{90O9KfC)FBZ$T4oK5P3; zIG>kP*pLaQbDAk^!s(o58a3f`wlk$oIG?|iH(|o*8GvchgwyPnG6}SGh)gy}Q&g0&)I)D_(qhwZ?FM`&+Niq#(;hdEJmSmbbg*hp|Lb8kG zSt%bUnTEJLUnTED7Bjx8vrXej%O8L7a(@+-DQvOqtX$T8pDSwM(8lpnKl)phT z4NV~+lqC2^l{(Y)vyh;Z`M1~Vk0R-y+U|ej)LxLcW%bv|Oi+Ensn1_^dxX%J z{eU29TjR+qsOOF1{2QmttwSHqG|Vgwh*NBDBd3>D=38Z-CI2^*;hK{N*M>#@yPp(` z$7e8|Pmp+$9w?}Th39~m`-k>X`GrBCG=Ev{VL7*_Eg#G!+7?dIn1*sAZCBv_75QI6 zK|;YZ0l8rW&j{*yFn22d6XXRCf2GlX*_27$4CemjxQ_-t_iBDSl;FvZu9s+W1gCp} zUMluu2DpN`pCQqcn-5N}Yzs~&+8RUCBW-Rpe+3*n33U-X{8cJGSCHl9KfFqXjsInE znrh82l4XxS9h@eu{C^s`PxksRT>N%l?zBy1q1?N9AFPmj@fR~?|J*y^f19S;MgQKG z)jjyV@M3Rw%ZY`P^c*&I%8_rPuIA3w{}>sV ztjCvn(Az*hIQ{Gb3JE^;p1yJNtDOR^&0Wf$|Cp3|#R*!W(jmT!PqeI-LwEo0pPI@4 z85Dkl_9duNw6CqyzMrB1Q~O3s?R#HVU4P53ZQr(QweRDP(7rMmYr3J>@Al7CuV%Sk zPk_+`G;>|caZai_OOd` zP9tOdeR2V|7-O%?-%ie?Qv_qJ$bqMdh{uC-dYB)f}aO}0lW!Ac@}&n_*L-Rz}ubRSa*ZqXTf#w1on&5sP7Q? zdGMp)7oh(<`18nriSofq@39{4-z6Lq?nN&8C3kC6L*opzjc3U=@M9=fK5zCkyBXhx z#IwN7&vC85262V|s~S%LAF{#e1njrLj{*Vd{IwxfG|bHqGQDhJVCa9VZk9L za4P+kqxDUPxactdU|{9z{JICOd*HeUu6y9R2d;bI|Gfw36%Nrc^?c18Hqc^`W#)K< zk!0mv7W{-#U_E-rOT;q0vnAqZvnz`OQs#GhLG?QYk5-aqodL-|{8ceUi6NIE^CQe$ zy&?0v&Lb+H-$CwC4^RB=aRn6uT5hn?9ZyG+@~gv=^E1~G)n0y1<9Da@ZILK^LqKxI zg_8LhJS=mC;CH25KVFf^{`5B*_VBxux!(&)Ua9g`G5_~$RoJ$U_4pM+)S>vDir=UB zUd8t-{xXn~28Jx`wtUV!|8MQ<*H9V6X?GP)9A1v3L~PDHM#G zSJq~fJe-AgG&ME`-!0p*>V3_ zkNFVtY0qJq_nm%aKdbDi{p2%lzk5|2B}`;jo)yVXA9ra=XHEDmRTw~;L#1vlGs+>=io zWb`}ROl-&4A0c73=W{M7U*eQwL|C8eXZf(QXa9%QIT=>=5lj0$Y^XTBdmt6I=Qtsb zA9~uNZ>|5&E%u`~1*F9&y-WjzxL`vpjh_<5_mD8xPp?skUQh?|wf2vb&?S4d+)Qy< zR0`hf7_4;X`NP0#NSN*EQxH-9Gm^<~!bZxtTkZcIu-TqI0})+O_EvqX{3dj1?sEIf z@nKX7zAsbZAfDfB&-3VQG`@+zh3ZpSBWnYe2!J(4T8_7O1x3Sa5 z=1dnNMR;GT#Ft~A37a9Ac2P8=&GWhok&nDTn2lW6C3)Rf;x`Lk&y{#NeytLxr@>01 z`C2F5uln6c`(1(a z9U>!VwV$7=fzJYWIII2n*T9#dUj81%>-tB)J)+ug=Yg+5bSZzAQpdA+pUY9-!+0-o zpyO0NKTkkSQX}xS!1+5G*ZXOy&st?p->f`kv6Q;22Cmg8CtCx5TH@8~<+&RA{{Wo) z;8_-sZP}n&^mYyXkCZ-t$D?^evaHfYW$UbPEyBtB+LqGi$>V=UY*hgZ)9xLvDX7 z&VOp>jHR8o0jK^>Dt%r@T}nS}(f^Xd`z`pFf!pf=?%CcI(zHHJ+pRw8?<_?vbZ=I{w4qK-iz8|o zuUTx=wq(YWQqfw#Fz2XR?z!{MfnEghc5M&!BB)u03u}=~CUQWFB}Xa&8AvO%o-gg} zy1TF2rrKc{+e|NGjG$Yn3=UMqC8)66Xm(taZ-z>`J5|Vq5g~0KFdPWT*j*!Dm%^wk zVzO-_yp1Sli`g}zr7N_(i2YR!wU1S<(55cm$Dt!t0mw>KMIJ-7ucTT%)IG*fTSqV= zu?9S(BG7P4Bx0V=)p>YU9}$jlF3kd6F8j@l`cmI}|<;Fojmr zyeRj)H10l3SsA)rSw7cILHdwRsVvc^Y1wmX~2U zY`>x^IkhYP<)Oy^Bv@R+!|V4O|Ba#T9ZyDk=|2zT4pZHFnyyt1RhvRpuk4hEYb>2% sW9h`?>tefq!LYO(|5;)2K*fI_AW!{2f&5MJeqx{iD;tE{50L+7;}XlKTm zS1d{*q`)#M)w=N``WJB%v(YsnM$HB`P*UY1ZWRAo64!+6N}Q%{gt(Gb!;a_Nch1av zkB$-(|B^F#@7(jd=Xbw9=HB!Zz$bvL({;LnoHxLpCCX&16B55o$m zN2CrPUB!@gLZV{P1XWGy^0iKjD9XP)TOTrkm6KdKu&r#QV+0Ua%}by8faiY8x@ z9XIVHg^zJU$3i;6XgfNrECA8M+lf3X=lzP5a~J1VtzC*-KhbQ$kw^(0FvL6 z!>N56I-VR(whgD!qhoDjog3OVbVT!+=vviY&6p(Rv31+?DsgFl?pC02Lut_%p!zo8 z;}_yk8q_xAPeQgl3b@Y~akP1SS0mOk55Bw#-d+Xot%9$qf_GQJ!88X)GHEk!CvvuF z0yc9$wdw|p$mUXMd%)};Isn#K%7y_ua{ys-VgHdtDh+vSB$K80pk>3>c<-ieb8U28 zw4)qe8(ojN0|c;D1N^H&O?^fWiM=d^T@{2K7$$6VIoSc&OOYryn);NczN5A+OLLzJ zQh)N4QFh3MOJ7n%vkR9wKzOSQcdrwg3wO_xhzoa*C1d>0q2iA*!QxX`%;L|nOvd;x zLo=oIXB#yrt$H2bO)GT_kv&9N&)z7ZtokY0RJGY_%Kj1ARHfNzW&eO|s>1APWxqr=6@7LJ?e=$j3%~oKQFz-J|KqJ4yL&HB>kT>>moM&6>he^*4#n@H<9kz6 zRAytMZUH7>9G|uWrE99lQ*L?QDBOIG9FIJsqaTbui;PcV=v)j}Hsk1Agw(}<2946M zjg8my;ii>Guq)ZlAw8Gk_9pT6v6U zK=~Qt&%Du~;n-+-jUXyp=t3vvbG3Bi>WsT|styt3H5`Po&bIbM`yHe3C!G<^6XV3luoAEp~b>VXHWd}?elXkfItOF9OrBoud6o3>C$>R4M z&voYy;F@}YJlm&>JqWf>V+|rR=hwLKHHcrJekrzK==@HMntSKGPUhg*&~4H;u`*m+Cbre)Ddr6rWsm z0>kkqZWF3juF}%CjM9v;aV|G!OzaI~PY;Ki;}gkn zYaBybe8LV#;uD9%F|0&qxmC;kjolo<9E|bzOZKvJwCy#m>;a%LGKXmeDPr_CccC+u zioeB@5i&z_H2~d-^lDohw9-~CVO!b(>ri7Evo-9qR8oL1CsMXHkjZKNnRGH`r!r}b zk)W2!YuTKYx6*ba4Tzc*!KXFUG$|HhD}NmI>!^35egpL|YV1EHHDB2UHDk>+D;73{ zrm*h_r~e99u&A$+N6+FIDZ)GO=|jGIJqaTg$7c`XCs9LUyx|*xuLmbFcTAF6^#(W-&{gPf zACxi_CiBb8leM}E37%y;#PO1!oJ+*UZAH~bXMb!rWlKBVVmrq1oZSCh$$8bE(H8Ef&#)d~ zeUSAD*56_6=Wp%qeoBjM#jQM((K@0X(e+xkJ-T*{mQ7i0F|waXv(U*WL^qFCp|iZ2w&#w83yRT6$$x}$h?qr=)8Le$GY%keis># z^85KJF?>CZ56x}i%lr@Vgr3GYl6rio?vlUE!*0aLRrs==Tw(qY#<|7cexJffn!Cc6 z`5NO2HZxhuFMgu;U_7k_V#|7NRm7-GsC*={p0{#_lD`vMS=Yrrhygc0#_LCn`B`yf&BZG3BS(FFxsN=} z{4r@5=1YG_vM>7ht-SxVaz*(%Pu$D#gzTDr*yNNQ^Kf_FcRC*a_VV+8=Ht_mpCrN!_n-LZ(3kpO@~7iI zNhkCD`T6Z>^rf*UeA&O`9`-aPjw0hz_)@N`80XGk?wxKlDO!2FJ62`&Ia^*eCSqF_DOeS5KD4qUjN$i|5mSm9msy=#p^-#AurwlvcGuo5Xipa#TS6= z2VT4pWS#fo50%$%FTN0DUH0OO%HMyy_+pTC)QdNPtdCy2x%}P2i!T9L&%Ag`d7bj& z597Mi=Y~``h_^hluDBzEcnXm9!izszzJK=OkCo2{Uc41#-g@z6p!0n6;&l7(6&j|s zaJzhtl33bvYXbM?`w?;ow7^ndeb-gNx2SaPt?zckH9Qsh%l|pVTVN6B4LXJ@b96t3 z3736VMdFM8M`&WW^brheE?a`%!oYmrMSfTXpH}$22s59|pQ5cT1N_e-Y4iJjqG*2H2_6zg_Z=lP@s7!#p!lUqjX)qG||^3_qVD_41I&*wEZ8gDo#XqzFm1Svv)g|D49x|qj@W- zzJ2)|OiyK!`HVS~NGFFaEKSeu?Yqp)+j{VW8hPpRpnP;-Tq%Czg KRA1K|*1rG><5zM3 literal 0 HcmV?d00001 diff --git a/cpp/multithreading/sem08-1b b/cpp/multithreading/sem08-1b new file mode 100755 index 0000000000000000000000000000000000000000..cde1fb801b32b4531f203fb1c5de431cff937aef GIT binary patch literal 8047 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 literal 0 HcmV?d00001 diff --git a/cpp/multithreading/time_test b/cpp/multithreading/time_test new file mode 100755 index 0000000000000000000000000000000000000000..139ef99eb0c4f1bcaa9f22b946cf12a086622b49 GIT binary patch literal 8004 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 literal 0 HcmV?d00001 diff --git a/cpp/multithreading/time_test.o b/cpp/multithreading/time_test.o deleted file mode 100644 index 2f5afbe6c54bc1ffa2cf90712cde44e6afa89b8f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4952 zcmbtXU2GIp6uvXFZI|x0EG>TqVg_-s#CEnMprk^nsmL}diV`%KXr0~8c2{<1mYvx` z8%>EO;0h?k=#v^_q9HyQG)jmufFY4+Oyofy@W~ev9(cf*7!r+m&b{YOcW;LmJ;}~F z-*F5-h**~ZRW*^}^TT#@*8_W17GUt0GqnJ|f%Fd1uG$&Buy#3PBZUdGy&LM$2`8yKp1 zuV%y(33O`!mvn`(TRR!+w6q;bk^De%tQQ9yX~(!kTNtN9Tyirr;$jGdU7CiqyVt=G znFLJwB6L*;4de0tMm3qc@u9~%xYA$|fOLUkMDnfB^)~bwv9^*MKmtdxcn8<|J1>B* zJwAik8jo*}9|h2Xj7S_Wf*B7gY^!l}8_Z@2KxQ0!7M}WgLaz%H6TXH(ae>|tC@Ii! zfl>mU5NNqTCk0w9(3=9S73eL2Oo2}0wDt9U0=<2Nqe0dwI@YFPaFl!s0oY`wwPA=c ze`1axdW`uab4k}b#I)3L@app~CIcT%(OK~6^TlMYUSL|!IUadx4%+5JRD1kgcy?jG zx*d2t$=Ea~ojn6jP5Z063!ePNfjli!_iLGwn=jWVolLF-<(nDCf>Onq2pm7K@{rDg znX2PkMSRoH0~S9TOT+*=fByn>oAUAnsvNFpO1PX*l2Dy)8%?6OWS68 z|3JDjke)Qt*`f6Aq4Zue{TzOzSd~!-G<> zOD=c!hc13h!xULAB*+LV6Ne`48D`g}rdg)wRh-NLuWY-SJvHwoCm;Bke6^aX)XPCB zDApW%vgA%NNGf{u8tPfkby(f?OH-~hY37SIXQwKGS17Qu=T4cS6W$TL2RT~F*YN6pRFW@`(t?71{JP6O*W zFjYQ5KCjmKS8x!vYjkwT?AztIf#-=zW_6P_*l$)#&cGm6-be$8W-h0mYO_x>?Qlw4 zlkA9}g3VbAJbqC4K0Ml;8a=9a@$Ud6Eq|sG*g4QaP3WSuYEId<0_SkRtVuhtnU(W> zFr8d|YQoOtYR)vXc#NP*Zoz9I$|cwztLBMh5mff_Eiu)4&b2EJ)NQI{*KBtRIgtbN zVOHL&RG=Hoa=pN@pu+=xVCN4|o>QDC)SwQo=zoa`+4!1-{h?|jq}8)5Um0?^>2_ChW*1mQv0_LIJG8Fte^5`5j2S!i?@xa@qgmUH-v$nAhTq&^qkKZ+X9NtN>i8w_s2m3WLiyuirZCi4{C!e6j9f>H!t>cIYHR?` zsP*5DSbq{?)%Cv#oLUpd+eSqP5j2S!+W=qG_$jzNp~!sfKV0q>jsHGySX0J<$)zmU zuM8-m)Mp?%D*qV2Br*0N)ssr*N&PwHOTW}#P`<=c%RGs{0|Pnr{G6x!tum0b?7yVH z1tY3|BhRV@JF!;j| zA%?iqF7g)caT$yb&mtaAORIDN>}l%fL2_ed+;3Ix0V0aO z_bz+y#ekR1#VR9a9LlN6YhjOqhPZ8@BxCy z7+3%I9U=Wlf*_A;mHaj&L6FBTN`4GU5LqAJ2NZc($9TNc$@l^~L6BboAIalyAPUxL zK7H~;AdmJn_@Kxgll*Bx^O|T%9`_Li_XkCNuh$7Wdj}-m`!ePh}Ha`Y(t$HbcoFZ*jL{C0{T zR`?%?A0r+Wo@pshDZD&a`lahu;GX=A9gu|LvA RUVdk(bxd@EVD0Am{{nwb!Jz;E diff --git a/cpp/multithreading/udp_socket b/cpp/multithreading/udp_socket new file mode 100755 index 0000000000000000000000000000000000000000..0a28614fa5bfb9be10da70c4d0209f6bd4cc4561 GIT binary patch literal 8389 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 UV`fZ#Mx(drc23CSJ$nHE1SywI3IG5A literal 0 HcmV?d00001 diff --git a/cpp/this/this b/cpp/this/this new file mode 100755 index 0000000000000000000000000000000000000000..efaeaaaec5d8edb6d799a3f19e6a63b262eefbb2 GIT binary patch literal 8538 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 literal 0 HcmV?d00001 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; +} +