模块笔记{程序源代码分析模块}

        这个模块是预测程序执行时间的基础。要预测程序执行时间，需要了解两个方面的信息

         （1）程序信息：程序的复杂程度

        （2）运行环境信息：运行程序的系统当前的状况

 

        其中，程序信息在本设计中，用时间权值来估计。 参考文献资料，设计出一套不同操作占用的时钟数权重指标，并且在特定的网格计算环境中进行了测试和验证。下表中WT列表示权重系数，此值是各个操作占用的时钟数与“+”操作占用的时钟数的比值。

 

         关于程序代码分析，目前只是一个粗略的分析过程，得到的分析结果不是十分精确，主要的设计思想是：

        采用程序遍历的方法，统计程序代码中的各种指令数目，参照上表中的WT值，得到程序代码的总WT值，作为衡量该程序代码运算量的参数。程序中的分支部分参照参考文献的做法，其具体实现方案为：
      识别出表表中列出的操作代码以后，则将相应的累加器递加。这种情况适用于严格的顺序结构的代码。但是对于分支结构代码，如if{}else{}或switch{case 1,case 2,...,case n}，如果前提条件为假，一些分支代码则不会执行，在这种情况下，这些分支代码不应统计在内。不幸的是，只有在运行时才能确定分支条件到底是真还是假，而且条件的真假也可能随着程序的执行而发生变化。我们用概率来处理这种情况，对于if{}else{}语句，每个分支被执行的概率为1/2,switch{case l , case 2,..., case n}语句中每个分支的执行概率为1/n。现在考虑循环语句，情况变得较为复杂一些。如果编译时能够决定迭代的总次数m，则循环体中的每条语句均被计数m次，但是对于while{}来说，我们无法得知其何时才会终结，也就无从知晓其迭代次数，此时就要借助于经验了，我们取其迭代次数为1或100。从算法的执行效果来看，确实达到了判定程序密集类型的目标。

        这样，由于充分考虑了循环结构中的所有运算量，因此得到的参数里已经包含了该程序时间复杂度的信息，所以不需要再单独计算代码的时间复杂度。

 

 

      用C++编写一个分析C程序的算法，以下源代码在VISUAL STUDIO 2008中调试通过：

 

