Mercurial > hg > CbC > CbC_gcc

comparison CbC-examples/quicksort/quicksort_cbc.cbc @ 39:9117c3b65bc3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
modify quicksort examples.
author kent@zeus.cr.ie.u-ryukyu.ac.jp
date Mon, 25 Jan 2010 16:14:42 +0900
parents 2476ed92181e
children 3367c5a7ec79
comparison
equal deleted inserted replaced
38:27e6f95b2c21 39:9117c3b65bc3
4 4
5 typedef void *stack; 5 typedef void *stack;
6 typedef struct { 6 typedef struct {
7 int size; 7 int size;
8 void *interface; 8 void *interface;
9 __code (*code)(void*, stack) ; 9 __code (*ret)(void*, stack) ;
10 } frame, *framep; 10 } frame, *framep;
11 11
12 /* quickstart main routine. */ 12 /* quickstart main routine. */
13 typedef struct { 13 typedef struct {
14 int *v; 14 int *v;
24 24
25 __code returner(stack sp) 25 __code returner(stack sp)
26 { 26 {
27 framep fp = (framep)sp; 27 framep fp = (framep)sp;
28 sp += fp->size; 28 sp += fp->size;
29 goto fp->code(fp->interface, sp); 29 goto fp->ret(fp->interface, sp);
30 } 30 }
31 31
32 __code quicksort_start(void *arg, stack sp) 32 __code quicksort_start(void *arg, stack sp)
33 { 33 {
34 QS_IF *recvif = arg; 34 QS_IF *recvif = arg;
86 if (s<e) { 86 if (s<e) {
87 int tmp; 87 int tmp;
88 tmp = recvif->v[s]; 88 tmp = recvif->v[s];
89 recvif->v[s] = recvif->v[e]; 89 recvif->v[s] = recvif->v[e];
90 recvif->v[e] = tmp; 90 recvif->v[e] = tmp;
91 s++; 91 //s++;
92 e--; 92 //e--;
93 goto quicksort_divider(recvif, s, e, p, sp); 93 goto quicksort_divider(recvif, s+1, e-1, p, sp);
94 } else { 94 } else {
95 assert(e+1==s || s==e);
96 goto quicksort_treecall(recvif, s, e, sp); 95 goto quicksort_treecall(recvif, s, e, sp);
97 } 96 }
98 } 97 }
99 /* divide routin end. */ 98 /* divide routin end. */
100 99
109 outif = (sp-=sizeof(QS_IF)); 108 outif = (sp-=sizeof(QS_IF));
110 outif->v = recvif->v; 109 outif->v = recvif->v;
111 outif->s = recvif->s; 110 outif->s = recvif->s;
112 outif->e = e; 111 outif->e = e;
113 fp = (sp-=sizeof(frame)); 112 fp = (sp-=sizeof(frame));
114 fp->code = quicksort_start; 113 fp->ret = quicksort_start;
115 fp->interface = recvif; 114 fp->interface = recvif;
116 fp->size = sizeof(frame)+sizeof(QS_IF); 115 fp->size = sizeof(frame)+sizeof(QS_IF);
117 116
118 /* recvif is used by second quicksort_start. */ 117 /* recvif is used by second quicksort_start. */
119 recvif->s = e+1; 118 recvif->s = e+1;
149 outif->v = v; 148 outif->v = v;
150 outif->s = s; 149 outif->s = s;
151 outif->e = e; 150 outif->e = e;
152 /* frame for quicksort_finish. */ 151 /* frame for quicksort_finish. */
153 fp = (sp -= sizeof(frame)); 152 fp = (sp -= sizeof(frame));
154 fp->code = quicksort_finish; 153 fp->ret = quicksort_finish;
155 fp->interface = finish_if; 154 fp->interface = finish_if;
156 fp->size = sizeof(frame)+sizeof(QS_IF); 155 fp->size = sizeof(frame)+sizeof(QS_IF);
157 156
158 goto quicksort_start(outif, sp); 157 goto quicksort_start(outif, sp);
159 } 158 }
160 __code 159 __code
161 quicksort_finish(void *arg, stack sp) 160 quicksort_finish(void *arg, stack sp)
162 { 161 {
163 QS_FINISH interface = *(QS_FINISH*)arg; 162 QS_FINISH interface;
164 //assert(interface.sp==mustbefreed); 163 interface = *(QS_FINISH*)arg;
164 //assert((void*)interface.sp==(void*)mustbefreed);
165 free(interface.sp); 165 free(interface.sp);
166 goto interface.ret(interface.ret_arg); 166 goto interface.ret(interface.ret_arg);
167 } 167 }
168 168
169 169
200 * | args |fp| 200 * | args |fp|
201 * -------------------- 201 * --------------------
202 * + ↑ - 202 * + ↑ -
203 * sp 203 * sp
204 */ 204 */
205 /* code segmentへgotoしたときのstack spの状態 205 /* ret segmentへgotoしたときのstack spの状態
206 * 206 *
207 * sp が直接さすのは frame 構造体 207 * sp が直接さすのは frame 構造体
208 * frame.size: 208 * frame.size:
209 * frame.code: そのcode segmentが終了した時にgotoすべきcode segment. 209 * frame.ret: そのret segmentが終了した時にgotoすべきret segment.
210 * frame.interface: frame.codeへgotoするときのinterface. 210 * frame.interface: frame.retへgotoするときのinterface.
211 * このポインタが指すメモリ領域は stack 211 * このポインタが指すメモリ領域は stack
212 * 中にあっても良いしなくても良い。 212 * 中にあっても良いしなくても良い。
213 * ただしframe.codeを登録した側で解放すべき。 213 * ただしframe.retを登録した側で解放すべき。
214 * sp+sizeof(frame)が指すのは実行中のcode segmentのinterface(引数) 214 * sp+sizeof(frame)が指すのは実行中のret segmentのinterface(引数)
215 * これは実行中のcode segmentがメモリ管理する 215 * これは実行中のret segmentがメモリ管理する
216 * 通常はこのcode segmentが終了する際に sp+=frame.size とすればよい 216 * 通常はこのret segmentが終了する際に sp+=frame.size とすればよい
217 */ 217 */
218 __code caller0(void *arg, stack sp) 218 __code caller0(void *arg, stack sp)
219 { 219 {
220 /* interface for caller_finish0. */ 220 /* interface for caller_finish0. */
221 double *finish_arg = (sp -= sizeof(double)); 221 double *finish_arg = (sp -= sizeof(double));
222 222
223 /* arg for quicksort_start. */ 223 /* arg for quicksort_start. */
224 outif = (sp -= sizeof(*outif)); 224 outif = (sp -= sizeof(*outif));
225 framep fp = (sp -= sizeof(frame)); 225 framep fp = (sp -= sizeof(frame));
226 fp->code = caller_finish; 226 fp->ret = caller_finish;
227 fp->interface = NULL; 227 fp->interface = NULL;
228 fp->size = sizeof(*outif)+sizeof(frame); 228 fp->size = sizeof(*outif)+sizeof(frame);
229 229
230 goto quicksort_start(outif, sp); 230 goto quicksort_start(outif, sp);
231 } 231 }
235 235
236 __code __returner0(void *arg , stack sp) 236 __code __returner0(void *arg , stack sp)
237 { 237 {
238 framep fp = sp; 238 framep fp = sp;
239 sp += fp->size; 239 sp += fp->size;
240 goto fp->code(fp->interface, sp); 240 goto fp->ret(fp->interface, sp);
241 } 241 }
242 242
243 #endif 243 #endif
244 244
245 245