怎样从c代码文件中抽取出完整函数函数信息

liion631818

RT，函数里面的信息可以是任意满足c语法的内容

抽取出来的函数信息应该是
void fun()
{
  ....
}

Herowinter

回复 1# liion631818
我的理解是把除了函数定义之外的一些全局变量
和结构体等的数据结构定义代码删掉？
   

liion631818

回复 2# Herowinter


    需要的抽取指定函数的信息，不是全部的，有什么好办法吗

Herowinter

回复 3# liion631818
那你的输入是指定的几个函数名，
输出是那几个指定的函数名的具体实现代码，
不需要考虑头文件中的那几个函数的声明吧？
   

Herowinter

不大理解为什么要用shell来做这个事，CDT或
vi或emacs应该都提供这种功能了吧。

liion631818

回复 5# Herowinter


    好吧，我只是想把他写在脚本里。我用c写了个可执行文件，配合我自己的环境，目前可用。

Herowinter

回复 6# liion631818
你来一段具体的文本吧，这样需求不是很清晰。
比如，文本里会不会同时出现函数fun
的声明、实现、调用。

1. int func(int a, int b);
   
2. int func(int a, int b){
   
3. ....
   
4. 
   
5. }
   
6. func(a,b);

复制代码

如果你指定抽取函数func的信息，这3种形式都要吗？

还有这问题其实是找到函数名，然后匹配"{" 和"}"，
这其实一定程度上会受coding style的影响，比如"{"
是和函数名同一行还是在下一行。
   

liion631818

回复 7# Herowinter


    只要函数的实现，格式不固定哦，所以有点麻烦，我用c代码实现的被中文搞死了，唉

Herowinter

回复 8# liion631818
Just a simple example, hope it can be useful to you.

1. awk -vf="ngx_create_chain_of_bufs" '$0~f&&$0!~/;/{in_func=1} in_func{left+=gsub(/{/,"{");right+=gsub(/}/,"}");print;if(left>0&&left==right)in_func=0}' ngx_buf.c
   
2. ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs)
   
3. {
   
4.     u_char       *p;
   
5.     ngx_int_t     i;
   
6.     ngx_buf_t    *b;
   
7.     ngx_chain_t  *chain, *cl, **ll;
   
8. 
   
9.     p = ngx_palloc(pool, bufs->num * bufs->size);
   
10.     if (p == NULL) {
    
11.         return NULL;
    
12.     }
    
13. 
    
14.     ll = &chain;
    
15. 
    
16.     for (i = 0; i < bufs->num; i++) {
    
17. 
    
18.         b = ngx_calloc_buf(pool);
    
19.         if (b == NULL) {
    
20.             return NULL;
    
21.         }
    
22. 
    
23.         /*
    
24.          * set by ngx_calloc_buf():
    
25.          *
    
26.          *     b->file_pos = 0;
    
27.          *     b->file_last = 0;
    
28.          *     b->file = NULL;
    
29.          *     b->shadow = NULL;
    
30.          *     b->tag = 0;
    
31.          *     and flags
    
32.          *
    
33.          */
    
34. 
    
35.         b->pos = p;
    
36.         b->last = p;
    
37.         b->temporary = 1;
    
38. 
    
39.         b->start = p;
    
40.         p += bufs->size;
    
41.         b->end = p;
    
42. 
    
43.         cl = ngx_alloc_chain_link(pool);
    
44.         if (cl == NULL) {
    
45.             return NULL;
    
46.         }
    
47. 
    
48.         cl->buf = b;
    
49.         *ll = cl;
    
50.         ll = &cl->next;
    
51.     }
    
52. 
    
53.     *ll = NULL;
    
54. 
    
55.     return chain;
    
56. }
    

复制代码

ngx_buf.c

1. 
   
2. /*
   
3. * Copyright (C) Igor Sysoev
   
4. * Copyright (C) Nginx, Inc.
   
5. */
   
6. 
   
7. 
   
8. #include <ngx_config.h>
   
9. #include <ngx_core.h>
   
10. 
    
11. 
    
12. ngx_buf_t *
    
13. ngx_create_temp_buf(ngx_pool_t *pool, size_t size)
    
14. {
    
15.     ngx_buf_t *b;
    
16. 
    
17.     b = ngx_calloc_buf(pool);
    
18.     if (b == NULL) {
    
19.         return NULL;
    
20.     }
    
21. 
    
22.     b->start = ngx_palloc(pool, size);
    
23.     if (b->start == NULL) {
    
24.         return NULL;
    
25.     }
    
26. 
    
27.     /*
    
28.      * set by ngx_calloc_buf():
    
29.      *
    
30.      *     b->file_pos = 0;
    
31.      *     b->file_last = 0;
    
32.      *     b->file = NULL;
    
33.      *     b->shadow = NULL;
    
34.      *     b->tag = 0;
    
35.      *     and flags
    
36.      */
    
37. 
    
38.     b->pos = b->start;
    
39.     b->last = b->start;
    
40.     b->end = b->last + size;
    
41.     b->temporary = 1;
    
42. 
    
43.     return b;
    
44. }
    
45. 
    
46. 
    
47. ngx_chain_t *
    
48. ngx_alloc_chain_link(ngx_pool_t *pool)
    