2. #include <stdio.h>
3. #include <ctype.h>
4. #include <string.h>
5. #include <conio.h>
6. #include <stdlib.h>
9. #define PRO_MAX_LEN 20480    //源程序最大长度
10. #define STR_MAX_LEN 300        //标识符最大长度
11. #define STB_MAX_LEN 10000    //单词表最大容量
12. #define BLOCK_MAX_NUM 1000   //最多块数
13. #define KEYWORD_LEN 32        //保留字个数
14. #define OP_LEN 51  //指令代码的个数
16. int 循环体默认计数 = 50;  //循环体 无法判断循环次数时，默认循环 “循环体默认计数” 次
19. int if块分支数(int if位置,int *if终点);
21. char proBuffer[PRO_MAX_LEN] = "";    //存储程序代码的全局缓冲区
22. char wordget[STR_MAX_LEN];            //标识符 或 常量
23. char wordTab[STB_MAX_LEN][STR_MAX_LEN];    //符号表
24. float  单词表长度=0;
26. char 块名表[BLOCK_MAX_NUM][STR_MAX_LEN],顺序块名表[BLOCK_MAX_NUM][STR_MAX_LEN];
27. int 块开始位置[BLOCK_MAX_NUM],块结束位置[BLOCK_MAX_NUM],块表长度=0,顺序块开始位置[BLOCK_MAX_NUM],顺序块结束位置[BLOCK_MAX_NUM];
28. float 块权值[BLOCK_MAX_NUM];
29. bool 是否发现语法错误 = false;
31. char 关键字表[KEYWORD_LEN][10]={        //保留字表 C语言一共有32个保留字[关键字]
32.         "auto"/*0*/,        "break"/*1*/,    "case"/*2*/,        "char"/*3*/,        "const"/*4*/,
33.         "continue"/*5*/,    "default"/*6*/,    "do"/*7*/,        "float"/*8*/,    "else"/*9*/,
34.         "enum"/*10*/,        "extern"/*11*/,    "float"/*12*/,    "for"/*13*/,        "goto"/*14*/,
35.         "if"/*15*/,        "int"/*16*/,        "long"/*17*/,        "register"/*18*/,    "return"/*19*/,
36.         "short"/*20*/,    "signed"/*21*/,    "sizeof"/*22*/,    "static"/*23*/,    "struct"/*24*/,
37.         "switch"/*25*/,    "typedef"/*26*/,    "union"/*27*/,    "unsigned"/*28*/,    "void"/*29*/,
38.         "volatile"/*30*/,    "while"/*31*/};
41. char 操作指令表[OP_LEN][10]={        //指令代码的个数
42.         "+",        "-",    "*",        "/",        "|",
43.         "!",    "^",    "<<",        ">",    ">=",
44.         "==",        "!=",    "++",    "--",        "&",
45.         ">>",        "<",        "<=",        "&&",    "||",
46.         "=",    "[",    ".",    "fopen",    "fclose",
47.         "fgets",    "fptf",    "scanf",    "fputs",    "fread",
48.         "fwrite",    "fscanf",    "printf", "+=" };
50. double 指令相对权值[OP_LEN]={0.01,0.01,0.08,0.26,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.07,0.08,8.67,2.98,1.59,4.02,28.91,1.73,2.33,2.86,3.48,36.88,0.01};
52. bool 是否输出详情 = false;
55. FILE *fin, *fout;
56. char ch;
57. float 指针;
58. int 单词表指针 = 0;
59. float 权值总数 = 0;
62. bool 是否为数字(char *str)
63. {
64.     int i=0;
65.     while(str[i]!='/0')
66.     {
67.         if(!isdigit(str[i]))
68.             return false;
69.         i++;
71.     }
72.     return true;
75. }
77. int 返回字串长度(char *str)
78. { 
79.   int i=0;
81.   while(str[i] != '/0') i++;
83.   return i;
85. }
88. int 字串变数字(char *str)
89. {
90.    int i=0,sum=0,temp,j=0,len;
91.    len = 返回字串长度(str);
93.    while( i < len )
94.    {
95.        temp=(int)str[i];
96.        temp-=48;
97.        for(j=i;j<len-1;j++)
98.        {
99.            temp *= 10;
100.        }
101.        
102.        sum += temp;
104.        i++;
106.    }
107.    
108.    return sum;
110. }
111. void 发现语法错误()
112. {
113.     是否发现语法错误 = true;
114.     if(是否输出详情)
115.     {
116.        printf("/n发现语法错误/n");
117.     }
118.     //exit(0);
119. }
122.  bool 读入程序()
123. {
124.     char c;
125.      if ((fin=fopen("Test.c","r")) == NULL)
126.     {
127.         if(是否输出详情)
128.         {
129.            printf("Cannot open infile/n");
130.         }
131.         return false;
132.     }
133.     int i = 0;
134.     while((c = fgetc(fin)) != EOF)
135.     {
136.         if(i >= PRO_MAX_LEN-1)
137.         {
138.             if(是否输出详情)
139.             {
140.                 printf("/n程序代码太长，无法处理/a");
141.             }
142.             return 0;
143.         }
144.         proBuffer[i++] = c;
145.     }
146.     fclose(fin);    //关闭文件
147.     proBuffer[i++] = '/0';
148.     return true;
150. }
152.  bool 读入程序1(char *source)
153. {
154.     char c;
155.     
156.     int i = 0;
157.     while((c = source[i]) != '/0')
158.     {
159.         
160.         proBuffer[i++] = c;
161.     }
162.     
163.     proBuffer[i++] = '/0';
164.     return true;
166. }
170.  char 获得字符(int point)
171. {
172.     char ch;
173.     if(point < PRO_MAX_LEN && proBuffer[point] != '/0')
174.     {//如果当前下标合法且当前字符为结束标记则取字符增游标
175.         ch = proBuffer[point];
176.         //if (ch == '/n')
177.         //    errorLine ++;
178.         return ch;
179.     }
180.     ch = '/0';
181.     return ch;
182. }
184.  char 获得非空字符(int *point)//读到文件末尾 返回'/0' 否则返回当前指针所指最近的一个非空字符
185. {
186.     char c;
187.     do
188.     {
189.         c=获得字符(*point);
190.         if(isspace(c))
191.         {
192.            *point+=1;
193.         }
194.         if(c=='/0')    //读到文件末尾
195.         {
196.             c = '/0';
197.             return c;
198.         }
199.     }while(isspace(c));    //直到获得一个非空白字符
200.     return c;
201. }
202. void 预处理()
203. {
204.     int lines=0;
205.     char tmp[PRO_MAX_LEN];    //先将处理结果保存到临时空间，这样虽然浪费空间但是节约
206.                             //时间
207.     int tmpp = 0;    //这个临时空间的末尾指针
208.     char flg;
209.     char flg1;
210.     char tmpc;
211.     int point = 0;
212.     //去掉注释
213.     //注释有两种 一种是C++风格的// 另一种是C风格的/**/
214.     
215.     do
216.     {
217.         flg = 获得字符(point);
218.         point++;
220.         if(flg == '/')
221.         {
222.             flg = 获得字符(point);
223.             point++;
225.             switch(flg)
226.             {
227.             case '/'://如果‘/’后面接一个‘/’ 就是注释
228.                 do
229.                 {
230.                     flg = 获得字符(point); 
231.                     point++;
232.                 }while(!(flg == '/n' || flg == '/0'));// || ch == '/0'));//注释一直到行尾或文件结束
233.                 if(flg == '/n')
234.                     point--;    //归还换行
235.                 break;
236.             case '*':
237.                 do
238.                 {
239.                     flg = 获得字符(point); //flg=前一个字符
240.                     point++;
241.                     tmpc = flg;
242.                     //为了保证出错处理程序能正确定位出错位置 保留注释中的换行
243.                     if(tmpc == '/n')
244.                         tmp[tmpp++] = tmpc;
245.                     flg1 = 获得字符(point);//flg1=后一个字符
246.                     
247.                 }while(flg != '/0' && !( tmpc == '*' && flg1 == '/'));
248.                 flg = 获得字符(point);
249.                 point++;
250.                 if (flg == '/0')
251.                 {
252.                     //ProcError(5);===========================================================================------------------
253.                     //"注释丢失'*/'"
254.                 }
255.                 break;
256.             default:
257.                 //不是任何一种注释
258.                 point--;
259.                 point--;
261.                 flg = 获得字符(point);
262.                 point++;
264.                 tmp[tmpp++] = flg;
267.                 flg = 获得字符(point);
268.                 point++;
269.                 tmp[tmpp++] = flg;
270.             }
271.         }
272.         else
273.         {
274.             tmp[tmpp++] = flg;
275.         }
276.     }while(flg != '/0');
277.     tmp[tmpp] = '/0';
278.     strcpy(proBuffer,tmp);
279. }
284. bool 获得单词(int *point)
285. {
288.     int  code, value;
289.     char judge;    //这里有个技巧 
290.     
291.     int  i = 0;    //辅助
293.     ch = 获得非空字符(point);//获取一个非空字符 赋值给ch
295.     if(ch == '/0') return false;//读到了文件尾，则退出
299.     if (isalpha(ch) || ch == '_')    
300.     {
301.         judge='L'; //如果ch是“字母”或者“下划线” judge 赋值为L （letter）
302.     }
303.     else if (isdigit(ch))
304.     {
305.         judge='D';              //如果ch是“数字”  judge 赋值为D (digit)
306.     }else
307.     {
308.         judge=ch;
309.     }
311.     switch(judge)
312.     {
313.     case 'L':    //ch 是字母时
314.         {
315.             *point+=1; 
316.             while(isalnum(ch) || ch == '_') //只要ch是字母、数字、下划线 则循环（）
317.              {    //标识符
318.                
319.               wordget[i++] = ch; //将ch放到wordget中去形成单词
320.              
321.               ch=获得字符(*point);
322.                  *point+=1;  
324.              }
325.             wordget[i] = '/0';//成字符串
326.             *point-=1;    //回退一个字符
327.             /*
328.             code = Reserve(wordget);//对wordget字符串查找保留字表 若是一个保留字-返回其编码 否则返回0
329.             if(code == 0)//wordget这个单词不是一个保留字
330.             {
331.                value = InsertId(wordget);//将str串以标识符插入符号表，并返回符号表指针（如果str在符号表中存在 则返回存在的指针）
332.                pDu->kind  = ID;         //这个单词的类型为“标识符” ID 33
333.                pDu->value = value;      //其值为 在符号表中的指针位置
334.             }
335.             else//wordget这个单词是一个保留字
336.             {
337.                pDu->kind = code;       //类型为保留字在保留字表中的位置
338.                pDu->value = -1;         //其值为-1
339.                if(0 == strcmp("for", wordget))
340.                {
341.                    //printf("dddddff:%d--%d",forstart(point),point);
342.                    printf("发现一个for循环，/"(/"开始位置%d，/"{/"位置：%d，/"}/"位置：%d：/n",point,forstart(point),forblock(forstart(point)));
343.                    getBlocksoWT(forstart(point),forblock(forstart(point)),pDu,fin, fout);
344.                }
346.             
347.             }
348.         
349.             updatesoWT(wordget);
350.         */
351.             return true;
353.         }
354.     case 'D':  //ch是数字时
355.         *point+=1; 
356.         while(isdigit(ch))//只要下一个字符是数字 则和这个数字连成一个单词
357.         {
358.             wordget[i++] = ch;
359.             ch=获得字符(*point);
360.              *point+=1;
361.         }
362.         wordget[i] = '/0';//成字串
363.         *point-=1;
364.         /*
365.         value = InsertConst(wordget);//将str串以常数插入常量表，并返回常数表指针（如果str在常量表中存在 则返回存在的指针）
366.         pDu->kind = CONST; //类型为“常量” 34
367.         pDu->value= value; //其值为wordget在常量表中的指针位置
368.         */
369.         return true;
370. //以下为ch为一下符号的情况(　)　[　]　.　,　!  !=　~　sizeof　<　<<　<=　>　>>　>=　=　==　　&　&&　&=　|　||　|=　?:　+　++　+=
371. //　-　->　--　-=　*　*=　/　/=　%　%=　>>=　<<=　^　^=
372.     case '"': //ch是"时 接下来的应该是个字符串
373.         //字符串常量
374.         do
375.         {
376.             wordget[i++] = ch;
377.             *point+=1;
378.             ch=获得字符(*point);
379.             
380.         }while(ch != '"' && ch != '/0');// 将“”中的字符串 放入到wordget中去
381.         wordget[i++] = ch;    
382.         wordget[i] = '/0';//变成字串
383.         *point+=1;
384.         /*
385.         if(ch == '/0')
386.         {
387.             printf("%s",wordget);
388.             ProcError(3);         //不正确的字符串表达
389.             pDu->kind = ERROR;    //类型0 
390.             pDu->value = 0;       //值 0
391.         }
392.         else
393.         {
394.             value = InsertConst(wordget);  //将wordget串以常数插入常量表，并返回常数表指针
395.             pDu->kind = CONST;             //类型 常数
396.             pDu->value = value;            //值  在常数表中的位置
397.         }
398.         */
399.         return true;
400.         //字符常量
401.     case '/''://ch是'时 接下来的应该是个字符常量
402.         wordget[i++] = ch;    // '
403.         ch=获得字符(++*point);
404.         
405.         wordget[i++] = ch;
407.         if(ch == '//')    // '/n'
408.         {//如果是转义字符则要多接收一个字符
409.             ch=获得字符(++*point);         // ch = '
410.             wordget[i++] = ch;
411.         }
412.         ch=获得字符(++*point); 
414.         wordget[i++] = ch;
415.         wordget[i] = '/0';//编程字串 '/n'/0
416.         *point+=1;
418.         /*
419.         if(ch != '/'')//'号不配对 则不对
420.         {//'/b'
421.             printf("%s",wordget);
422.             ProcError(2);      //非法的字符
423.             pDu->kind = ERROR; 
424.             pDu->value = 0;
425.         }
426.         else
427.         {
428.             value = InsertConst(wordget); //将wordget串以常数插入常量表，并返回常数表指针
429.             pDu->kind = CONST;
430.             pDu->value = value;
431.         }*/
432.         return true;
433.     case '(':
434.     case ')':
435.     case '[':
436.     case ']':
437.     case '.':
438.     case ',':
439.     case '~':
440.     case '?':
441.     case ':':
442.     case ';':
443.     case '{':
444.     case '}':
445.     case '#':
446.         wordget[i++] = ch;    
447.         wordget[i] = '/0';
448.         *point+=1;
449.         /*
450.         pDu->kind = DIVIDE; //界符
451.         pDu->value = -1;    //界符的时候 -1
452.         */
453.         return true;
454.     case '!':
455.         //!=
456.         wordget[i++] = ch;
457.         ch=获得字符(++*point); 
458.         if (ch=='=') wordget[i++] = ch;
459.         else *point-=1;
460.         wordget[i]='/0';
461.         
462.         break;
463.     case '<':
464.         // << <=
465.         wordget[i++] = ch;
466.         ch=获得字符(++*point); 
467.         if (ch == '<' || ch == '=') wordget[i++] = ch;
468.         else *point-=1;
469.         wordget[i]='/0';
470.         
471.         break;
472.     case '>':
473.         // >> >=
474.         wordget[i++] = ch;
475.          ch=获得字符(++*point); 
476.         if (ch == '>' || ch == '=') wordget[i++] = ch;
477.         else *point-=1;
478.         wordget[i]='/0';
479.         
480.         break;
481.     case '=':
482.         // ==
483.         wordget[i++] = ch;
484.         ch=获得字符(++*point); 
485.         if (ch == '=') wordget[i++] = ch;
486.         else *point-=1;
487.         wordget[i]='/0';
488.         
489.         break;
490.     case '&':
491.         // && &=
492.         wordget[i++] = ch;
493.        ch=获得字符(++*point); 
494.         //if (ch == '&' || ch == '=') wordget[i++] = ch;
495.         if (ch !=' ') wordget[i++] = ch;
496.         else *point-=1;
497.         wordget[i]='/0';
498.         
499.         break;
500.     case '|':
501.         // || |=
502.         wordget[i++] = ch;
503.         ch=获得字符(++*point); 
504.         if (ch == '|' || ch == '=') wordget[i++] = ch;
505.         else *point-=1;
506.         wordget[i]='/0';
507.         
508.         break;
509.     case '+':
510.         // ++ +=
511.         wordget[i++] = ch;
512.         
513.         ch=获得字符(++(*point)); 
514.         if (ch == '+' || ch == '=') wordget[i++] = ch;
515.         else *point-=1;
516.         wordget[i]='/0';
517.         
518.         break;
519.     case '-':
520.         // -- -= ->
521.         wordget[i++] = ch;
522.         ch=获得字符(++*point); 
523.         if (ch == '-' || ch == '=' || ch == '>') wordget[i++] = ch;
524.         else *point-=1;
525.         wordget[i]='/0';
526.         
527.         break;
528.     case '*':
529.         // ** *=
530.         wordget[i++] = ch;
531.         ch=获得字符(++*point); 
532.         if (ch == '*' || ch == '=') wordget[i++] = ch;
533.         else *point-=1;
534.         wordget[i]='/0';
535.         
536.         break;
537.     case '/':
538.         // /=
539.         wordget[i++] = ch;
540.         ch=获得字符(++*point); 
541.         if (ch == '=') wordget[i++] = ch;
542.         else *point-=1;
543.         wordget[i]='/0';
544.         
545.         break;
546.     case '%':
547.         // %=
548.         wordget[i++] = ch;
549.         ch=获得字符(++*point); 
550.         if (ch == '=') wordget[i++] = ch;
551.         else *point-=1;
552.         wordget[i]='/0';
553.         
554.         break;
555.     case '^':
556.         // ^=
557.         wordget[i++] = ch;
558.         ch=获得字符(++*point); 
559.         if (ch == '=') wordget[i++] = ch;
560.         else *point-=1;
561.         wordget[i]='/0';
562.         
563.         break;
564.     case '/0':
565.         return false;
566.     default:
567.         //ProcError(1);
568.         return false;
569.     }
570.     //updatesoWT(wordget);
571.     //pDu->kind = OPERAT;
572.     *point+=1;
573.     return true;
574. }
576. void 寻找程序块名(int 开始左括号位置)
577. {
580. }
582. int 返回右括号配对(int 右括号位置)
583. {
584.      int flag = 0;//表示开始默认搜索(
585.      int i = 右括号位置-1;
586.      while(i > 0)
587.      {
588.      
589.          if(0 == strcmp(")", wordTab[i])&&flag>=0)
590.                {
591.                    
592.                    flag++;//表示开始搜索这个{匹配的}
594.                }
595.          
597.          else if(0 == strcmp("(", wordTab[i])&&flag>=1)
598.          {
599.              flag--;
600.          }
602.          else if(0 == strcmp("(", wordTab[i])&&flag==0)
603.          {
604.              
605.              return i;
606.          }
607.          i--;
609.      }
611.     return -1;
612. }
614. int 返回左括号配对(int 左括号位置)
615. {
616.      int flag = 0;//表示开始默认搜索)
617.      int i = 左括号位置+1;
618.      while(i < 单词表长度)
619.      {
620.      
621.          if(0 == strcmp("(", wordTab[i])&&flag>=0)
622.                {
623.                    
624.                    flag++;//表示开始搜索这个{匹配的}
626.                }
627.          
629.          else if(0 == strcmp(")", wordTab[i])&&flag>=1)
630.          {
631.              flag--;
632.          }
634.          else if(0 == strcmp(")", wordTab[i])&&flag==0)
635.          {
636.              
637.              return i;
638.          }
639.          i++;
641.      }
643.     return -1;
644. }
646. int 返回左大括号配对(int 左大括号位置)
647. {
648.       int flag = 0;//表示开始默认搜索}
649.      int i = 左大括号位置+1;
650.      while(i < 单词表长度)
651.      {
652.      
653.          if(0 == strcmp("{", wordTab[i])&&flag>=0)
654.                {
655.                    
656.                    flag++;//表示开始搜索这个{匹配的}
658.                }
659.          
661.          else if(0 == strcmp("}", wordTab[i])&&flag>=1)
662.          {
663.              flag--;
664.          }
666.          else if(0 == strcmp("}", wordTab[i])&&flag==0)
667.          {
668.              
669.              return i;
670.              
671.          }
672.          i++;
673.      }
674.      return -1;
675. }
678. void 分割程序()
679. {
680.     int flag = 0;//表示开始默认搜索{
681.     int i = 0;
682.      while(i<单词表长度)
683.      {
684.      
685.          if(0 == strcmp("{", wordTab[i])&&flag==0)//发现一级{
686.                {
687.                    if(0 == strcmp(")", wordTab[i-1]))//只有{前紧跟着（）的才是一个块，块一般是指函数
688.                    {
690.                         int ff = 返回右括号配对(i-1)-1;
691.                   
692.                          strcpy(块名表[块表长度], wordTab[ff]);
693.                          块开始位置[块表长度]=i;
694.                          块结束位置[块表长度]=返回左大括号配对(i);
698.                         //printf("发现一个块，块名字：%s，块开始位置：%d，结束位置：%d",wordTab[ff],i,返回左大括号配对(i));
699.                         if(是否输出详情)
700.                         {
701.                             printf("/n发现一个块，块名字：%s，块开始位置：%d，结束位置：%d",块名表[块表长度],块开始位置[块表长度],块结束位置[块表长度]);
702.                         }
704.                         块表长度++;
705.                         flag++;//表示开始搜索这个{匹配的}
706.                    }
708.                }
711.          if(0 == strcmp("{", wordTab[i])&&flag>0)//发现非一级{
712.          {
713.              flag++;
715.          }
718.          if(0 == strcmp("}", wordTab[i])&&flag>1)
719.          {
720.              flag--;
721.          }
724.          if(0 == strcmp("}", wordTab[i])&&flag==1)
725.          {
726.              
727.              flag--;
728.          }
729.          i++;
731.      }
733.     
734. }
736. void 插入单词表(char *str)
737. {
738.     
739.    
740.     strcpy(wordTab[单词表指针++], str);
741.     //return (pointCTB-1);
742. }
743. void 建立单词表()
744. {
745.     int 指针 = 0;
746.      while(获得单词(&指针))
747.      {
749.         插入单词表(wordget);
750.         单词表长度++;
751.      }
752. }
755. int 查关键字表(char *str)
756. {
757.     int i;
758.     for(i=0; i<KEYWORD_LEN; ++i)    //从保留字表中查找str串
759.     {
760.         if(0 == strcmp(关键字表[i], str))
761.             return i;    
762.     }
763.     return -1;
764. }
767. int 查函数名表(char *str)
768. {
769.     int i;
770.     for(i = 0; i < 块表长度; ++i)    //从函数名表中查找str串
771.     {
772.         if(0 == strcmp(顺序块名表[i], str))
773.             return i;    
774.     }
775.     return -1;
777. }
779. float 查指令表返回权值(char *str)
780. {
781.     int i;
782.     int 位置 = -1;
784.     for(i=0; i<OP_LEN; ++i)    //从保留字表中查找str串
785.     {
786.         if(0 == strcmp(操作指令表[i], str))
787.             位置 = i;    
788.     }
790.     if(位置 == -1)
791.     {
792.          return -1;
793.     }else
794.     {
795.         return 指令相对权值[位置];
797.     }
798. }
800. int 分析for起点(int for位置)
801. {
802.     int 分析点 = for位置+1;
804.     if(0 == strcmp("(", wordTab[分析点]))
805.     {
806.         分析点=返回左括号配对(分析点)+1;
807.     }else
808.     {
809.         发现语法错误();
810.         return -1;
811.     }
812.     return 分析点;
814. }
816. int 分析for终点(int for位置)
817. {
818.     int 分析点 = 分析for起点(for位置);
819.     
821.     if(0 == strcmp("{", wordTab[分析点]))//for块 以{}出现
822.     {
823.          return 返回左大括号配对(分析点);
824.     }
825.     else if(0 == strcmp("if", wordTab[分析点]))
826.     {
827.         int if的终点;
828.         if块分支数(分析点,if的终点);
829.         return if的终点;
831.     }
832.     else if(0 == strcmp("for", wordTab[分析点]))
833.     {
834.         return 分析for终点(分析点);
836.     }
837.     else
838.     {//for后面没有{}块 只跟一条语句
839.         while(0 != strcmp(";", wordTab[分析点]))
840.         {
841.            分析点++;
842.         }
844.         return 分析点;
846.     }
848. }
850. int 分析for条件点(int for位置)
851. {
852.     int 分析点 = for位置 + 1;
853.     
855.     while(0 != strcmp(";", wordTab[分析点]))
856.     {//找到第一个";"
857.         
858.       分析点++;
859.     }
860.     分析点++;
861.     while(0 != strcmp(";", wordTab[分析点]))
862.     {//找到第二个";"
863.         
864.       分析点++;
865.     }
869.     return 分析点;
872. }
874. int 分析for循环次数(int for位置)
875. {
876.      int 分析点 = for位置+1;
877.      int 开始条件,结束条件,次数;
879.     if(0 == strcmp("(", wordTab[分析点]))
880.     {
881.         /**
882.         for(i=0;i<n;i++) 只能分析一下这个情况下的循环次数，并且只有n是一个常数的时候才分析
883.         */
884.         if(  (0 == strcmp(wordTab[分析点+1], wordTab[分析点+5]))  &&  (0 == strcmp(wordTab[分析点+5], wordTab[分析点+9]))  &&  是否为数字(wordTab[分析点+3])  &&  是否为数字(wordTab[分析点+7])  &&  ((0 == strcmp("++", wordTab[分析点+10]))||(0 == strcmp("--", wordTab[分析点+10]))))
885.         {   
887.              结束条件 = 字串变数字(wordTab[分析点+7]);
888.              开始条件 = 字串变数字(wordTab[分析点+3]);
889.              if(0 == strcmp("++", wordTab[分析点+10]))
890.              {
891.                   次数 = 结束条件-开始条件;
892.              }else
893.              {
894.                   次数 = 开始条件-结束条件;
896.              }
898.              if(次数>0)
899.              return 次数;
900.              else
901.              return 0;//起始条件都不满足 则这个循环不开始
903.         }else//其他的情况不好分析，默认循环“循环体默认计数”次，这个参数应该是个可以调整的多次调整以得到最好的预测结果
904.         {
906.              return 循环体默认计数;
907.         }
908.         
909.         
912.     }else
913.     {
914.         发现语法错误();
915.         return -1;
916.     }
917.     
918. }
921. int 分析if起点(int if位置)
922. {
923.     int 分析点 = if位置+1;
925.     if(0 == strcmp("(", wordTab[分析点]))
926.     {
927.         分析点=返回左括号配对(分析点) + 1;
928.     }else
929.     {
930.         发现语法错误();
931.         return -1;
932.     }
933.     return 分析点;
935. }
937. int 块后面一个单词(int 块起点)
938. {
939.     int 分析点;
941.     分析点 = 块起点;//此时分析点在if条件括号后面一个单词
943.     if(0==strcmp("{",wordTab[分析点]))
944.     {//if语句后面有{}
945.         分析点=返回左大括号配对(分析点);
947.     }else
948.     {//if语句后面直接接一个语句的
949.         while(0 != strcmp(";", wordTab[分析点]))
950.         {
951.            分析点++;
952.         }//循环完后 分析点 指向;
953.         
955.     }
956.     return ++分析点;
961. }
963. int if块分支数(int if位置,int *if终点)
964. {
965.     int 分支 = 1;
966.     int 块结束下一位置 = 块后面一个单词(分析if起点(if位置));
967.     while(0==strcmp("else",wordTab[块结束下一位置]))
968.     {
969.         分支++;
970.         if(0 == strcmp("if",wordTab[块结束下一位置+1]))
971.         {
972.             块结束下一位置 = 块后面一个单词(分析if起点(块结束下一位置+1));
975.         }else
976.         {
977.             块结束下一位置 = 块后面一个单词(块结束下一位置+1);
979.             break;
981.         }
985.     }
986.     *if终点 = 块结束下一位置-1;
987.     if(分支 == 1) 分支 = 2;
988.     return 分支;
990. }
996. int 分析while起点(int while位置)
997. {
998.     int 分析点 = while位置 + 1;
1000.     if(0 == strcmp("(", wordTab[分析点]))
1001.     {
1002.         分析点 = 返回左括号配对(分析点)+1;
1003.     }else
1004.     {
1005.         发现语法错误();
1006.         return -1;
1007.     }
1009.     return 分析点;
1011. }
1013. int 分析while终点(int while位置)
1014. {
1015.     int 分析点 = 分析while起点(while位置);
1016.     
1018.     if(0 == strcmp("{", wordTab[分析点]))//for块 以{}出现
1019.     {
1020.          return 返回左大括号配对(分析点);
1021.     }
1022.     else
1023.     {//for后面没有{}块 只跟一条语句
1024.         while(0 != strcmp(";", wordTab[分析点]))
1025.         {
1026.            分析点++;
1027.         }
1029.         return 分析点;
1031.     }
1033. }
1035. int 分析switch起点(int switch位置)
1036. {
1037.     int 分析点 = switch位置 + 1;
1039.     if(0 == strcmp("(", wordTab[分析点]))
1040.     {
1041.         分析点 = 返回左括号配对(分析点)+1;
1042.     }else
1043.     {
1044.         发现语法错误();
1045.         return -1;
1046.     }
1048.     return 分析点;
1050. }
1051. int 分析switch终点(int switch位置)
1052. {
1054.     int 分析点 = 分析switch起点(switch位置);
1055.     
1057.     if(0 == strcmp("{", wordTab[分析点]))//for块 以{}出现
1058.     {
1059.          return 返回左大括号配对(分析点);
1060.     }
1061.     else
1062.     {
1063.         发现语法错误();
1065.         return -1;
1067.     }
1069. }
1070. int switch分支数(int switch起点,int switch终点)
1071. {
1072.     int 分析点 = switch起点;
1073.     int sum=0;
1075.     while(分析点 <= switch终点)
1076.     {
1077.        if(0 == strcmp("case", wordTab[分析点]))
1078.        {
1079.           sum++;
1080.        }
1081.        分析点++;
1082.     }
1083.     return sum;
1085. }
1086. float 顺序分析(int 起点,int 终点)
1087. {
1088.     float 该块权值 = 0.0;
1090.     int 当前分析点=起点;
1092.     while(当前分析点 < 终点)
1093.     {
1094.         switch(查关键字表(wordTab[当前分析点]))
1095.         {
1096.             case 13://for
1097.                 {
1098.                     int forend = 分析for终点(当前分析点);
1101.                     int forbegin = 分析for起点(当前分析点);
1103.                     if(forbegin != -1)
1104.                     {
1105.                     int div= 分析for条件点(当前分析点);
1106.                     int times = 分析for循环次数(当前分析点);
1107.                     int forblockWT = 顺序分析(div,forend);
1108.                     int forst = 顺序分析(当前分析点+1,div);
1110.                     该块权值 += forst;
1112.                     该块权值 += times * forblockWT;
1114.                     当前分析点 = forend;
1116.                     if(是否输出详情)
1117.                     {
1118.                         printf("/nfor语句的起点：%d 终点：%d 这个FOR语句的循环次数：%d，该for语句块的权值：%d，总权值 = 条件权值 + for语句块的权值 * 循环次数（%d = %d + %d * %d）",forbegin,forend,times,forblockWT,该块权值,forst,forblockWT,times);
1119.             
1120.                     }
1121.                         //该块权值 += 顺序分析(当前分析点,div)  + 分析for循环次数(当前分析点) * (顺序分析(div,forend));
1122.                     }
1123.                     else
1124.                     {
1125.                         当前分析点 = 单词表长度;
1127.                     }
1129.                     break;
1131.                 }
1132.             case 15://if
1133.                 {
1134.                     if(0 != strcmp("else",wordTab[当前分析点-1])){
1135.                         //如果当前IF是一个if块的第一个if，而不是分支中的 else if
1136.                     int if结束点 = 0 ;
1137.                     int if起点 = 分析if起点(当前分析点);
1138.                     int if分支数 = if块分支数(当前分析点,if结束点);
1140.                     
1141.                     if(if起点 != -1)
1142.                     {
1143.                     
1145.                         if(是否输出详情)
1146.                          {
1147.                              printf("/n发现一个if,该if开始位置：%d 分支数为%d,-----",if起点,if分支数);
1148.                              printf("/n该if块结束位置为：%d,",if结束点);
1149.                         }
1151.                          该块权值 += 顺序分析(if起点,if结束点)/if分支数;
1152.                     }
1153.                     else
1154.                     {
1155.                          当前分析点 = 单词表长度;
1157.                     }
1160.                     当前分析点 = if结束点;
1161.                     }
1162.                     break;
1163.                 }
1164.             case 31://while
1165.                 {
1166.                     
1167.                     int whilebegin = 分析while起点(当前分析点);
1169.                     if(whilebegin != -1)
1170.                     {
1172.                        int whileend = 分析while终点(当前分析点);
1174.                        if(是否输出详情)
1175.                        {
1176.                            printf("/nwhile语句的起点：%d 终点：%d ",whilebegin,whileend);
1177.                        }
1179.                     
1180.                        该块权值 += 循环体默认计数 * 顺序分析(whilebegin,whileend);
1181.             
1182.             
1183.                        当前分析点 = whileend;
1184.                     }
1185.                     else
1186.                     {
1187.                         当前分析点 = 单词表长度;
1188.                     }
1191.                     break;
1192.                 }
1194.             case 25://switch
1195.                 {   int switchbegin = 分析switch起点(当前分析点);
1199.                     int switchend = 分析switch终点(当前分析点);
1201.                     int fenzhi = switch分支数(switchbegin,switchend);
1202.                      
1203.                     if((switchbegin != -1) && (switchend != -1))
1204.                     {
1206.                         if(是否输出详情)
1207.                         {
1208.                             printf("/n发现一个switch,该switch开始位置：%d 分支数为%d,-----",switchbegin,fenzhi);
1209.                             printf("/n该if块结束位置为：%d,",switchend);
1210.                         }
1212.                         该块权值 += (顺序分析(switchbegin,switchend) / fenzhi);
1214.                         当前分析点 = switchend;
1215.                     }
1216.                     else
1217.                     {
1218.                         当前分析点 = 单词表长度;
1220.                     }
1224.                 }
1226.             case -1://不是一个关键字
1227.                 {
1228.                     int temp = 查函数名表(wordTab[当前分析点]);
1229.                     if(temp != -1)
1230.                     {//如果是一个函数，则用前面分析到的这个函数的权值 作为这个关键字的权值
1233.                         if(是否输出详情)
1234.                         {
1235.                             printf("/n发现一个函数，当前分析点：%d, 函数名：%s:权值： %f/n",当前分析点,wordTab[当前分析点],块权值[temp]);
1236.                         }
1238.                         该块权值 += 块权值[temp];
1240.                     }
1241.                     
1242.                     else if(查指令表返回权值(wordTab[当前分析点]) != -1)
1243.                     {
1244.                         if(是否输出详情)
1245.                         {
1246.                             printf("/n当前分析点：%d, 单词：%s:权值： %f=====%f/n",当前分析点,wordTab[当前分析点],查指令表返回权值(wordTab[当前分析点]),该块权值);
1247.                         }
1248.                         该块权值 += 查指令表返回权值(wordTab[当前分析点]);
1249.                     }
1251.                 
1252.                 
1253.                 }
1254.             default:break;
1255.         }
1258.         当前分析点++;
1259.     }
1260.     
1261.     return 该块权值;
1263. }
1265. int 按函数名查找函数表(char *str)//如果在函数表里 就返回在“块名表”里的位置
1266. {
1267.     int i;
1268.     for(i=0;i<块表长度;i++)
1269.     {
1270.         if(0 == strcmp(str,块名表[i]))
1271.         {
1272.             return i;
1273.         }
1274.     }
1275.     return -1;
1278. }
1279. void 块名表调序(int 新顺序,int 老位置)
1280. {
1281.     //顺序块名表[新顺序] = 块名表[老位置];
1282.     strcpy(顺序块名表[新顺序],块名表[老位置]);
1283.     
1284.     strcpy(块名表[老位置],"");
1286.     顺序块开始位置[新顺序] = 块开始位置[老位置];
1288.     顺序块结束位置[新顺序] = 块结束位置[老位置];
1292.     
1293. }
1295. void 按函数出现顺序排序()
1296. {
1297.     int 当前分析点 = 0;
1298.     int i=0,j=0;
1300.     while(当前分析点 < 单词表长度)
1301.     {
1302.         i = 按函数名查找函数表(wordTab[当前分析点]);
1303.             if(i != -1)
1304.             {
1305.                 块名表调序(j,i);
1306.                 j++;
1309.             }
1310.         当前分析点++;
1314.     }
1315.     
1316.     
1317. }
1319. float getSourceWT(int times,bool isprint)
1320. {
1321.     循环体默认计数 = times;
1322.     是否输出详情 = isprint;
1323.      int i=0;
1324.     char c;
1326.    
1327.     读入程序();
1328.     
1329.     //读入程序1(source);
1330.     //char* csStr = env->GetStringUTFChars(str,NULL);
1331.     //char* csStr = GetStringUTFChars(
1333.     预处理();
1334.    
1336.     建立单词表();
1338.     分割程序();
1340.     按函数出现顺序排序();
1341.     
1342.     for(int i=0;i<块表长度;i++)
1343.     {
1344.         块权值[i] = 顺序分析(顺序块开始位置[i],顺序块结束位置[i]);
1345.         
1346.         
1347.         
1349.     }
1350.     if(是否输出详情)
1351.     {
1352.         for(int i=0;i<块表长度;i++)
1353.         {
1354.             printf("/n块信息：/n%s:%d---%d/n",顺序块名表[i],顺序块开始位置[i],顺序块结束位置[i]);
1355.             printf("权值：%f",块权值[i]);
1356.         }
1357.     }
1358.     if(是否发现语法错误)
1359.     {
1360.         return -1;
1362.     }
1363.     else
1364.     {
1366.         for(int i=0;i<块表长度;i++)
1367.         { 
1368.             if(0==strcmp("main",顺序块名表[i]))
1369.             {
1370.                return 块权值[i];
1371.             }
1372.         }
1373.         //没有main块 ，也算是语法错误
1374.         return -1;
1376.         
1377.     }
1378.     
1380. }
1384. int main()
1385. {
1387.     
1389.     
1390.      
1393.     printf("权值---->：%f",getSourceWT(90,false));
1394.     
1395.     
1397.     printf("/n写入完毕/n按任意键继续/n");    getch();
1399.     return 0;
1400. }

        getSourceWT(int times,bool isprint)函数中的两个参数：

        第一个提供外部修改“默认循环次数”的接口，在以后的预测过程中调整这个数值，以与期望的预测时间更接近

        第二个参数方便调试用，如果要查看具体的分析过程，可以设置这个值为真，则在命令管理器中会输出分析过程。

        下面是JNI改造：

 

        步骤一：在“C:/c/com/swjtu/sourcemanage”里建立文件SourceScan.java，文件代码如下：

 

