Debian Codegraph @

src/score.c

raw
1
2 /*
3 * This file is part of Complexity.
4 * Complexity Copyright (c) 2011-2020 by Bruce Korb - all rights reserved
5 *
6 * Complexity is free software: you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * Complexity is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 * See the GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "opts.h"
21 #include <setjmp.h>
22
23 static jmp_buf bail_on_proc;
24
25 static char const err_fmt[] = "error: %s %s\n";
26 static char const line_score[] = "line %5d score %5u\n";
27
28 typedef score_t (handler_func_t)(state_t *);
29
30 /**
31 * subexpression types that have been seen. Tracking is only done within
32 * one parenthesized expression. If two or more types are mixed, the
33 * expression gets penalized. If there is ever an assignment within
34 * an expression, the expression is penalized.
35 */
36 typedef struct {
37 int saw_and, saw_or, saw_assign, saw_relop;
38 score_t res;
39 } subexpr_seen_t;
40
41 /*
42 * declare the dispatch functions and define the table.
43 */
44 #define handle_TKN_KW_SWITCH handle_TKN_KW_FOR
45 #define handle_TKN_KW_WHILE handle_TKN_KW_FOR
46 #define handle_TKN_KW_ELSE handle_noop
47 #define handle_TKN_KW_EXTERN handle_invalid
48 #define handle_TKN_KW_GOTO handle_invalid
49 #define handle_TKN_EMPTY handle_invalid
50 #define handle_TKN_EOF handle_invalid
51 #define handle_TKN_NUMBER handle_expression
52 #define handle_TKN_NAME handle_expression
53 #define handle_TKN_REL_OP handle_invalid
54 #define handle_TKN_ARITH_OP handle_expression
55 #define handle_TKN_LOGIC_AND handle_invalid
56 #define handle_TKN_LOGIC_OR handle_invalid
57 #define handle_TKN_ASSIGN handle_invalid
58 #define handle_TKN_ELLIPSIS handle_invalid
59 #define handle_TKN_LIT_CLSPAREN handle_invalid
60 #define handle_TKN_LIT_COMMA handle_noop
61 #define handle_TKN_LIT_COLON handle_invalid
62 #define handle_TKN_LIT_QUESTION handle_expression
63 #define handle_TKN_LIT_CLSBRACK handle_invalid
64 #define handle_TKN_LIT_OPNBRACK handle_array_init
65 #define handle_TKN_LIT_CBRACE handle_invalid
66 #define handle_TKN_LIT_OBRACE handle_stmt_block
67 #define handle_TKN_LIT_OPNPAREN handle_p_expr
68
69 #define _Ttbl_(_v, _n) handle_ ## _n,
70 static handler_func_t TOKEN_TABLE
71 handle_parms, handle_bracket_expr;
72 #undef _Ttbl_
73
74 static handler_func_t * score_fun[TOKEN_MAX] = {
75 #define _Ttbl_(_v, _n) [_v] = handle_ ## _n,
76 TOKEN_TABLE
77 #undef _Ttbl_
78 };
79
80 #define APPLY_NEST_PENALTY(_s) ((_s) * penalty)
81
82 static int statement_depth = 0;
83
84 static score_t
85 handle_subexpr(state_t * sc, bool is_for_clause);
86
87 static score_t
88 bad_token(state_t * sc, char const * where, token_t ev)
89 {
90 static char const msgfmt[] =
91 "error on line %d of %s in file %s(%d):\n"
92 "in context %s, token %s (%d) is invalid.\n";
93 static char const * const tkn_names[] = {
94 #define _Ttbl_(_v, _n) [_v] = #_n,
95 TOKEN_TABLE
96 #undef _Ttbl_
97 };
98
99 char const * p = (ev < TOKEN_MAX) ? tkn_names[ev] : NULL;
100 char invbuf[32];
101
102 if (p == NULL) {
103 sprintf(invbuf, "%d is not a valid token", ev);
104 p = invbuf;
105 }
106
107 fprintf(stderr, msgfmt, sc->st_line_ct, sc->pname, sc->st_fstate->fs_fname,
108 sc->proc_line + sc->st_line_ct, where, p, ev);
109 return MAX_SCORE;
110 }
111
112 static token_t
113 next_score_token(state_t * sc)
114 {
115 fstate_t * fs = sc->st_fstate;
116 token_t tk = next_token(fs);
117
118 if ((tk == TKN_EOF) || (fs->fs_scan > sc->st_end))
119 longjmp(bail_on_proc, 1);
120
121 if (tk != TKN_KW_GOTO)
122 return tk;
123 sc->goto_ct++;
124 return TKN_NAME;
125 }
126
127 static void
128 unget_score_token(state_t * sc)
129 {
130 unget_token(sc->st_fstate);
131 }
132
133 /**
134 * The open brace for the statement block has already been processed.
135 */
136 static score_t
137 handle_stmt_block(state_t * sc)
138 {
139 fstate_t * fs = sc->st_fstate;
140 score_t res = 0;
141
142 /*
143 * Bookwork for the first call for a procedure
144 */
145 token_t ev = next_score_token(sc);
146 if (sc->st_nc_line_ct < 0) {
147 sc->st_line_ct = fs->cur_line;
148 sc->st_nc_line_ct = fs->nc_line;
149 }
150
151 if (++statement_depth > sc->st_depth_warned)
152 sc->st_depth_warned = statement_depth;
153
154 for (;; ev = next_score_token(sc)) {
155 switch (ev) {
156 case TKN_LIT_CBRACE:
157 if (HAVE_OPT(TRACE))
158 fprintf(trace_fp, line_score,
159 fs->cur_line, (unsigned int)res);
160 statement_depth--;
161 return (res > MAX_SCORE) ? MAX_SCORE : res;
162
163 default:
164 res += score_fun[ev](sc);
165 }
166 }
167 }
168
169 static score_t
170 handle_invalid(state_t * sc)
171 {
172 sc->st_fstate->fs_scan = sc->st_end;
173 fprintf(stderr, "invalid transition\n");
174 return MAX_SCORE;
175 }
176
177 static score_t
178 handle_noop(state_t * sc)
179 {
180 return 0;
181 }
182
183 static char const *
184 fiddle_subexpr_score(subexpr_seen_t * ses)
185 {
186 int which =
187 (ses->saw_and ? 0x01 : 0) +
188 (ses->saw_or ? 0x02 : 0) +
189 (ses->saw_assign ? 0x04 : 0) +
190 (ses->saw_relop ? 0x08 : 0);
191 int tmp;
192
193 switch (which) {
194 case 0x00:
195 case 0x01:
196 case 0x02:
197 case 0x08:
198 return NULL;
199
200 case 0x04:
201 ses->res += penalty * (score_t)ses->saw_assign;
202 return "assignment within expression";
203
204 case 0x07:
205 ses->res += penalty * (score_t)ses->saw_assign;
206 /* FALLTHROUGH */
207
208 case 0x03:
209 tmp = (ses->saw_and + 1) * ses->saw_or;
210 ses->res += penalty * (score_t)tmp;
211 return "AND and OR expressions";
212
213 case 0x05:
214 case 0x06:
215 ses->res += penalty * (score_t)ses->saw_assign;
216 ses->res += (score_t)(ses->saw_and + ses->saw_or);
217 return "assignments and boolean operators";
218
219 case 0x09:
220 case 0x0A:
221 ses->res += subexp_penalty * (score_t)ses->saw_relop;
222 return "comparison and boolean operators";
223
224 case 0x0B:
225 tmp = (ses->saw_and + 1) * ses->saw_or;
226 ses->res += subexp_penalty * (score_t)(ses->saw_relop * tmp);
227 return "AND, OR and comparison operators";
228
229 case 0x0C:
230 ses->res += penalty * (score_t)ses->saw_assign;
231 ses->res += subexp_penalty * (score_t)ses->saw_relop;
232 return "assignments and comparison operators";
233
234 case 0x0D:
235 case 0x0E:
236 ses->res += penalty * (score_t)(
237 ses->saw_assign + ses->saw_relop + ses->saw_and + ses->saw_or);
238 return "many kinds of operators";
239
240 case 0x0F:
241 tmp = (ses->saw_and + 1) * ses->saw_or;
242 ses->res += penalty * (score_t)(
243 ses->saw_assign + ses->saw_relop + tmp);
244 return "*ALL* kinds of operators";
245
246 default:
247 CX_ASSERT(which == 0);
248 }
249 }
250
251 static score_t
252 handle_TKN_LIT_SEMI(state_t * sc)
253 {
254 return 1;
255 }
256
257 static score_t
258 handle_subexpr(state_t * sc, bool is_for_clause)
259 {
260 bool saw_name = false;
261 int tkn_ct = 0;
262 subexpr_seen_t ses = { 0, 0, 0, 0, 1.0 };
263 int const start_nc_ln_ct = sc->st_fstate->nc_line;
264
265 for (;;) {
266 token_t ev = next_score_token(sc);
267 tkn_ct++;
268
269 switch (ev) {
270 case TKN_LIT_CLSPAREN:
271 if (tkn_ct <= 2) // name + close paren
272 return 0;
273
274 if (! is_for_clause) {
275 char const * msg = fiddle_subexpr_score(&ses);
276 if ((msg != NULL) && HAVE_OPT(TRACE))
277 fprintf(trace_fp, "line %5d expression score adjusted due "
278 "to mix of %s\n", sc->st_fstate->cur_line, msg);
279 }
280
281 ses.res += (score_t)(sc->st_fstate->nc_line - start_nc_ln_ct);
282 if (ses.res > 1)
283 ses.res -= 1;
284 if (HAVE_OPT(TRACE))
285 fprintf(trace_fp, line_score,
286 sc->st_fstate->cur_line, (unsigned int)ses.res);
287 return ses.res;
288
289 case TKN_LIT_OPNPAREN:
290 if (saw_name)
291 ses.res += handle_parms(sc);
292 else {
293 ses.res += handle_subexpr(sc, false) * subexp_penalty;
294
295 /*
296 * We have not actually seen a name, but it could have
297 * been a parenthesized expression that yields a pointer.
298 * That pointer can reference a procedure or an array of
299 * memory. We lie a little bit.
300 */
301 ev = TKN_NAME;
302 }
303 break;
304
305 case TKN_ASSIGN:
306 /*
307 * Only worry over assignment operators in nested expressions
308 */
309 ses.saw_assign += (statement_depth > 1) ? 1 : 0;
310 break;
311
312 case TKN_LOGIC_AND:
313 ses.saw_and++;
314 break;
315
316 case TKN_LOGIC_OR:
317 ses.saw_or++;
318 break;
319
320 case TKN_REL_OP:
321 ses.saw_relop++;
322 break;
323
324 case TKN_LIT_COMMA:
325 case TKN_LIT_SEMI:
326 ses.res += 1.0;
327 break;
328
329 case TKN_NAME:
330 case TKN_NUMBER:
331 case TKN_ARITH_OP:
332 case TKN_LIT_COLON:
333 case TKN_LIT_QUESTION:
334 break;
335
336 case TKN_LIT_OBRACE:
337 ses.res += APPLY_NEST_PENALTY(handle_stmt_block(sc));
338 break;
339
340 case TKN_LIT_OPNBRACK:
341 ses.res += handle_bracket_expr(sc);
342 break;
343
344 default:
345 return bad_token(sc, "parenthesized expression", ev);
346 }
347
348 saw_name = (ev == TKN_NAME);
349 }
350 }
351
352 /*
353 * handle parameters. They are basically free, unless they
354 * get extended to multiple lines or include parenthesized
355 * lists.
356 */
357 static score_t
358 handle_parms(state_t * sc)
359 {
360 score_t res = 0;
361 int const start_nc_ln_ct = sc->st_fstate->nc_line;
362
363 for (;;) {
364 token_t ev = next_score_token(sc);
365 switch (ev) {
366 case TKN_LIT_CLSPAREN:
367 {
368 /*
369 * Set to zero if we are on the same non-comment line count
370 */
371 int l_ct_delta = sc->st_fstate->nc_line - start_nc_ln_ct;
372 return (score_t)l_ct_delta + res;
373 }
374
375 case TKN_LIT_OPNPAREN:
376 {
377 score_t s = handle_subexpr(sc, false);
378 if (s > 0)
379 res += s;
380 break;
381 }
382
383 case TKN_LIT_OBRACE:
384 res += APPLY_NEST_PENALTY(handle_stmt_block(sc));
385 break;
386
387 case TKN_LIT_OPNBRACK:
388 {
389 score_t s = handle_bracket_expr(sc);
390 if (s > 1)
391 res += s - 1;
392 break;
393 }
394
395 default:
396 (void)handle_expression(sc);
397 break;
398 }
399 }
400 }
401
402 /**
403 * expressions always count at least 1. Additional points
404 * are added for multiple lines and complexity and lack
405 * of parentheses when there are operators of different
406 * precedence.
407 */
408 static score_t
409 handle_expression(state_t * sc)
410 {
411 score_t res = 1;
412 int const start_nc_ln_ct = sc->st_fstate->nc_line;
413 bool paren_is_parms = true;
414 bool cbrace_needs_semi = false;
415
416 for (;;) {
417 token_t ltk = sc->st_fstate->last_tkn;
418 token_t ev = next_score_token(sc);
419 bool next_paren_is_parms = false;
420 bool next_cbrace_needs_semi = false;
421
422 switch (ev) {
423 case TKN_LIT_CBRACE:
424 if (HAVE_OPT(TRACE))
425 fprintf(trace_fp, line_score,
426 sc->st_fstate->cur_line, (unsigned int)res);
427 /* FALLTHROUGH */
428 case TKN_LIT_CLSBRACK:
429 case TKN_LIT_CLSPAREN:
430 unget_score_token(sc);
431 goto done;
432
433 case TKN_LIT_COMMA:
434 res += 1;
435 break;
436
437 case TKN_LIT_SEMI:
438 goto done;
439
440 case TKN_LIT_OPNPAREN:
441 if (paren_is_parms)
442 res += handle_parms(sc) - 1; // calling name already counted
443
444 else {
445 res += handle_subexpr(sc, false);
446 next_paren_is_parms = true;
447 }
448 break;
449
450 case TKN_NAME:
451 next_paren_is_parms = true;
452 break;
453
454 case TKN_LIT_OBRACE:
455 res += APPLY_NEST_PENALTY(handle_stmt_block(sc));
456 if (! cbrace_needs_semi) {
457 /*
458 * Someone has mutilated C syntax and made a macro into
459 * a block structured command. (Bad idea, but common....)
460 * To fix this, we lie to our caller and claim we saw a
461 * semi-colon.
462 */
463 sc->st_fstate->last_tkn = TKN_LIT_SEMI;
464 goto done;
465 }
466 break;
467
468 case TKN_LIT_OPNBRACK:
469 res += handle_bracket_expr(sc) - 1;
470 break;
471
472 case TKN_ASSIGN:
473 next_cbrace_needs_semi = true;
474 break;
475
476 case TKN_LIT_COLON:
477 /*
478 * A name followed by a colon is a statement label, unless
479 * we are in the middle of a ternary operation.
480 */
481 if (sc->st_colon_need > 0) {
482 sc->st_colon_need--;
483 } else if (ltk ==TKN_NAME)
484 goto done;
485 break;
486
487 case TKN_LIT_QUESTION:
488 sc->st_colon_need++;
489 break;
490
491 case TKN_NUMBER:
492 case TKN_ARITH_OP:
493 default:
494 break;
495 }
496
497 paren_is_parms = next_paren_is_parms;
498 cbrace_needs_semi = next_cbrace_needs_semi;
499 }
500
501 done:
502 {
503 /*
504 * Set the minimum to the number of lines used by the expr
505 * and limit the maximum to MAX_SCORE
506 */
507 score_t min = 1 + (sc->st_fstate->nc_line - start_nc_ln_ct);
508 if (res < min)
509 res = min;
510 else if (res > MAX_SCORE)
511 res = MAX_SCORE;
512 }
513 return res;
514 }
515
516 static score_t
517 handle_p_expr(state_t * sc)
518 {
519 unget_score_token(sc);
520 return handle_expression(sc);
521 }
522
523 /*
524 * Handle these:
525 *
526 * case VALUE:
527 * case (expression):
528 * case (expr1) ... (expr2):
529 */
530 static score_t
531 handle_TKN_KW_CASE(state_t * sc)
532 {
533 score_t case_score = 1;
534 int ellipsis_ct = 0;
535
536 for (;;) {
537 token_t ev = next_score_token(sc);
538 switch (ev) {
539 case TKN_LIT_OPNPAREN:
540 {
541 score_t pscore = handle_subexpr(sc, false);
542 if (pscore > 0)
543 case_score += pscore - 1;
544 break;
545 }
546
547 case TKN_ARITH_OP:
548 case TKN_REL_OP:
549 case TKN_NAME:
550 case TKN_NUMBER:
551 break;
552
553 case TKN_LIT_COLON:
554 return case_score + ellipsis_ct;
555
556 case TKN_ELLIPSIS:
557 if (ellipsis_ct > 0)
558 return bad_token(sc, "'case' statement ellipsis", ev);
559 ellipsis_ct = 2;
560 break;
561
562 default:
563 return bad_token(sc, "'case' statement", ev);
564 }
565 }
566 }
567
568 static score_t
569 handle_TKN_KW_DEFAULT(state_t * sc)
570 {
571 token_t ev = next_score_token(sc);
572 if (ev != TKN_LIT_COLON)
573 return bad_token(sc, "'default' missing colon", ev);
574 return 1;
575 }
576
577 static score_t
578 handle_TKN_KW_DO(state_t * sc)
579 {
580 score_t res = 1;
581 token_t ev = next_score_token(sc);
582
583 switch (ev) {
584 case TKN_LIT_OBRACE:
585 res += APPLY_NEST_PENALTY(handle_stmt_block(sc));
586 break;
587
588 case TKN_LIT_OPNPAREN:
589 res += handle_p_expr(sc);
590 break;
591
592 case TKN_KW_IF:
593 case TKN_KW_DO:
594 case TKN_KW_FOR:
595 case TKN_KW_SWITCH:
596 case TKN_KW_WHILE:
597 res += APPLY_NEST_PENALTY(score_fun[ev](sc));
598 break;
599
600 default:
601 res += handle_expression(sc);
602 }
603
604 ev = next_score_token(sc);
605 if (ev != TKN_KW_WHILE)
606 return bad_token(sc, "'do ...' missing 'while' ", ev);
607 ev = next_score_token(sc);
608
609 if (ev != TKN_LIT_OPNPAREN)
610 return bad_token(sc, "while loop expression", ev);
611
612 {
613 int psc = APPLY_NEST_PENALTY(handle_subexpr(sc, false));
614 if (psc < 1)
615 psc = 1;
616 res += psc;
617 }
618 ev = next_score_token(sc);
619
620 if (ev != TKN_LIT_SEMI)
621 return bad_token(sc, "do...while() missing semicolon", ev);
622 return res;
623 }
624
625 static score_t
626 handle_TKN_KW_IF(state_t * sc)
627 {
628 score_t res = 0;
629 int then_clause_done;
630 token_t ev;
631
632 cascade_if:
633
634 then_clause_done = 0;
635 ev = next_score_token(sc);
636
637 if (ev != TKN_LIT_OPNPAREN)
638 return bad_token(sc, "if expression", ev);
639
640 res += handle_subexpr(sc, false) + 1;
641 ev = next_score_token(sc);
642
643 do_if_clause:
644
645 switch (ev) {
646 case TKN_LIT_OBRACE:
647 res += APPLY_NEST_PENALTY(handle_stmt_block(sc));
648 break;
649
650 case TKN_LIT_SEMI:
651 break;
652
653 case TKN_LIT_OPNPAREN:
654 res += handle_subexpr(sc, false);
655 goto simple_statement;
656
657 case TKN_LIT_COMMA:
658 ev = next_score_token(sc);
659 goto do_if_clause;
660
661 case TKN_LIT_OPNBRACK:
662 res += handle_bracket_expr(sc) - 1;
663 /* FALLTHROUGH */
664 case TKN_ARITH_OP:
665 case TKN_NAME:
666 case TKN_NUMBER:
667 simple_statement:
668 res += handle_expression(sc);
669 break;
670
671 case TKN_KW_IF:
672 case TKN_KW_DO:
673 case TKN_KW_FOR:
674 case TKN_KW_SWITCH:
675 case TKN_KW_WHILE:
676 res += APPLY_NEST_PENALTY(score_fun[ev](sc));
677 break;
678
679 default:
680 return bad_token(sc, "bad if block", ev);
681 }
682
683 if (then_clause_done)
684 return res;
685
686 ev = sc->st_fstate->last_tkn;
687 {
688 token_t ntkn = next_score_token(sc);
689 if (ntkn != TKN_KW_ELSE) {
690 /*
691 * Put the token back. The caller will need it.
692 */
693 unget_score_token(sc);
694 sc->st_fstate->last_tkn = ev;
695 return res;
696 }
697 }
698
699 ev = next_score_token(sc);
700 if (ev == TKN_KW_IF)
701 goto cascade_if;
702
703 then_clause_done = 1;
704 goto do_if_clause;
705 }
706
707 static score_t
708 handle_TKN_KW_FOR(state_t * sc)
709 {
710 score_t res;
711 bool real_for = (sc->st_fstate->last_tkn == TKN_KW_FOR);
712 token_t ev = next_score_token(sc);
713
714 if (ev != TKN_LIT_OPNPAREN)
715 return bad_token(sc, "loop expression", ev);
716
717 res = handle_subexpr(sc, real_for);
718 if (res < 1)
719 res = 1;
720 if (! real_for)
721 res *= penalty;
722
723 for (;;) {
724 ev = next_score_token(sc);
725 switch (ev) {
726 case TKN_LIT_OBRACE:
727 res += APPLY_NEST_PENALTY(handle_stmt_block(sc));
728 return res;
729
730 case TKN_LIT_SEMI:
731 return res;
732
733 case TKN_KW_IF:
734 case TKN_KW_DO:
735 case TKN_KW_FOR:
736 case TKN_KW_SWITCH:
737 case TKN_KW_WHILE:
738 res += APPLY_NEST_PENALTY(score_fun[ev](sc));
739 return res;
740
741 case TKN_LIT_OPNPAREN:
742 res += handle_subexpr(sc, false);
743 continue;
744
745 case TKN_LIT_OPNBRACK:
746 res += handle_bracket_expr(sc) - 1;
747 /* FALLTHROUGH */
748
749 case TKN_NAME:
750 case TKN_NUMBER:
751 res += handle_expression(sc);
752 if (sc->st_fstate->last_tkn == TKN_LIT_SEMI)
753 return res;
754 if (sc->st_fstate->last_tkn != TKN_LIT_COMMA)
755 return bad_token(sc, "loop body ended badly",
756 sc->st_fstate->last_tkn);
757 /* FALLTHROUGH */
758
759 default:
760 continue;
761 }
762 }
763 }
764
765 static score_t
766 handle_bracket_expr(state_t * sc)
767 {
768 score_t res = 0;
769
770 for (;;) {
771 res += handle_expression(sc);
772 if (sc->st_fstate->last_tkn != TKN_LIT_COMMA)
773 break;
774 res -= 1;
775 }
776
777 token_t ev = next_score_token(sc);
778 switch (ev) {
779 case TKN_LIT_CLSBRACK:
780 return (res > MAX_SCORE) ? MAX_SCORE : res;
781
782 default:
783 return bad_token(sc, "bracketed block", ev);
784 }
785 }
786
787 static score_t
788 handle_array_init(state_t * sc)
789 {
790 score_t res = handle_bracket_expr(sc) - 1;
791 token_t ev = next_score_token(sc);
792 if (ev != TKN_ASSIGN)
793 return bad_token(sc, "array element initializer", ev);
794 return res + handle_expression(sc);
795 }
796
797 /**
798 * return 'true' if the closing brace is on its own line.
799 * This affects both the non-comment line count and
800 * the total line count.
801 */
802 static inline bool
803 check_own_line_close(state_t * sc)
804 {
805 char const * p = sc->st_fstate->fs_scan - 1;
806 CX_ASSERT(*p == '}');
807 return IS_END_OF_LINE_CHAR(p[-1]);
808 }
809
810 /**
811 * Score the procedure we just found.
812 */
813 void
814 score_proc(state_t * score)
815 {
816 static bool fix_dispatch = true;
817
818 if (fix_dispatch) {
819 int ix = 0;
820 do {
821 if (score_fun[ix] == NULL)
822 score_fun[ix] = handle_invalid;
823 } while (++ix < TOKEN_MAX);
824 fix_dispatch = false;
825 }
826
827 if (setjmp(bail_on_proc) != 0) {
828 fprintf(stderr, "end of %s() in %s reached with open control blocks\n",
829 score->pname, score->st_fstate->fs_fname);
830
831 score->score = MAX_SCORE;
832 return;
833 }
834
835 statement_depth = 0;
836 score->st_line_ct = \
837 score->st_nc_line_ct = -1;
838
839 score->score = handle_stmt_block(score);
840 if (score->goto_ct > 0)
841 score->score += score->goto_ct * scaling;
842
843 if (score->st_depth_warned >= 5) {
844 fprintf(stderr, "NOTE: proc %s in file %s line %u\n"
845 "\tnesting depth reached level %u\n",
846 score->pname, score->st_fstate->fs_fname,
847 score->proc_line, score->st_depth_warned);
848 if (score->st_depth_warned >= 7)
849 fputs("==>\t*seriously consider rewriting the procedure*.\n", stderr);
850 }
851
852 if (score->st_fstate->fs_scan + 2 <= score->st_end) {
853 fprintf(stderr, "procedure %s in %s ended before final close bracket\n",
854 score->pname, score->st_fstate->fs_fname);
855
856 score->score += penalty;
857 }
858
859 /*
860 * No negative scores and no scores beyond the completely ridiculous
861 * value of MAX_SCORE
862 */
863 if (score->score < 0)
864 score->score = 0.0;
865
866 else if (score->score < MAX_SCORE)
867 score->score = (score_t)(unsigned int)((score->score * scaling) + 0.9);
868
869 if (score->score > MAX_SCORE)
870 score->score = MAX_SCORE;
871
872 /*
873 * Set the line counts for our score
874 */
875 bool close_on_own_line = check_own_line_close(score);
876 int ct = 1 + (score->st_fstate->cur_line - score->st_line_ct) -
877 (close_on_own_line ? 1 : 0);
878 score->st_line_ct = ct;
879 ct = 1 + (score->st_fstate->nc_line - score->st_nc_line_ct) -
880 (close_on_own_line ? 1 : 0);
881 score->st_nc_line_ct = ct;
882 }
883 /*
884 * Local Variables:
885 * mode: C
886 * c-file-style: "stroustrup"
887 * indent-tabs-mode: nil
888 * End:
889 * end of score.c */