49. {
    
50.     ngx_chain_t  *cl;
    
51. 
    
52.     cl = pool->chain;
    
53. 
    
54.     if (cl) {
    
55.         pool->chain = cl->next;
    
56.         return cl;
    
57.     }
    
58. 
    
59.     cl = ngx_palloc(pool, sizeof(ngx_chain_t));
    
60.     if (cl == NULL) {
    
61.         return NULL;
    
62.     }
    
63. 
    
64.     return cl;
    
65. }
    
66. 
    
67. ngx_create_chain_of_bufs(p,q);
    
68. ngx_chain_t *
    
69. ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs)
    
70. {
    
71.     u_char       *p;
    
72.     ngx_int_t     i;
    
73.     ngx_buf_t    *b;
    
74.     ngx_chain_t  *chain, *cl, **ll;
    
75. 
    
76.     p = ngx_palloc(pool, bufs->num * bufs->size);
    
77.     if (p == NULL) {
    
78.         return NULL;
    
79.     }
    
80. 
    
81.     ll = &chain;
    
82. 
    
83.     for (i = 0; i < bufs->num; i++) {
    
84. 
    
85.         b = ngx_calloc_buf(pool);
    
86.         if (b == NULL) {
    
87.             return NULL;
    
88.         }
    
89. 
    
90.         /*
    
91.          * set by ngx_calloc_buf():
    
92.          *
    
93.          *     b->file_pos = 0;
    
94.          *     b->file_last = 0;
    
95.          *     b->file = NULL;
    
96.          *     b->shadow = NULL;
    
97.          *     b->tag = 0;
    
98.          *     and flags
    
99.          *
    
100.          */
     
101. 
     
102.         b->pos = p;
     
103.         b->last = p;
     
104.         b->temporary = 1;
     
105. 
     
106.         b->start = p;
     
107.         p += bufs->size;
     
108.         b->end = p;
     
109. 
     
110.         cl = ngx_alloc_chain_link(pool);
     
111.         if (cl == NULL) {
     
112.             return NULL;
     
113.         }
     
114. 
     
115.         cl->buf = b;
     
116.         *ll = cl;
     
117.         ll = &cl->next;
     
118.     }
     
119. 
     
120.     *ll = NULL;
     
121. 
     
122.     return chain;
     
123. }
     
124. 
     
125. 
     
126. ngx_int_t
     
127. ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, ngx_chain_t *in)
     
128. {
     
129.     ngx_chain_t  *cl, **ll;
     
130. 
     
131.     ll = chain;
     
132. 
     
133.     for (cl = *chain; cl; cl = cl->next) {
     
134.         ll = &cl->next;
     
135.     }
     
136. 
     
137.     while (in) {
     
138.         cl = ngx_alloc_chain_link(pool);
     
139.         if (cl == NULL) {
     
140.             return NGX_ERROR;
     
141.         }
     
142. 
     
143.         cl->buf = in->buf;
     
144.         *ll = cl;
     
145.         ll = &cl->next;
     
146.         in = in->next;
     
147.     }
     
148. 
     
149.     *ll = NULL;
     
150. 
     
151.     return NGX_OK;
     
152. }
     
153. 
     
154. 
     
155. ngx_chain_t *
     
156. ngx_chain_get_free_buf(ngx_pool_t *p, ngx_chain_t **free)
     
157. {
     
158.     ngx_chain_t  *cl;
     
159. 
     
160.     if (*free) {
     
161.         cl = *free;
     
162.         *free = cl->next;
     
163.         cl->next = NULL;
     
164.         return cl;
     
165.     }
     
166. 
     
167.     cl = ngx_alloc_chain_link(p);
     
168.     if (cl == NULL) {
     
169.         return NULL;
     
170.     }
     
171. 
     
172.     cl->buf = ngx_calloc_buf(p);
     
173.     if (cl->buf == NULL) {
     
174.         return NULL;
     
175.     }
     
176. 
     
177.     cl->next = NULL;
     
178. 
     
179.     return cl;
     
180. }
     
181. 
     
182. 
     
183. void
     
184. ngx_chain_update_chains(ngx_pool_t *p, ngx_chain_t **free, ngx_chain_t **busy,
     
185.     ngx_chain_t **out, ngx_buf_tag_t tag)
     
186. {
     
187.     ngx_chain_t  *cl;
     
188. 
     
189.     if (*busy == NULL) {
     
190.         *busy = *out;
     
191. 
     
192.     } else {
     
193.         for (cl = *busy; cl->next; cl = cl->next) { /* void */ }
     
194. 
     
195.         cl->next = *out;
     
196.     }
     
197. 
     
198.     *out = NULL;
     
199. 
     
200.     while (*busy) {
     
201.         cl = *busy;
     
202. 
     
203.         if (ngx_buf_size(cl->buf) != 0) {
     
204.             break;
     
205.         }
     
206. 
     
207.         if (cl->buf->tag != tag) {
     
208.             *busy = cl->next;
     
209.             ngx_free_chain(p, cl);
     
210.             continue;
     
211.         }
     
212. 
     
213.         cl->buf->pos = cl->buf->start;
     
214.         cl->buf->last = cl->buf->start;
     
215. 
     
216.         *busy = cl->next;
     
217.         cl->next = *free;
     
218.         *free = cl;
     
219.     }
     
220. }

复制代码