1. package com.swjtu.sourcemanage;
3. public class SourceScan {
4.     public static native double getSourceWT(int times,boolean isprint,String source);   
5.     static  
6.     {   
7.     System.loadLibrary("SourceScan");   
8.     }   
11. }

步骤二：点击“开始”——>“运行”——>cmd 敲命令 Microsoft Windows XP [版本 5.1.2600]
(C) 版权所有 1985-2001 Microsoft Corp.
C:/Documents and Settings/Administrator>cd c:/c
C:/c>cd com/swjtu/sourcemanage
C:/c/com/swjtu/sourcemanage>javac SourceScan .java
C:/c/com/swjtu/sourcemanage>cd c:/c
C:/c>javah com.swjtu.sourcemanage.SourceScan 
C:/c>
注：javah命令在c:/c文件夹下生成了com_swjtu_sourcemanage_SourceScan.h头文件，文件代码如下：

1. /* DO NOT EDIT THIS FILE - it is machine generated */
2. #include <jni.h>
3. /* Header for class com_swjtu_sourcemanage_SourceScan */
5. #ifndef _Included_com_swjtu_sourcemanage_SourceScan
6. #define _Included_com_swjtu_sourcemanage_SourceScan
7. #ifdef __cplusplus
8. extern "C" {
9. #endif
10. /*
11.  * Class:     com_swjtu_sourcemanage_SourceScan
12.  * Method:    getSourceWT
13.  * Signature: (IZLjava/lang/String;)D
14.  */
15. JNIEXPORT jdouble JNICALL Java_com_swjtu_sourcemanage_SourceScan_getSourceWT
16.   (JNIEnv *, jclass, jint, jboolean, jstring);
18. #ifdef __cplusplus
19. }
20. #endif
21. #endif

 

