Mercurial > hg > Papers > 2012 > aplas
annotate paper/rectype.ind @ 37:bda0b56c9231
fix
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Sat, 16 Jun 2012 01:02:37 +0900 |
| parents | f9e7052a380e |
| children | 34a726a5c0d4 |
| rev | line source |
|---|---|
| 11 | 1 -title: Recursive type syntax in Continuation based C |
| 2 | |
| 32 | 3 \newcommand{\rectype}{{\tt \_\_rectype}} |
| 11 | 4 |
| 32 | 5 --author: Nobuyasu Oshiro, Shinji KONO |
| 11 | 6 |
| 7 --abstract: | |
| 32 | 8 |
| 11 | 9 We have implemented Continuation based C (CbC). |
| 10 CbC is an extension of C, which has parameterized goto statement. | |
| 11 It is useful for finite state automaton or many core tasks. | |
| 12 Goto statement is a way to force tail call elimination. | |
| 13 The destination of goto statement is called Code Segment, which is actually a normal function of C. | |
| 14 To represent recursive function call, the type system of C is not enough, because | |
| 15 it has no recursive types. | |
| 16 We introduce \rectype keyword for recursive type, and it is implemented in GCC-4.6.0. | |
| 17 We will compare the conventional methods, \rectype keyword and a method using C structure. | |
| 18 Also we show usage of CbC and it's benchmark. | |
| 19 | |
| 32 | 20 --Motivation |
| 21 | |
| 37 | 22 The C programming language is used in many practical programs, operating system |
| 23 kernels, byte code machines, network servers or embeded systems. Low level feature | |
| 24 of C is useful, but sometimes it requres programming hacks. For example, in case of | |
| 25 byte code machine often entire program is a huge switch statement which has many | |
| 26 labels which corespond the byte codes. Operating system or network server has | |
| 27 many layers such as system call dispatch, transport or presentation layer. It | |
| 28 requires deep call levels, 2 or 3 for each layer, resulting 10-30 call levels. | |
| 32 | 29 |
| 37 | 30 Continuation based C (CbC) provids a structured way to represent these situations. It |
| 31 is a small modication of C. It consists of a syntax to force tail-call-elimation | |
| 32 and parametarized goto statement. | |
| 33 | |
| 34 C has capable of recursive functions, but we find it's type system is not enough | |
| 35 to represent CbC programming. In this paper, we introduce \rectype | |
| 36 keyward as a recursive type. To handle recursive type, conventionally tagged struct | |
| 37 is used. It is also fit for CbC program. | |
| 38 | |
| 39 We will describe the CbC and \rectype implementation of CbC on GCC 4.6.0. | |
| 11 | 40 |
| 41 --Continuation based C | |
| 42 | |
| 28 | 43 CbC's basic programming unit is a Code Segment. It is not a subroutine, but it |
| 11 | 44 looks like a function, because it has input and output. We can use C struct |
| 45 as input and output interfaces. | |
| 46 | |
| 47 struct interface1 { int i; }; | |
| 48 struct interface2 { int o; }; | |
| 49 | |
| 50 __code f(struct interface1 a) { | |
| 51 struct interface2 b; b.o=a.i; | |
| 52 goto g(b); | |
| 53 } | |
| 54 | |
| 28 | 55 In this example, a Code Segment |
| 56 \verb+f+ has \verb+input a+ and sends \verb+output b+ to a Code Segment \verb+g+. | |
| 57 There is no return from Code Segment \verb+b+, \verb+b+ should call another | |
| 11 | 58 continuation using \verb+goto+. Any control structure in C is allowed in CwC |
| 59 language, but in case of CbC, we restrict ourselves to use \verb+if+ statement | |
| 60 only, because it is sufficient to implement C to CbC translation. In this case, | |
| 28 | 61 Code Segment has one input interface and several output interfaces (fig.\ref{code}). |
| 11 | 62 |
| 30 | 63 <center><img src="figure/code.pdf" alt="code"></center> |
| 11 | 64 |
| 65 | |
| 66 \verb+__code+ and parameterized global goto statement is an extension of | |
| 67 Continuation based C. Unlike \verb+C--+ \cite{cminusminus}'s parameterized goto, | |
| 68 we cannot goto into normal C function. | |
| 69 | |
| 28 | 70 In CwC, we can go to a Code Segment from a C function and we can call C functions |
| 71 in a Code Segment. So we don't have to shift completely from C to CbC. The later | |
| 11 | 72 one is straight forward, but the former one needs further extensions. |
| 73 | |
| 74 void *env; | |
| 75 __code (*exit)(int); | |
| 76 | |
| 77 __code h(char *s) { | |
| 78 printf(s); | |
| 79 goto (*exit)(0),env; | |
| 80 } | |
| 81 | |
| 82 int main() { | |
| 83 env = __environment; | |
| 84 exit = __return; | |
| 85 goto h("hello World\n"); | |
| 86 } | |
| 87 | |
| 88 In this hello world example, the environment of \verb+main()+ | |
| 89 and its continuation is kept in global variables. The environment | |
| 90 and the continuation can be get using \verb+__environment+, | |
| 28 | 91 and \verb+__return+. Arbitrary mixture of Code Segments and functions |
| 11 | 92 are allowed (in CwC). The continuation of \verb+goto+ statement |
| 93 never returns to original function, but it goes to caller of original | |
| 94 function. In this case, it returns result 0 to the operating system. | |
| 95 | |
| 96 | |
| 97 | |
| 14 | 98 --Recursive type syntax |
| 99 | |
| 37 | 100 A continuation is a pointer to a Code Segment to be executed after. |
| 101 For example, it is passed as follows; | |
| 14 | 102 |
| 103 __code csA( __code (*p)() ) { | |
| 104 goto p(csB); | |
| 105 } | |
| 106 | |
| 37 | 107 where {\tt p} is the continuation and {\tt csB} is a Code Segment which |
| 108 has the same type of {\tt csA}. This declaration is not enough because | |
| 109 it lacks the type of the argument. If add the type declaration, we | |
| 110 get following program; | |
| 14 | 111 |
| 37 | 112 __code csA( __code (*p)( __code (*)( __code (*)( __code (*)())))) { |
| 14 | 113 goto p(csB); |
| 114 } | |
| 115 | |
| 37 | 116 or |
|
26
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
117 __code csA( __code (*p)( __code(*)())) { |
|
15
68d2c32f74cf
modify explanation of rectype syntax
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
14
diff
changeset
|
118 goto p(csB); |
|
68d2c32f74cf
modify explanation of rectype syntax
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
14
diff
changeset
|
119 } |
|
68d2c32f74cf
modify explanation of rectype syntax
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
14
diff
changeset
|
120 |
| 37 | 121 It is enough to type {\csB}, but of course it is not completly wll typed. |
| 122 Omitting types of the arguments of a function is allowed, but it requires | |
| 123 complex declaration and it is imcomplete. | |
|
15
68d2c32f74cf
modify explanation of rectype syntax
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
14
diff
changeset
|
124 |
| 37 | 125 We introduce \rectype syntax for this situation. In an argument declation, |
| 126 \rectype represents it's fuction type. Using \rectype, previous example can | |
| 127 be written like this; | |
| 11 | 128 |
| 129 __code csA( __rectype *p) { | |
| 130 goto p(csB); | |
| 131 } | |
| 132 | |
| 37 | 133 {\tt *p} has a type of {\tt csA} itself. |
| 134 | |
| 135 The same situation is happen in convetional C, since Code Segment is a | |
| 136 mere C function with tail-call-elimination. \rectype provides exact and | |
| 137 concise way to describe recursive type. If we have extra arguments, | |
| 138 | |
| 139 __code csBs(int a, __rectype *p) ; | |
| 140 | |
| 141 __code csAs(int a, __rectype *p) { | |
| 142 goto p(a, csBs); | |
| 143 } | |
| 144 | |
| 145 In this case, we have two \rectype keywords. It may points the same type or | |
| 146 different types. There is no ambiguity here, because it point the exact | |
| 147 position. If it points the same position in the same type declaration, | |
| 148 it is the same type. | |
| 149 | |
| 11 | 150 |
| 151 | |
| 152 | |
| 153 | |
| 13 | 154 --Recursive type syntax |
| 155 | |
| 156 struct interface { | |
| 157 __code (*next)(struct interface); | |
| 158 }; | |
| 159 | |
| 160 __code csA(struct interface p) { | |
| 161 struct interface ds = { csB }; | |
| 162 goto p.next(ds); | |
| 163 } | |
| 164 | |
| 165 int main() { | |
| 166 struct interface ds = { print }; | |
| 167 goto csA(ds); | |
| 168 return 0; | |
| 169 } | |
| 170 | |
| 171 | |
| 172 | |
| 173 __code fibonacci(__rectype *p, int num, int count, int result, int prev) | |
| 174 | |
| 175 | |
| 33 | 176 |
| 177 | |
| 24 | 178 --How to implement \rectype |
| 11 | 179 |
| 29 | 180 \rectype syntax is implemented overriding AST. |
| 24 | 181 First, \rectype syntax make Tree same \code(\ref{fig:tree1}). |
| 182 Second, tree was created to be rectype flag. | |
| 29 | 183 Third, to override AST(\ref{fig:tree2}). |
| 24 | 184 |
| 185 \begin{figure}[htpb] | |
| 30 | 186 \begin{minipage}{0.5\hsize} |
| 187 \begin{center} | |
| 24 | 188 \scalebox{0.35}{\includegraphics{figure/tree1.pdf}} |
| 30 | 189 \end{center} |
| 190 \caption{AST of function pointer} | |
| 191 \label{fig:tree1} | |
| 192 \end{minipage} | |
| 193 \begin{minipage}{0.2\hsize} | |
| 194 \begin{center} | |
| 24 | 195 \scalebox{0.35}{\includegraphics{figure/tree2.pdf}} |
| 30 | 196 \end{center} |
| 197 \caption{AST of \rectype} | |
| 198 \label{fig:tree2} | |
| 24 | 199 \end{minipage} |
| 200 \end{figure} | |
| 201 | |
| 202 This AST(\ref{fig:tree2}) is made by syntax of \verb+__code csA(__rectype *p)+ . | |
| 30 | 203 \treelist have infomation of argument. |
| 204 First \treelist represent that argument is function pointer(\verb+__code (*p)()+) . | |
| 205 Second \treelist represent that csA is Fixed-length argument. | |
| 206 First \treelist is connected with \pointertype. | |
| 207 \pointertype have pointer of function(\functiontype). | |
| 24 | 208 We have to override it in the pointer of csA. |
| 209 | |
| 210 | |
| 211 | |
| 212 | |
| 21 | 213 --Problems with implementation of \rectype. |
| 33 | 214 |
| 21 | 215 Segmentation fault has occurred in the following program on compile. |
| 216 | |
| 217 __code csA(__rectype *p) { | |
| 218 goto p(3); | |
| 219 } | |
| 220 | |
| 221 The above code is the wrong argument of p. | |
| 22 | 222 The p's argument is converted by GCC. |
| 28 | 223 3 of type int is converted to a pionter type of Code Segment. |
| 22 | 224 At this time, GCC looks at the type of the argument. |
| 225 p's argument is pointer of csA. | |
| 226 csA's argument is p. | |
| 227 GCC is also an infinite recursion happens to see the type of tye argument of the argument. | |
| 228 | |
| 23 | 229 We Solve this problem that does not check the arguments if the \rectype flag is true. |
| 230 The following program become part was fixed gcc/c-family/c-pretty-print.c. | |
| 231 | |
| 232 static void | |
| 233 pp_c_abstract_declarator (c_pretty_printer *pp, tree t) | |
| 234 { | |
| 235 if (TREE_CODE (t) == POINTER_TYPE) | |
| 236 { | |
| 237 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE | |
| 238 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE) | |
| 239 pp_c_right_paren (pp); | |
| 240 #ifndef noCbC | |
| 241 if (IS_RECTYPE(t)) return; | |
| 242 #endif | |
| 243 t = TREE_TYPE (t); | |
| 244 } | |
| 245 pp_direct_abstract_declarator (pp, t); | |
| 246 } | |
| 247 | |
| 248 | |
| 249 Variable t have information of p's argument. | |
| 30 | 250 If t is \pointertype, t is assigned type of \pointertype(\verb+t = TREE_TYPE (t);+). |
| 23 | 251 We have added code \verb+if (IS_RECTYPE(t)) return;+ |
| 252 Thereby we have solved type checking and infinite recursion problem. | |
| 21 | 253 |
| 254 | |
| 255 | |
| 256 | |
| 11 | 257 --Method other than \rectype |
| 258 | |
|
18
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
259 The recursively program of C's syntax can be solved using struct syntax. |
|
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
260 For example, if we write |
|
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
261 |
| 11 | 262 struct interface { |
| 263 __code (*next)(struct interface); | |
| 264 }; | |
| 265 | |
| 266 __code csA(struct interface p) { | |
|
18
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
267 struct interface ds; |
|
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
268 ds.next = csB; |
| 11 | 269 goto p.next(ds); |
| 270 } | |
| 271 | |
| 272 int main() { | |
|
18
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
273 struct interface ds; |
|
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
274 ds = print; |
| 11 | 275 goto csA(ds); |
| 276 return 0; | |
| 277 } | |
| 278 | |
|
18
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
279 there is no need to write recursively. |
|
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
280 Because the struct syntax wrapped in a function pointer. |
| 28 | 281 Code Segment does not receive function pointer in arguments. |
|
18
33b7a54edaa9
method other rectype
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
17
diff
changeset
|
282 Recursively program does not occur. |
| 11 | 283 |
| 284 | |
|
26
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
285 --Comparison |
| 11 | 286 |
|
26
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
287 Here is CbC program that finds the Fibonacci sequence. |
| 11 | 288 |
|
26
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
289 __code print(__rectype *p, long int num, |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
290 long int count, long int result, long int prev) { |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
291 printf("fibonacci(%d) = %ld\n",num,result); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
292 goto cs_while(print, num, count, result, prev); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
293 } |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
294 |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
295 __code fibonacci(__rectype *p, long int num, |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
296 long int count, long int result, long int prev) { |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
297 if (count == 0) { |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
298 result += 0; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
299 count++; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
300 } else if (count == 1) { |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
301 result += 1; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
302 count++; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
303 } else if (count > 1){ |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
304 long int tmp = prev; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
305 prev = result; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
306 result = result + tmp; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
307 count++; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
308 } else { |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
309 printf("please enter nutural number\n"); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
310 exit(0); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
311 } |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
312 if (num < count) { |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
313 goto p(fibonacci, num, count, result, prev); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
314 } |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
315 goto fibonacci(p, num, count, result, prev); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
316 } |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
317 __code cs_while(__rectype *p, long int num, |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
318 long int count, long int result, long int prev) { |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
319 if (num > 0) { |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
320 num--; |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
321 goto fibonacci(print, num, 0, 0, 0); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
322 } |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
323 exit(0); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
324 } |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
325 |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
326 It is written using \rectype syntax. |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
327 Do not use the \rectype syntax program would be the following declaration. |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
328 |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
329 __code print(__code (*p)(__code(*)(),long int,long int,long int,long int), |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
330 long int num, long int count, long int result, long int prev); |
| 28 | 331 |
|
26
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
332 __code fibonacci(__code (*p)(__code(*)(),long int,long int, long int,long int), |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
333 long int num, long int count, long int result, long int prev); |
| 28 | 334 |
|
26
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
335 __code cs_while(__code (*p)(__code(*)(),long int, long int, long int, long int), |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
336 long int num, long int count, long int result, long int prev); |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
337 |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
338 Comparing the program that made the declaration of each. |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
339 AST is almost the same should be created both. |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
340 Therefore, there should be no difference was the result. |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
341 |
|
680becde8c9f
modify coparison
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
25
diff
changeset
|
342 Here is the result. |
|
19
dc62dc1fe059
modify compression
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
18
diff
changeset
|
343 |
|
dc62dc1fe059
modify compression
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
18
diff
changeset
|
344 --Conclusion |