home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / lifeos2.zip / LIFE-1.02 / TESTS / REFOUT / TESTSLC.REF < prev    next >
Text File  |  1996-06-04  |  34KB  |  192 lines
  1.  
  2. *** Yes
  3. --1> 
  4. *** No
  5. > 
  6. blic(main) ?
  7.  
  8. D = getenv("SLDIR"), chdir(D) ?
  9.  
  10. load("c_public_terms")?
  11. load("sl_public_terms")?
  12. load("sl_utils")?
  13. load("sl_parser")?
  14.  
  15. open("c_public_terms")?
  16. open("sl_public_terms")?
  17. open("sl_parser")?
  18. open("sl_utils")?
  19. load("rl_overload")?
  20.  
  21. '*rule*'(_A: "variable_length",
  22.          _B,
  23.          _C) :- is_list_member("declaration",
  24.                                _C), (parse_mode :== prefix, _B :== local_declaration), !, '*rule_name*' <<- ref(_A), _D = _B .scope, _E = _D .left_brace, _F = _D .right_brace,(_E .file :\== _F .file, !, error_msg("Braces around a block must be in the same file",
  25.                                                                                                                                                                                                                      _F) ; strlen(_B .name .id) =< sqrt(_F .line - _E .line), !, error_msg("Variable name is too short",
  26.                                                                                                                                                                                                                                                                                            _B .name) ; succeed) ; succeed.
  27.  
  28. '*rule*'(_A: "extern_in_c_file",
  29.          _B,
  30.          _C) :- is_list_member("declaration",
  31.                                _C), (parse_mode :== prefix, _B :== external_declaration), !, '*rule_name*' <<- ref(_A),((_B .type .store_class :== extern, file_extension(_B .name .file) :== "c"), !, error_msg("No declaration in a .c file accessed out of the .c file",
  32.                                                                                                                                                                                                                  _B .name) ; succeed) ; succeed.
  33.  
  34. '*rule*'(_A: "block_alignment",
  35.          _B,
  36.          _C) :- is_list_member("alignment",
  37.                                _C), ((parse_mode :== prefix, is_not_token(_B)),((_B :== if, ! ; _B :== while), ! ; _B :== for)), !, '*rule_name*' <<- ref(_A), _D = _B,(_D :== {while;
  38.                                                                                                                                                                                 for}, !, _E = _B .keyword, _F = _B .body,(_F :== block, !, test_alignment(_E,
  39.                                                                                                                                                                                                                                                           _F) ; succeed) ; _D :== if, !, _G = _B .keyword, _H = _B .then_body, (_H :== block, !, test_alignment(_G,
  40.                                                                                                                                                                                                                                                                                                                                                                 _H) ; succeed), _I = _B .else_body,(_I :\== nothing, !, _J = _B .else_keyword,(_I :== block, !, test_alignment(_J,
  41.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _I) ; succeed) ; succeed) ; succeed) ; succeed.
  42.  
  43. test_alignment(_A,
  44.                _B) :- _C = _B .left_brace, _D = _B .right_brace, (_C .white_spaces :\== " ", !, error_msg("There must be one space between brace and condition",
  45.                                                                                                           _C) ; succeed),(_D .column :\== _A .column, !, error_msg("Brace must be aligned with first character of instruction",
  46.                                                                                                                                                                    _D) ; succeed).
  47.  
  48. '*rule*'(_A: "nested_typedef",
  49.          _B,
  50.          _C) :- is_list_member("type_definition",
  51.                                _C), (parse_mode :== prefix, _B :== type_definition), !, '*rule_name*' <<- ref(_A), _D = _B .type,((_D :== protected_type, _D .type :== protected_type), !, error_msg("Only one level of nested parentheses allowed around type definitions",
  52.                                                                                                                                                                                                      _B .name) ; succeed) ; succeed.
  53.  
  54. '*rule*'(_A: "contiguous_nested_typedef",
  55.          _B,
  56.          _C) :- is_list_member("type_definition",
  57.                                _C), (parse_mode :== prefix, _B :== type_definition), !, '*rule_name*' <<- ref(_A), _D = _B .type,(((_D :== protected_type, _D .type :== protected_type), _D .left_parenthesis .next :== "("), !, error_msg("Only one level of contiguous nested parentheses allowed around type definitions",
  58.                                                                                                                                                                                                                                            _B .name) ; succeed) ; succeed.
  59.  
  60. '*rule*'(_A: "assignment_style",
  61.          _B,
  62.          _C) :- is_list_member("operator",
  63.                                _C), (parse_mode :== prefix, is_assignment_operator(_B)), !, '*rule_name*' <<- ref(_A),((_B .white_spaces :\== " ", ! ; _B .next .white_spaces :\== " "), !, error_msg("Assignment operators must be preceded and followed by a single space",
  64.                                                                                                                                                                                                       _B) ; succeed) ; succeed.
  65.  
  66. '*rule*'(_A: "adjacent_operators",
  67.          _B,
  68.          _C) :- is_list_member("operator",
  69.                                _C), ((parse_mode :== prefix, is_operator(_B)), is_token(_B)), !, '*rule_name*' <<- ref(_A),((is_operator(_B .previous), _B .white_spaces :== ""), !, error_msg("Two operators cannot be adjacent",
  70.                                                                                                                                                                                                _B) ; succeed) ; succeed.
  71.  
  72. '*rule*'(_A: "uninitialized_variable",
  73.          _B,
  74.          _C) :- is_list_member("semantics",
  75.                                _C), is_expression(_B), !, '*rule_name*' <<- ref(_A), _D = _B .mode, (parse_mode :== prefix, !, _E = _D,(_E :== special, !,(_B .operator :== "?", !, verify_init(_B .condition), verify_init(_B .then), verify_init(_B .else) ; _B :== protected_expression, !, verify_init(_B .expression) ; _B :== function_call, !, verify_init(_B .call), verify_init_args(_B .arguments .first_argument) ; _B :== array_reference, !, verify_init(_B .array), verify_init(_B .index) ; verify_init(_B .expression)) ; _E :== infix, !, _F = base_expression(_B .left_expression), ((_B .operator :== "=", _F :== identifier), !, set_feature(uninit_marked,
  76.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  true,
  77.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  _F) ; verify_init(_B .left_expression)), verify_init(_B .right_expression) ; _E :== {prefix;
  78.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       postfix}, !, verify_init(_B .expression) ; succeed) ; succeed),(((parse_mode :== postfix, _D :== infix), _B .operator :== "="), !, _F = base_expression(_B .left_expression),(_F :== identifier, !, _G = declaration_of(_F .id),(_G :== local_declaration, !, set_initialized_variable(_F .id,
  79.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              current_instruction .scope) ; succeed) ; succeed) ; succeed) ; succeed.
  80.  
  81. verify_init(_A) :- _A :== identifier, !,(has_feature(uninit_marked,
  82.                                                      _A), !, succeed ; _B = first_mention_of(_A .id),(_B :== nothing, !, error_msg("Variable may be uninitialized",
  83.                                                                                                                                    _A) ; succeed)) ; succeed.
  84.  
  85. verify_init_args(_A) :- _A :\== nothing, !, verify_init(_A .expression), verify_init_args(_A .next) ; succeed.
  86.  
  87. set_initialized_variable(_A,
  88.                          _B) :- _C = _B,(_C :== then_body, !, _D = _B .instruction, (has_feature(then_init_variables,
  89.                                                                                                  _D), !, succeed ; set_feature(then_init_variables,
  90.                                                                                                                                variables,
  91.                                                                                                                                _D)), set_feature(_A,
  92.                                                                                                                                                  init,
  93.                                                                                                                                                  _D .then_init_variables) ; _C :== else_body, !, _D = _B .instruction, (has_feature(else_init_variables,
  94.                                                                                                                                                                                                                                     _D), !, succeed ; set_feature(else_init_variables,
  95.                                                                                                                                                                                                                                                                   variables,
  96.                                                                                                                                                                                                                                                                   _D)), set_feature(_A,
  97.                                                                                                                                                                                                                                                                                     init,
  98.                                                                                                                                                                                                                                                                                     _D .else_init_variables) ; _C :== {for;
  99.                                                                                                                                                                                                                                                                                                                        {while;
  100.                                                                                                                                                                                                                                                                                                                         do_while}}, !, (has_feature(init_variables,
  101.                                                                                                                                                                                                                                                                                                                                                     _B), !, succeed ; set_feature(init_variables,
  102.                                                                                                                                                                                                                                                                                                                                                                                   variables,
  103.                                                                                                                                                                                                                                                                                                                                                                                   _B)), set_feature(_A,
  104.                                                                                                                                                                                                                                                                                                                                                                                                     init,
  105.                                                                                                                                                                                                                                                                                                                                                                                                     _B .init_variables) ; _C :== block, !, _E = _B .block_declarations .local_declarations,(has_feature(_A,
  106.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         _E), !, set_feature(init,
  107.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             true,
  108.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             _E ._A) ; set_initialized_variable(_A,
  109.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _B .scope)) ; _C :== {nothing;
  110.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function_body}, !, succeed ; set_initialized_variable(_A,
  111.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _B .scope) ; succeed).
  112.  
  113. '*rule*'(_A: "propagate_init",
  114.          _B,
  115.          _C) :- is_list_member("semantics",
  116.                                _C), ((_B :== if, is_not_token(_B)), parse_mode :== postfix), !, '*rule_name*' <<- ref(_A), _D = intersect_init_variables(_B), set_initialized_variables(_D,
  117.                                                                                                                                                                                         _B .scope) ; succeed.
  118.  
  119. set_initialized_variables(_A,
  120.                           _B) :- _A :== [], !, succeed ; set_initialized_variable(_A .first_element,
  121.                                                                                   _B), set_initialized_variables(_A .tail,
  122.                                                                                                                  _B).
  123.  
  124. intersect_init_variables(_A) -> _B | (has_feature(then_init_variables,
  125.                                                   _A), !,(has_feature(else_init_variables,
  126.                                                                       _A), !, _B = intersection(features_list(_A .then_init_variables),
  127.                                                                                                 features_list(_A .else_init_variables)) ; _B = features_list(_A .then_init_variables)) ; has_feature(else_init_variables,
  128.                                                                                                                                                                                                      _A), !, _B = features_list(_A .else_init_variables) ; _B = []), cond(_B :== @,
  129.                                                                                                                                                                                                                                                                           _B = unknown).
  130.  
  131. intersection(_A,
  132.              _B) -> _C | (_A :== [], !, _C = [] ; _D = _A .first_element, _E = intersection(_A .tail,
  133.                                                                                             _B),(member(_D,
  134.                                                                                                         _B), !, _C = newlist(_D,
  135.                                                                                                                              _E) ; _C = _E)), cond(_C :== @,
  136.                                                                                                                                                    _C = unknown).
  137.  
  138. base_expression(_A) -> _B | (_A :== protected_expression, !, _B = base_expression(_A .expression) ; _B = _A), cond(_B :== @,
  139.                                                                                                                    _B = unknown).
  140.  
  141. is_expression(_A) -> _B | (has_feature(mode,
  142.                                        _A), !, _B = true ; _B = false), cond(_B :== @,
  143.                                                                              _B = unknown).
  144.  
  145. first_mention_of(_A) -> _B | (current_block :== nothing, !, _B = external ; _B = search_mention_of(_A,
  146.                                                                                                    current_block)), cond(_B :== @,
  147.                                                                                                                          _B = unknown).
  148.  
  149. search_mention_of(_A,
  150.                   _B) -> _C | (_D = _B,(_D :== block, !, _E = _B .block_declarations .local_declarations,(has_feature(_A,
  151.                                                                                                                       _E), !,((_E ._A .initialization :\== nothing, ! ; has_feature(init,
  152.                                                                                                                                                                                     _E ._A)), !, _C = init ; _C = nothing) ; _C = search_mention_of(_A,
  153.                                                                                                                                                                                                                                                     _B .scope)) ; _D :== then_body, !, _F = _B .instruction,((has_feature(then_init_variables,
  154.                                                                                                                                                                                                                                                                                                                           _F), has_feature(_A,
  155.                                                                                                                                                                                                                                                                                                                                            _F .then_init_variables)), !, _C = init ; _C = search_mention_of(_A,
  156.                                                                                                                                                                                                                                                                                                                                                                                                             _F .scope)) ; _D :== else_body, !, _F = _B .instruction,((has_feature(else_init_variables,
  157.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _F), has_feature(_A,
  158.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _F .else_init_variables)), !, _C = init ; _C = search_mention_of(_A,
  159.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _F .scope)) ; _D :== {for;
  160.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           {while;
  161.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            do_while}}, !,((has_feature(init_variables,
  162.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _B), has_feature(_A,
  163.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         _B .init_variables)), !, _C = init ; _C = search_mention_of(_A,
  164.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _B .scope)) ; _D :== {nothing;
  165.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           function_body}, !, _C = external ; search_mention_of(_A,
  166.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _B .scope) ; succeed)), cond(_C :== @,
  167.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             _C = unknown).
  168.  
  169. declaration_of(_A) -> _B | (current_block :== nothing, !, _B = nothing ; _B = search_declaration(current_block .block_declarations,
  170.                                                                                                  _A)), cond(_B :== @,_B = unknown).
  171.  
  172. search_declaration(_A,
  173.                    _B) -> _C | ((_A :== block_declarations, !, _D = _A .local_declarations ; _D = nothing),(_D :== nothing, !, _C = nothing ; has_feature(_B,
  174.                                                                                                                                                           _D), !, _C = _D ._B ; _C = search_declaration(_A .parent_declarations,
  175.                                                                                                                                                                                                         _B))), cond(_C :== @,
  176.                                                                                                                                                                                                                     _C = unknown).
  177.  
  178. M : main :- 
  179.                   sl_parse(strip(M)),writeln, writeln("Style checking : "), writeln("----------------"), writeln, scan_tree({(operator, type_definition, alignment, declaration, variable_length)}), writeln, writeln("Uninitialized variables : "), writeln("-------------------------"), writeln, scan_tree(semantics).
  180.  
  181. '*superlint_rules*' <<- ["variable_length",
  182.  "extern_in_c_file",
  183.  "block_alignment",
  184.  "nested_typedef",
  185.  "contiguous_nested_typedef",
  186.  "assignment_style",
  187.  "adjacent_operators",
  188.  "uninitialized_variable",
  189.  "propagate_init",
  190.  "main"] ?
  191.  
  192.