步骤三：在文件夹“C:/c”建立com_swjtu_sourcemanage_SourceScan.cpp文件，这个文件是上面的经过一些小修改而成的，为可以被JAVA调用的DLL源代码，文件内容如下：

 

1. #include "com_swjtu_sourcemanage_SourceScan.h"
3. #include <stdio.h>
4. #include <ctype.h>
5. #include <string.h>
6. #include <conio.h>
7. #include <stdlib.h>
10. #define PRO_MAX_LEN 20480    //源程序最大长度
11. #define STR_MAX_LEN 300        //标识符最大长度
12. #define STB_MAX_LEN 10000    //单词表最大容量
13. #define BLOCK_MAX_NUM 1000   //最多块数
14. #define KEYWORD_LEN 32        //保留字个数
15. #define OP_LEN 51  //指令代码的个数
17. int 循环体默认计数 = 50;  //循环体 无法判断循环次数时，默认循环 “循环体默认计数” 次
19. int if块分支数(int if位置,int *if终点);
21. char proBuffer[PRO_MAX_LEN] = "";    //存储程序代码的全局缓冲区
22. char wordget[STR_MAX_LEN];            //标识符 或 常量
23. char wordTab[STB_MAX_LEN][STR_MAX_LEN];    //符号表
24. float  单词表长度=0;
26. char 块名表[BLOCK_MAX_NUM][STR_MAX_LEN],顺序块名表[BLOCK_MAX_NUM][STR_MAX_LEN];
27. int 块开始位置[BLOCK_MAX_NUM],块结束位置[BLOCK_MAX_NUM],块表长度=0,顺序块开始位置[BLOCK_MAX_NUM],顺序块结束位置[BLOCK_MAX_NUM];
28. float 块权值[BLOCK_MAX_NUM];
29. bool 是否发现语法错误 = false;
31. char 关键字表[KEYWORD_LEN][10]={        //保留字表 C语言一共有32个保留字[关键字]
32.         "auto"/*0*/,        "break"/*1*/,    "case"/*2*/,        "char"/*3*/,        "const"/*4*/,
33.         "continue"/*5*/,    "default"/*6*/,    "do"/*7*/,        "float"/*8*/,    "else"/*9*/,
34.         "enum"/*10*/,        "extern"/*11*/,    "float"/*12*/,    "for"/*13*/,        "goto"/*14*/,
35.         "if"/*15*/,        "int"/*16*/,        "long"/*17*/,        "register"/*18*/,    "return"/*19*/,
36.         "short"/*20*/,    "signed"/*21*/,    "sizeof"/*22*/,    "static"/*23*/,    "struct"/*24*/,
37.         "switch"/*25*/,    "typedef"/*26*/,    "union"/*27*/,    "unsigned"/*28*/,    "void"/*29*/,
38.         "volatile"/*30*/,    "while"/*31*/};
41. char 操作指令表[OP_LEN][10]={        //指令代码的个数
42.         "+",        "-",    "*",        "/",        "|",
43.         "!",    "^",    "<<",        ">",    ">=",
44.         "==",        "!=",    "++",    "--",        "&",
45.         ">>",        "<",        "<=",        "&&",    "||",
46.         "=",    "[",    ".",    "fopen",    "fclose",
47.         "fgets",    "fptf",    "scanf",    "fputs",    "fread",
48.         "fwrite",    "fscanf",    "printf", "+=" };
50. double 指令相对权值[OP_LEN]={0.01,0.01,0.08,0.26,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.07,0.08,8.67,2.98,1.59,4.02,28.91,1.73,2.33,2.86,3.48,36.88,0.01};
52. bool 是否输出详情 = false;
55. FILE *fin, *fout;
56. char ch;
57. float 指针;
58. int 单词表指针 = 0;
59. float 权值总数 = 0;
62. bool 是否为数字(char *str)
63. {
64.     int i=0;
65.     while(str[i]!='/0')
66.     {
67.         if(!isdigit(str[i]))
68.             return false;
69.         i++;
71.     }
72.     return true;
75. }
77. int 返回字串长度(char *str)
78. { 
79.   int i=0;
81.   while(str[i] != '/0') i++;
83.   return i;
85. }
88. int 字串变数字(char *str)
89. {
90.    int i=0,sum=0,temp,j=0,len;
91.    len = 返回字串长度(str);
93.    while( i < len )
94.    {
95.        temp=(int)str[i];
96.        temp-=48;
97.        for(j=i;j<len-1;j++)
98.        {
99.            temp *= 10;
100.        }
101.        
102.        sum += temp;
104.        i++;
106.    }
107.    
108.    return sum;
110. }
111. void 发现语法错误()
112. {
113.     是否发现语法错误 = true;
114.     if(是否输出详情)
115.     {
116.        printf("/n发现语法错误/n");
117.     }
118.     //exit(0);
119. }
122.  bool 读入程序()
123. {
124.     char c;
125.      if ((fin=fopen("Test.c","r")) == NULL)
126.     {
127.         if(是否输出详情)
128.         {
129.            printf("Cannot open infile/n");
130.         }
131.         return false;
132.     }
133.     int i = 0;
134.     while((c = fgetc(fin)) != EOF)
135.     {
136.         if(i >= PRO_MAX_LEN-1)
137.         {
138.             if(是否输出详情)
139.             {
140.                 printf("/n程序代码太长，无法处理/a");
141.             }
142.             return 0;
143.         }
144.         proBuffer[i++] = c;
145.     }
146.     fclose(fin);    //关闭文件
147.     proBuffer[i++] = '/0';
148.     return true;
150. }
152.  bool 读入程序1(const char *source)
153. {
154.     char c;
155.     
156.     int i = 0;
157.     while((c = source[i]) != '/0')
158.     {
159.         
160.         proBuffer[i++] = c;
161.     }
162.     
163.     proBuffer[i++] = '/0';
164.     return true;
166. }
170.  char 获得字符(int point)
171. {
172.     char ch;
173.     if(point < PRO_MAX_LEN && proBuffer[point] != '/0')
174.     {//如果当前下标合法且当前字符为结束标记则取字符增游标
175.         ch = proBuffer[point];
176.         //if (ch == '/n')
177.         //    errorLine ++;
178.         return ch;
179.     }
180.     ch = '/0';
181.     return ch;
182. }
184.  char 获得非空字符(int *point)//读到文件末尾 返回'/0' 否则返回当前指针所指最近的一个非空字符
185. {
186.     char c;
187.     do
188.     {
189.         c=获得字符(*point);
190.         if(isspace(c))
191.         {
192.            *point+=1;
193.         }
194.         if(c=='/0')    //读到文件末尾
195.         {
196.             c = '/0';
197.             return c;
198.         }
199.     }while(isspace(c));    //直到获得一个非空白字符
200.     return c;
201. }
202. void 预处理()
203. {
204.     int lines=0;
205.     char tmp[PRO_MAX_LEN];    //先将处理结果保存到临时空间，这样虽然浪费空间但是节约
206.                             //时间
207.     int tmpp = 0;    //这个临时空间的末尾指针
208.     char flg;
209.     char flg1;
210.     char tmpc;
211.     int point = 0;
212.     //去掉注释
213.     //注释有两种 一种是C++风格的// 另一种是C风格的/**/
214.     
215.     do
216.     {
217.         flg = 获得字符(point);
218.         point++;
220.         if(flg == '/')
221.         {
222.             flg = 获得字符(point);
223.             point++;
225.             switch(flg)
226.             {
227.             case '/'://如果‘/’后面接一个‘/’ 就是注释
228.                 do
229.                 {
230.                     flg = 获得字符(point); 
231.                     point++;
232.                 }while(!(flg == '/n' || flg == '/0'));// || ch == '/0'));//注释一直到行尾或文件结束
233.                 if(flg == '/n')
234.                     point--;    //归还换行
235.                 break;
236.             case '*':
237.                 do
238.                 {
239.                     flg = 获得字符(point); //flg=前一个字符
240.                     point++;
241.                     tmpc = flg;
242.                     //为了保证出错处理程序能正确定位出错位置 保留注释中的换行
243.                     if(tmpc == '/n')
244.                         tmp[tmpp++] = tmpc;
245.                     flg1 = 获得字符(point);//flg1=后一个字符
246.                     
247.                 }while(flg != '/0' && !( tmpc == '*' && flg1 == '/'));
248.                 flg = 获得字符(point);
249.                 point++;
250.                 if (flg == '/0')
251.                 {
252.                     //ProcError(5);===========================================================================------------------
253.                     //"注释丢失'*/'"
254.                 }
255.                 break;
256.             default:
257.                 //不是任何一种注释
258.                 point--;
259.                 point--;
261.                 flg = 获得字符(point);
262.                 point++;
264.                 tmp[tmpp++] = flg;
267.                 flg = 获得字符(point);
268.                 point++;
269.                 tmp[tmpp++] = flg;
270.             }
271.         }
272.         else
273.         {
274.             tmp[tmpp++] = flg;
275.         }
276.     }while(flg != '/0');
277.     tmp[tmpp] = '/0';
278.     strcpy(proBuffer,tmp);
279. }
284. bool 获得单词(int *point)
285. {
288.     int  code, value;
289.     char judge;    //这里有个技巧 
290.     
291.     int  i = 0;    //辅助
293.     ch = 获得非空字符(point);//获取一个非空字符 赋值给ch
295.     if(ch == '/0') return false;//读到了文件尾，则退出
299.     if (isalpha(ch) || ch == '_')    
300.     {
301.         judge='L'; //如果ch是“字母”或者“下划线” judge 赋值为L （letter）
302.     }
303.     else if (isdigit(ch))
304.     {
305.         judge='D';              //如果ch是“数字”  judge 赋值为D (digit)
306.     }else
307.     {
308.         judge=ch;
309.     }
311.     switch(judge)
312.     {
313.     case 'L':    //ch 是字母时
314.         {
315.             *point+=1; 
316.             while(isalnum(ch) || ch == '_') //只要ch是字母、数字、下划线 则循环（）
317.              {    //标识符
318.                
319.               wordget[i++] = ch; //将ch放到wordget中去形成单词
320.              
321.               ch=获得字符(*point);
322.                  *point+=1;  
324.              }
325.             wordget[i] = '/0';//成字符串
326.             *point-=1;    //回退一个字符
327.             /*
328.             code = Reserve(wordget);//对wordget字符串查找保留字表 若是一个保留字-返回其编码 否则返回0
329.             if(code == 0)//wordget这个单词不是一个保留字
330.             {
331.                value = InsertId(wordget);//将str串以标识符插入符号表，并返回符号表指针（如果str在符号表中存在 则返回存在的指针）
332.                pDu->kind  = ID;         //这个单词的类型为“标识符” ID 33
333.                pDu->value = value;      //其值为 在符号表中的指针位置
334.             }
335.             else//wordget这个单词是一个保留字
336.             {
337.                pDu->kind = code;       //类型为保留字在保留字表中的位置
338.                pDu->value = -1;         //其值为-1
339.                if(0 == strcmp("for", wordget))
340.                {
341.                    //printf("dddddff:%d--%d",forstart(point),point);
342.                    printf("发现一个for循环，/"(/"开始位置%d，/"{/"位置：%d，/"}/"位置：%d：/n",point,forstart(point),forblock(forstart(point)));
343.                    getBlocksoWT(forstart(point),forblock(forstart(point)),pDu,fin, fout);
344.                }
346.             
347.             }
348.         
349.             updatesoWT(wordget);
350.         */
351.             return true;
353.         }
354.     case 'D':  //ch是数字时
355.         *point+=1; 
356.         while(isdigit(ch))//只要下一个字符是数字 则和这个数字连成一个单词
357.         {
358.             wordget[i++] = ch;
359.             ch=获得字符(*point);
360.              *point+=1;
361.         }
362.         wordget[i] = '/0';//成字串
363.         *point-=1;
364.         /*
365.         value = InsertConst(wordget);//将str串以常数插入常量表，并返回常数表指针（如果str在常量表中存在 则返回存在的指针）
366.         pDu->kind = CONST; //类型为“常量” 34
367.         pDu->value= value; //其值为wordget在常量表中的指针位置
368.         */
369.         return true;
370. //以下为ch为一下符号的情况(　)　[　]　.　,　!  !=　~　sizeof　<　<<　<=　>　>>　>=　=　==　　&　&&　&=　|　||　|=　?:　+　++　+=
371. //　-　->　--　-=　*　*=　/　/=　%　%=　>>=　<<=　^　^=
372.     case '"': //ch是"时 接下来的应该是个字符串
373.         //字符串常量
374.         do
375.         {
376.             wordget[i++] = ch;
377.             *point+=1;
378.             ch=获得字符(*point);
379.             
380.         }while(ch != '"' && ch != '/0');// 将“”中的字符串 放入到wordget中去
381.         wordget[i++] = ch;    
382.         wordget[i] = '/0';//变成字串
383.         *point+=1;
384.         /*
385.         if(ch == '/0')
386.         {
387.             printf("%s",wordget);
388.             ProcError(3);         //不正确的字符串表达
389.             pDu->kind = ERROR;    //类型0 
390.             pDu->value = 0;       //值 0
391.         }
392.         else
393.         {
394.             value = InsertConst(wordget);  //将wordget串以常数插入常量表，并返回常数表指针
395.             pDu->kind = CONST;             //类型 常数
396.             pDu->value = value;            //值  在常数表中的位置
397.         }
398.         */
399.         return true;
400.         //字符常量
401.     case '/''://ch是'时 接下来的应该是个字符常量
402.         wordget[i++] = ch;    // '
403.         ch=获得字符(++*point);
404.         
405.         wordget[i++] = ch;
407.         if(ch == '//')    // '/n'
408.         {//如果是转义字符则要多接收一个字符
409.             ch=获得字符(++*point);         // ch = '
410.             wordget[i++] = ch;
411.         }
412.         ch=获得字符(++*point); 
414.         wordget[i++] = ch;
415.         wordget[i] = '/0';//编程字串 '/n'/0
416.         *point+=1;
418.         /*
419.         if(ch != '/'')//'号不配对 则不对
420.         {//'/b'
421.             printf("%s",wordget);
422.             ProcError(2);      //非法的字符
423.             pDu->kind = ERROR; 
424.             pDu->value = 0;
425.         }
426.         else
427.         {
428.             value = InsertConst(wordget); //将wordget串以常数插入常量表，并返回常数表指针
429.             pDu->kind = CONST;
430.             pDu->value = value;
431.         }*/
432.         return true;
433.     case '(':
434.     case ')':
435.     case '[':
436.     case ']':
437.     case '.':
438.     case ',':
439.     case '~':
440.     case '?':
441.     case ':':
442.     case ';':
443.     case '{':
444.     case '}':
445.     case '#':
446.         wordget[i++] = ch;    
447.         wordget[i] = '/0';
448.         *point+=1;
449.         /*
450.         pDu->kind = DIVIDE; //界符
451.         pDu->value = -1;    //界符的时候 -1
452.         */
453.         return true;
454.     case '!':
455.         //!=
456.         wordget[i++] = ch;
457.         ch=获得字符(++*point); 
458.         if (ch=='=') wordget[i++] = ch;
459.         else *point-=1;
460.         wordget[i]='/0';
461.         
462.         break;
463.     case '<':
464.         // << <=
465.         wordget[i++] = ch;
466.         ch=获得字符(++*point); 
467.         if (ch == '<' || ch == '=') wordget[i++] = ch;
468.         else *point-=1;
469.         wordget[i]='/0';
470.         
471.         break;
472.     case '>':
473.         // >> >=
474.         wordget[i++] = ch;
475.          ch=获得字符(++*point); 
476.         if (ch == '>' || ch == '=') wordget[i++] = ch;
477.         else *point-=1;
478.         wordget[i]='/0';
479.         
480.         break;
481.     case '=':
482.         // ==
483.         wordget[i++] = ch;
484.         ch=获得字符(++*point); 
485.         if (ch == '=') wordget[i++] = ch;
486.         else *point-=1;
487.         wordget[i]='/0';
488.         
489.         break;
490.     case '&':
491.         // && &=
492.         wordget[i++] = ch;
493.        ch=获得字符(++*point); 
494.         //if (ch == '&' || ch == '=') wordget[i++] = ch;
495.         if (ch !=' ') wordget[i++] = ch;
496.         else *point-=1;
497.         wordget[i]='/0';
498.         
499.         break;
500.     case '|':
501.         // || |=
502.         wordget[i++] = ch;
503.         ch=获得字符(++*point); 
504.         if (ch == '|' || ch == '=') wordget[i++] = ch;
505.         else *point-=1;
506.         wordget[i]='/0';
507.         
508.         break;
509.     case '+':
510.         // ++ +=
511.         wordget[i++] = ch;
512.         
513.         ch=获得字符(++(*point)); 
514.         if (ch == '+' || ch == '=') wordget[i++] = ch;
515.         else *point-=1;
516.         wordget[i]='/0';
517.         
518.         break;
519.     case '-':
520.         // -- -= ->
521.         wordget[i++] = ch;
522.         ch=获得字符(++*point); 
523.         if (ch == '-' || ch == '=' || ch == '>') wordget[i++] = ch;
524.         else *point-=1;
525.         wordget[i]='/0';
526.         
527.         break;
528.     case '*':
529.         // ** *=
530.         wordget[i++] = ch;
531.         ch=获得字符(++*point); 
532.         if (ch == '*' || ch == '=') wordget[i++] = ch;
533.         else *point-=1;
534.         wordget[i]='/0';
535.         
536.         break;
537.     case '/':
538.         // /=
539.         wordget[i++] = ch;
540.         ch=获得字符(++*point); 
541.         if (ch == '=') wordget[i++] = ch;
542.         else *point-=1;
543.         wordget[i]='/0';
544.         
545.         break;
546.     case '%':
547.         // %=
548.         wordget[i++] = ch;
549.         ch=获得字符(++*point); 
550.         if (ch == '=') wordget[i++] = ch;
551.         else *point-=1;
552.         wordget[i]='/0';
553.         
554.         break;
555.     case '^':
556.         // ^=
557.         wordget[i++] = ch;
558.         ch=获得字符(++*point); 
559.         if (ch == '=') wordget[i++] = ch;
560.         else *point-=1;
561.         wordget[i]='/0';
562.         
563.         break;
564.     case '/0':
565.         return false;
566.     default:
567.         //ProcError(1);
568.         return false;
569.     }
570.     //updatesoWT(wordget);
571.     //pDu->kind = OPERAT;
572.     *point+=1;
573.     return true;
574. }
576. void 寻找程序块名(int 开始左括号位置)
577. {
580. }
582. int 返回右括号配对(int 右括号位置)
583. {
584.      int flag = 0;//表示开始默认搜索(
585.      int i = 右括号位置-1;
586.      while(i > 0)
587.      {
588.      
589.          if(0 == strcmp(")", wordTab[i])&&flag>=0)
590.                {
591.                    
592.                    flag++;//表示开始搜索这个{匹配的}
594.                }
595.          
597.          else if(0 == strcmp("(", wordTab[i])&&flag>=1)
598.          {
599.              flag--;
600.          }
602.          else if(0 == strcmp("(", wordTab[i])&&flag==0)
603.          {
604.              
605.              return i;
606.          }
607.          i--;
609.      }
611.     return -1;
612. }
614. int 返回左括号配对(int 左括号位置)
615. {
616.      int flag = 0;//表示开始默认搜索)
617.      int i = 左括号位置+1;
618.      while(i < 单词表长度)
619.      {
620.      
621.          if(0 == strcmp("(", wordTab[i])&&flag>=0)
622.                {
623.                    
624.                    flag++;//表示开始搜索这个{匹配的}
626.                }
627.          
629.          else if(0 == strcmp(")", wordTab[i])&&flag>=1)
630.          {
631.              flag--;
632.          }
634.          else if(0 == strcmp(")", wordTab[i])&&flag==0)
635.          {
636.              
637.              return i;
638.          }
639.          i++;
641.      }
643.     return -1;
644. }
646. int 返回左大括号配对(int 左大括号位置)
647. {
648.       int flag = 0;//表示开始默认搜索}
649.      int i = 左大括号位置+1;
650.      while(i < 单词表长度)
651.      {
652.      
653.          if(0 == strcmp("{", wordTab[i])&&flag>=0)
654.                {
655.                    
656.                    flag++;//表示开始搜索这个{匹配的}
658.                }
659.          
661.          else if(0 == strcmp("}", wordTab[i])&&flag>=1)
662.          {
663.              flag--;
664.          }
666.          else if(0 == strcmp("}", wordTab[i])&&flag==0)
667.          {
668.              
669.              return i;
670.              
671.          }
672.          i++;
673.      }
674.      return -1;
675. }
678. void 分割程序()
679. {
680.     int flag = 0;//表示开始默认搜索{
681.     int i = 0;
682.      while(i<单词表长度)
683.      {
684.      
685.          if(0 == strcmp("{", wordTab[i])&&flag==0)//发现一级{
686.                {
687.                    if(0 == strcmp(")", wordTab[i-1]))//只有{前紧跟着（）的才是一个块，块一般是指函数
688.                    {
690.                         int ff = 返回右括号配对(i-1)-1;
691.                   
692.                          strcpy(块名表[块表长度], wordTab[ff]);
693.                          块开始位置[块表长度]=i;
694.                          块结束位置[块表长度]=返回左大括号配对(i);
698.                         //printf("发现一个块，块名字：%s，块开始位置：%d，结束位置：%d",wordTab[ff],i,返回左大括号配对(i));
699.                         if(是否输出详情)
700.                         {
701.                             printf("/n发现一个块，块名字：%s，块开始位置：%d，结束位置：%d",块名表[块表长度],块开始位置[块表长度],块结束位置[块表长度]);
702.                         }
704.                         块表长度++;
705.                         flag++;//表示开始搜索这个{匹配的}
706.                    }
708.                }
711.          if(0 == strcmp("{", wordTab[i])&&flag>0)//发现非一级{
712.          {
713.              flag++;
715.          }
718.          if(0 == strcmp("}", wordTab[i])&&flag>1)
719.          {
720.              flag--;
721.          }
724.          if(0 == strcmp("}", wordTab[i])&&flag==1)
725.          {
726.              
727.              flag--;
728.          }
729.          i++;
731.      }
733.     
734. }
736. void 插入单词表(char *str)
737. {
738.     
739.    
740.     strcpy(wordTab[单词表指针++], str);
741.     //return (pointCTB-1);
742. }
743. void 建立单词表()
744. {
745.     int 指针 = 0;
746.      while(获得单词(&指针))
747.      {
749.         插入单词表(wordget);
750.         单词表长度++;
751.      }
752. }
755. int 查关键字表(char *str)
756. {
757.     int i;
758.     for(i=0; i<KEYWORD_LEN; ++i)    //从保留字表中查找str串
759.     {
760.         if(0 == strcmp(关键字表[i], str))
761.             return i;    
762.     }
763.     return -1;
764. }
767. int 查函数名表(char *str)
768. {
769.     int i;
770.     for(i = 0; i < 块表长度; ++i)    //从函数名表中查找str串
771.     {
772.         if(0 == strcmp(顺序块名表[i], str))
773.             return i;    
774.     }
775.     return -1;
777. }
779. float 查指令表返回权值(char *str)
780. {
781.     int i;
782.     int 位置 = -1;
784.     for(i=0; i<OP_LEN; ++i)    //从保留字表中查找str串
785.     {
786.         if(0 == strcmp(操作指令表[i], str))
787.             位置 = i;    
788.     }
790.     if(位置 == -1)
791.     {
792.          return -1;
793.     }else
794.     {
795.         return 指令相对权值[位置];
797.     }
798. }
800. int 分析for起点(int for位置)
801. {
802.     int 分析点 = for位置+1;
804.     if(0 == strcmp("(", wordTab[分析点]))
805.     {
806.         分析点=返回左括号配对(分析点)+1;
807.     }else
808.     {
809.         发现语法错误();
810.         return -1;
811.     }
812.     return 分析点;
814. }
816. int 分析for终点(int for位置)
817. {
818.     int 分析点 = 分析for起点(for位置);
819.     
821.     if(0 == strcmp("{", wordTab[分析点]))//for块 以{}出现
822.     {
823.          return 返回左大括号配对(分析点);
824.     }
825.     else if(0 == strcmp("if", wordTab[分析点]))
826.     {
827.         int if的终点;
828.         if块分支数(分析点,if的终点);
829.         return if的终点;
831.     }
832.     else if(0 == strcmp("for", wordTab[分析点]))
833.     {
834.         return 分析for终点(分析点);
836.     }
837.     else
838.     {//for后面没有{}块 只跟一条语句
839.         while(0 != strcmp(";", wordTab[分析点]))
840.         {
841.            分析点++;
842.         }
844.         return 分析点;
846.     }
848. }
850. int 分析for条件点(int for位置)
851. {
852.     int 分析点 = for位置 + 1;
853.     
855.     while(0 != strcmp(";", wordTab[分析点]))
856.     {//找到第一个";"
857.         
858.       分析点++;
859.     }
860.     分析点++;
861.     while(0 != strcmp(";", wordTab[分析点]))
862.     {//找到第二个";"
863.         
864.       分析点++;
865.     }
869.     return 分析点;
872. }
874. int 分析for循环次数(int for位置)
875. {
876.      int 分析点 = for位置+1;
877.      int 开始条件,结束条件,次数;
879.     if(0 == strcmp("(", wordTab[分析点]))
880.     {
881.         /**
882.         for(i=0;i<n;i++) 只能分析一下这个情况下的循环次数，并且只有n是一个常数的时候才分析
883.         */
884.         if(  (0 == strcmp(wordTab[分析点+1], wordTab[分析点+5]))  &&  (0 == strcmp(wordTab[分析点+5], wordTab[分析点+9]))  &&  是否为数字(wordTab[分析点+3])  &&  是否为数字(wordTab[分析点+7])  &&  ((0 == strcmp("++", wordTab[分析点+10]))||(0 == strcmp("--", wordTab[分析点+10]))))
885.         {   
887.              结束条件 = 字串变数字(wordTab[分析点+7]);
888.              开始条件 = 字串变数字(wordTab[分析点+3]);
889.              if(0 == strcmp("++", wordTab[分析点+10]))
890.              {
891.                   次数 = 结束条件-开始条件;
892.              }else
893.              {
894.                   次数 = 开始条件-结束条件;
896.              }
898.              if(次数>0)
899.              return 次数;
900.              else
901.              return 0;//起始条件都不满足 则这个循环不开始
903.         }else//其他的情况不好分析，默认循环“循环体默认计数”次，这个参数应该是个可以调整的多次调整以得到最好的预测结果
904.         {
906.              return 循环体默认计数;
907.         }
908.         
909.         
912.     }else
913.     {
914.         发现语法错误();
915.         return -1;
916.     }
917.     
918. }
921. int 分析if起点(int if位置)
922. {
923.     int 分析点 = if位置+1;
925.     if(0 == strcmp("(", wordTab[分析点]))
926.     {
927.         分析点=返回左括号配对(分析点) + 1;
928.     }else
929.     {
930.         发现语法错误();
931.         return -1;
932.     }
933.     return 分析点;
935. }
937. int 块后面一个单词(int 块起点)
938. {
939.     int 分析点;
941.     分析点 = 块起点;//此时分析点在if条件括号后面一个单词
943.     if(0==strcmp("{",wordTab[分析点]))
944.     {//if语句后面有{}
945.         分析点=返回左大括号配对(分析点);
947.     }else
948.     {//if语句后面直接接一个语句的
949.         while(0 != strcmp(";", wordTab[分析点]))
950.         {
951.            分析点++;
952.         }//循环完后 分析点 指向;
953.         
955.     }
956.     return ++分析点;
961. }
963. int if块分支数(int if位置,int *if终点)
964. {
965.     int 分支 = 1;
966.     int 块结束下一位置 = 块后面一个单词(分析if起点(if位置));
967.     while(0==strcmp("else",wordTab[块结束下一位置]))
968.     {
969.         分支++;
970.         if(0 == strcmp("if",wordTab[块结束下一位置+1]))
971.         {
972.             块结束下一位置 = 块后面一个单词(分析if起点(块结束下一位置+1));
975.         }else
976.         {
977.             块结束下一位置 = 块后面一个单词(块结束下一位置+1);
979.             break;
981.         }
985.     }
986.     *if终点 = 块结束下一位置-1;
987.     if(分支 == 1) 分支 = 2;
988.     return 分支;
990. }
996. int 分析while起点(int while位置)
997. {
998.     int 分析点 = while位置 + 1;
1000.     if(0 == strcmp("(", wordTab[分析点]))
1001.     {
1002.         分析点 = 返回左括号配对(分析点)+1;
1003.     }else
1004.     {
1005.         发现语法错误();
1006.         return -1;
1007.     }
1009.     return 分析点;
1011. }
1013. int 分析while终点(int while位置)
1014. {
1015.     int 分析点 = 分析while起点(while位置);
1016.     
1018.     if(0 == strcmp("{", wordTab[分析点]))//for块 以{}出现
1019.     {
1020.          return 返回左大括号配对(分析点);
1021.     }
1022.     else
1023.     {//for后面没有{}块 只跟一条语句
1024.         while(0 != strcmp(";", wordTab[分析点]))
1025.         {
1026.            分析点++;
1027.         }
1029.         return 分析点;
1031.     }
1033. }
1035. int 分析switch起点(int switch位置)
1036. {
1037.     int 分析点 = switch位置 + 1;
1039.     if(0 == strcmp("(", wordTab[分析点]))
1040.     {
1041.         分析点 = 返回左括号配对(分析点)+1;
1042.     }else
1043.     {
1044.         发现语法错误();
1045.         return -1;
1046.     }
1048.     return 分析点;
1050. }
1051. int 分析switch终点(int switch位置)
1052. {
1054.     int 分析点 = 分析switch起点(switch位置);
1055.     
1057.     if(0 == strcmp("{", wordTab[分析点]))//for块 以{}出现
1058.     {
1059.          return 返回左大括号配对(分析点);
1060.     }
1061.     else
1062.     {
1063.         发现语法错误();
1065.         return -1;
1067.     }
1069. }
1070. int switch分支数(int switch起点,int switch终点)
1071. {
1072.     int 分析点 = switch起点;
1073.     int sum=0;
1075.     while(分析点 <= switch终点)
1076.     {
1077.        if(0 == strcmp("case", wordTab[分析点]))
1078.        {
1079.           sum++;
1080.        }
1081.        分析点++;
1082.     }
1083.     return sum;
1085. }
1086. float 顺序分析(int 起点,int 终点)
1087. {
1088.     float 该块权值 = 0.0;
1090.     int 当前分析点=起点;
1092.     while(当前分析点 < 终点)
1093.     {
1094.         switch(查关键字表(wordTab[当前分析点]))
1095.         {
1096.             case 13://for
1097.                 {
1098.                     int forend = 分析for终点(当前分析点);
1101.                     int forbegin = 分析for起点(当前分析点);
1103.                     if(forbegin != -1)
1104.                     {
1105.                     int div= 分析for条件点(当前分析点);
1106.                     int times = 分析for循环次数(当前分析点);
1107.                     int forblockWT = 顺序分析(div,forend);
1108.                     int forst = 顺序分析(当前分析点+1,div);
1110.                     该块权值 += forst;
1112.                     该块权值 += times * forblockWT;
1114.                     当前分析点 = forend;
1116.                     if(是否输出详情)
1117.                     {
1118.                         printf("/nfor语句的起点：%d 终点：%d 这个FOR语句的循环次数：%d，该for语句块的权值：%d，总权值 = 条件权值 + for语句块的权值 * 循环次数（%d = %d + %d * %d）",forbegin,forend,times,forblockWT,该块权值,forst,forblockWT,times);
1119.             
1120.                     }
1121.                         //该块权值 += 顺序分析(当前分析点,div)  + 分析for循环次数(当前分析点) * (顺序分析(div,forend));
1122.                     }
1123.                     else
1124.                     {
1125.                         当前分析点 = 单词表长度;
1127.                     }
1129.                     break;
1131.                 }
1132.             case 15://if
1133.                 {
1134.                     if(0 != strcmp("else",wordTab[当前分析点-1])){
1135.                         //如果当前IF是一个if块的第一个if，而不是分支中的 else if
1136.                     int if结束点 = 0 ;
1137.                     int if起点 = 分析if起点(当前分析点);
1138.                     int if分支数 = if块分支数(当前分析点,if结束点);
1140.                     
1141.                     if(if起点 != -1)
1142.                     {
1143.                     
1145.                         if(是否输出详情)
1146.                          {
1147.                              printf("/n发现一个if,该if开始位置：%d 分支数为%d,-----",if起点,if分支数);
1148.                              printf("/n该if块结束位置为：%d,",if结束点);
1149.                         }
1151.                          该块权值 += 顺序分析(if起点,if结束点)/if分支数;
1152.                     }
1153.                     else
1154.                     {
1155.                          当前分析点 = 单词表长度;
1157.                     }
1160.                     当前分析点 = if结束点;
1161.                     }
1162.                     break;
1163.                 }
1164.             case 31://while
1165.                 {
1166.                     
1167.                     int whilebegin = 分析while起点(当前分析点);
1169.                     if(whilebegin != -1)
1170.                     {
1172.                        int whileend = 分析while终点(当前分析点);
1174.                        if(是否输出详情)
1175.                        {
1176.                            printf("/nwhile语句的起点：%d 终点：%d ",whilebegin,whileend);
1177.                        }
1179.                     
1180.                        该块权值 += 循环体默认计数 * 顺序分析(whilebegin,whileend);
1181.             
1182.             
1183.                        当前分析点 = whileend;
1184.                     }
1185.                     else
1186.                     {
1187.                         当前分析点 = 单词表长度;
1188.                     }
1191.                     break;
1192.                 }
1194.             case 25://switch
1195.                 {   int switchbegin = 分析switch起点(当前分析点);
1199.                     int switchend = 分析switch终点(当前分析点);
1201.                     int fenzhi = switch分支数(switchbegin,switchend);
1202.                      
1203.                     if((switchbegin != -1) && (switchend != -1))
1204.                     {
1206.                         if(是否输出详情)
1207.                         {
1208.                             printf("/n发现一个switch,该switch开始位置：%d 分支数为%d,-----",switchbegin,fenzhi);
1209.                             printf("/n该if块结束位置为：%d,",switchend);
1210.                         }
1212.                         该块权值 += (顺序分析(switchbegin,switchend) / fenzhi);
1214.                         当前分析点 = switchend;
1215.                     }
1216.                     else
1217.                     {
1218.                         当前分析点 = 单词表长度;
1220.                     }
1224.                 }
1226.             case -1://不是一个关键字
1227.                 {
1228.                     int temp = 查函数名表(wordTab[当前分析点]);
1229.                     if(temp != -1)
1230.                     {//如果是一个函数，则用前面分析到的这个函数的权值 作为这个关键字的权值
1233.                         if(是否输出详情)
1234.                         {
1235.                             printf("/n发现一个函数，当前分析点：%d, 函数名：%s:权值： %f/n",当前分析点,wordTab[当前分析点],块权值[temp]);
1236.                         }
1238.                         该块权值 += 块权值[temp];
1240.                     }
1241.                     
1242.                     else if(查指令表返回权值(wordTab[当前分析点]) != -1)
1243.                     {
1244.                         if(是否输出详情)
1245.                         {
1246.                             printf("/n当前分析点：%d, 单词：%s:权值： %f=====%f/n",当前分析点,wordTab[当前分析点],查指令表返回权值(wordTab[当前分析点]),该块权值);
1247.                         }
1248.                         该块权值 += 查指令表返回权值(wordTab[当前分析点]);
1249.                     }
1251.                 
1252.                 
1253.                 }
1254.             default:break;
1255.         }
1258.         当前分析点++;
1259.     }
1260.     
1261.     return 该块权值;
1263. }
1265. int 按函数名查找函数表(char *str)//如果在函数表里 就返回在“块名表”里的位置
1266. {
1267.     int i;
1268.     for(i=0;i<块表长度;i++)
1269.     {
1270.         if(0 == strcmp(str,块名表[i]))
1271.         {
1272.             return i;
1273.         }
1274.     }
1275.     return -1;
1278. }
1279. void 块名表调序(int 新顺序,int 老位置)
1280. {
1281.     //顺序块名表[新顺序] = 块名表[老位置];
1282.     strcpy(顺序块名表[新顺序],块名表[老位置]);
1283.     
1284.     strcpy(块名表[老位置],"");
1286.     顺序块开始位置[新顺序] = 块开始位置[老位置];
1288.     顺序块结束位置[新顺序] = 块结束位置[老位置];
1292.     
1293. }
1295. void 按函数出现顺序排序()
1296. {
1297.     int 当前分析点 = 0;
1298.     int i=0,j=0;
1300.     while(当前分析点 < 单词表长度)
1301.     {
1302.         i = 按函数名查找函数表(wordTab[当前分析点]);
1303.             if(i != -1)
1304.             {
1305.                 块名表调序(j,i);
1306.                 j++;
1309.             }
1310.         当前分析点++;
1314.     }
1315.     
1316.     
1317. }
1319. //float getSourceWT(int times,bool isprint,String str)
1320. JNIEXPORT jdouble JNICALL Java_com_swjtu_sourcemanage_SourceScan_getSourceWT(JNIEnv * env, jclass c1, jint times, jboolean isprint, jstring str)
1321. {
1322.     循环体默认计数 = times;
1323.     是否输出详情 = isprint;
1324.      int i=0;
1325.     char c;
1327.    
1328.         //读入程序();
1329.     
1330.     //读入程序1(source);
1331.     //char* csStr = env->GetStringUTFChars(str,NULL);
1332.     //char* csStr = GetStringUTFChars(
1335.        
1336.         const char* csStr = env->GetStringUTFChars(str,NULL);
1337.         读入程序1(csStr);
1339.     预处理();
1340.    
1342.     建立单词表();
1344.     分割程序();
1346.     按函数出现顺序排序();
1347.     
1348.     for(int i=0;i<块表长度;i++)
1349.     {
1350.         块权值[i] = 顺序分析(顺序块开始位置[i],顺序块结束位置[i]);
1351.         
1352.         
1353.         
1355.     }
1356.     if(是否输出详情)
1357.     {
1358.         for(int i=0;i<块表长度;i++)
1359.         {
1360.             printf("/n块信息：/n%s:%d---%d/n",顺序块名表[i],顺序块开始位置[i],顺序块结束位置[i]);
1361.             printf("权值：%f",块权值[i]);
1362.         }
1363.     }
1364.     if(是否发现语法错误)
1365.     {
1366.         return -1;
1368.     }
1369.     else
1370.     {
1372.         for(int i=0;i<块表长度;i++)
1373.         { 
1374.             if(0==strcmp("main",顺序块名表[i]))
1375.             {
1376.                return 块权值[i];
1377.             }
1378.         }
1379.         //没有main块 ，也算是语法错误
1380.         return -1;
1382.         
1383.     }
1384.     
1386. }
1389. /*
1390. int main()
1391. {
1393.     
1395.     
1396.      
1399.     printf("权值---->：%f",getSourceWT(90,false));
1400.     
1401.     
1403.     printf("/n写入完毕/n按任意键继续/n");    getch();
1405.     return 0;
1406. }
1407. */

        步骤四：生成DLL文件 使用命令：cl -IC:/include -LD com_swjtu_sourcemanage_SourceScan.cpp -FeSourceScan.dll如果执行过程中出现找不到头文件错误，则将该头文件所在目录加入到命令中（如-IC:/include，目录名不要有空格），如果执行过程出现打不开lib文件错误，则将相应的文件拷贝到C:/c文件夹下。成功后生成SourceScan.dll，将这个文件拷贝到com文件同目录。