Mercurial > hg > CbC > CbC_gcc

comparison CbC-examples/quicksort/quicksort_cbc.cbc @ 25:2476ed92181e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
modified machine description of i386 for support indirect sibcall attributed fastcall.
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Tue, 27 Oct 2009 16:04:06 +0900
parents f37d7058d1ce
children 9117c3b65bc3
comparison
equal deleted inserted replaced
24:f37d7058d1ce 25:2476ed92181e
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 (*code)(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;
15 int s; 15 int s;
16 int e; 16 int e;
17 } QS_IF ; 17 } QS_IF ;
18 typedef __code (*RET)(void*); 18 typedef __code (*RET)(void*);
19 19
20 #include"quicksort_cbc.h" 20 #include"quicksort_cbc.h"
21 21
22 /* for check. */ 22 /* for check. */
23 void *mustbefreed; 23 void *mustbefreed;
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->code(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;
35 int a,b,c,p; 35 int a,b,c,p;
36 a = recvif->v[recvif->s]; 36 a = recvif->v[recvif->s];
37 b = recvif->v[recvif->e]; 37 b = recvif->v[recvif->e];
59 goto quicksort_divider (recvif, recvif->s, recvif->e, p, sp); 59 goto quicksort_divider (recvif, recvif->s, recvif->e, p, sp);
60 } 60 }
61 /* main routine end. */ 61 /* main routine end. */
62 62
63 /* divide routine. */ 63 /* divide routine. */
64 __code quicksort_divider(QS_IF *recvif, int s, int e, int p, stack sp) 64 __code quicksort_divider(QS_IF *recvif, int s, int e, int p, stack sp)
65 { 65 {
66 goto quicksort_divider_s(recvif, s, e, p, sp); 66 goto quicksort_divider_s(recvif, s, e, p, sp);
67 } 67 }
68 __code quicksort_divider_s(QS_IF *recvif, int s, int e, int p, stack sp) 68 __code quicksort_divider_s(QS_IF *recvif, int s, int e, int p, stack sp)
69 { 69 {
70 if (recvif->v[s]<p) { 70 if (recvif->v[s]<p) {
71 s++; 71 s++;
72 goto quicksort_divider_s(recvif, s, e, p, sp); 72 goto quicksort_divider_s(recvif, s, e, p, sp);
73 } else 73 } else
74 goto quicksort_divider_e(recvif, s, e, p, sp); 74 goto quicksort_divider_e(recvif, s, e, p, sp);
75 } 75 }
76 __code quicksort_divider_e(QS_IF *recvif, int s, int e, int p, stack sp) 76 __code quicksort_divider_e(QS_IF *recvif, int s, int e, int p, stack sp)
77 { 77 {
78 if (p<recvif->v[e]) { 78 if (p<recvif->v[e]) {
79 e--; 79 e--;
80 goto quicksort_divider_e(recvif, s, e, p, sp); 80 goto quicksort_divider_e(recvif, s, e, p, sp);
81 } else 81 } else
82 goto quicksort_swapper(recvif, s, e, p, sp); 82 goto quicksort_swapper(recvif, s, e, p, sp);
83 } 83 }
84 __code quicksort_swapper(QS_IF *recvif, int s, int e, int p, stack sp) 84 __code quicksort_swapper(QS_IF *recvif, int s, int e, int p, stack sp)
85 { 85 {
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];
98 } 98 }
99 /* divide routin end. */ 99 /* divide routin end. */
100 100
101 101
102 /* recursive call routine. */ 102 /* recursive call routine. */
103 __code quicksort_treecall(QS_IF *recvif, int s, int e, stack sp) 103 __code quicksort_treecall(QS_IF *recvif, int s, int e, stack sp)
104 { 104 {
105 framep fp; 105 framep fp;
106 QS_IF *outif; 106 QS_IF *outif;
107 107
108 /* interface for first quicksort_start this segment directly jump to. */ 108 /* interface for first quicksort_start this segment directly jump to. */
122 /* recursive call routine end. */ 122 /* recursive call routine end. */
123 123
124 #define STACK_SIZE 10240 124 #define STACK_SIZE 10240
125 125
126 typedef struct { 126 typedef struct {
127 __code (*ret)(void*); 127 __code (*ret)(void*);
128 void *ret_arg; 128 void *ret_arg;
129 stack *sp; 129 stack *sp;
130 } QS_FINISH; 130 } QS_FINISH;
131 __code 131 __code
132 quicksort(int *v, int s, int e, RET ret, void *arg ) 132 quicksort(int *v, int s, int e, RET ret, void *arg )
133 { 133 {
134 framep fp; 134 framep fp;
135 stack sp0, sp; 135 stack sp0, sp;
136 sp0 = malloc(STACK_SIZE); 136 sp0 = mustbefreed = malloc(STACK_SIZE);
137 mustbefreed = sp0;
138 sp = sp0 + STACK_SIZE; 137 sp = sp0 + STACK_SIZE;
139 QS_FINISH *finish_if; 138 QS_FINISH *finish_if;
140 QS_IF *outif; 139 QS_IF *outif;
141 140
142 /* interface for quicksort_finish. */ 141 /* interface for quicksort_finish. */
156 fp->interface = finish_if; 155 fp->interface = finish_if;
157 fp->size = sizeof(frame)+sizeof(QS_IF); 156 fp->size = sizeof(frame)+sizeof(QS_IF);
158 157
159 goto quicksort_start(outif, sp); 158 goto quicksort_start(outif, sp);
160 } 159 }
161 __code 160 __code
162 quicksort_finish(void *arg, stack sp) 161 quicksort_finish(void *arg, stack sp)
163 { 162 {
164 QS_FINISH interface = *(QS_FINISH*)arg; 163 QS_FINISH interface = *(QS_FINISH*)arg;
165 assert(interface.sp==mustbefreed); 164 //assert(interface.sp==mustbefreed);
166 free(interface.sp); 165 free(interface.sp);
167 goto interface.ret(interface.ret_arg); 166 goto interface.ret(interface.ret_arg);
168 } 167 }
169 168
170 169