File find_input_parameter_validation_template-with_s... of Package Deletion_of_checks_before_specific_function_cal...

Overview Repositories Revisions Requests Users Attributes Meta

File find_input_parameter_validation_template-with_static2.cocci of Package Deletion_of_checks_before_specific_function_calls_in_Linux_source_files (Revision aabfc3f59a9a7cfa2a0952d48165a55b)

Currently displaying revision aabfc3f59a9a7cfa2a0952d48165a55b , Show latest

// Copyright (c) 2015 Markus Elfring
//
// This file is part of a script collection for static source code analysis.
//
// The collection is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License (version 2)
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

@initialize:python@
URL << virtual.database_URL;
@@
import sqlalchemy, sys
sys.stderr.write("\n".join(["Using SQLAlchemy version:",
                            sqlalchemy.__version__]))
sys.stderr.write("\n")
from sqlalchemy import create_engine, Column, Integer, String

if URL == False or URL == "default":
   URL = "sqlite:///result-with_static.db"

engine = create_engine(URL, echo = False)
from sqlalchemy.ext.declarative import declarative_base
base = declarative_base()

class position(base):
   __tablename__ = "positions_parallel2"
   function = Column(String, primary_key = True)
   source_file = Column(String, primary_key = True)
   line = Column(Integer, primary_key = True)
   column = Column(Integer, primary_key = True)
   parameter = Column(String)
   data_type = Column(String)
   static = Column(Integer, default = 0)
   void = Column(Integer, default = 0)

from sqlalchemy.orm import sessionmaker
configured_session = sessionmaker(bind = engine)
session = configured_session()
base.metadata.create_all(engine)

def store_positions(fun, type, point, places):
    """Add source code positions to an internal table."""
    for place in places:
       entry = position(function = fun,
                        source_file = place.file,
                        line = place.line,
                        column = int(place.column) + 1,
                        data_type = type,
                        parameter = point
                       )
       session.add(entry)

def store_void(fun, type, point, places):
    """Add source code positions to an internal table."""
    for place in places:
       entry = position(function = fun,
                        source_file = place.file,
                        line = place.line,
                        column = int(place.column) + 1,
                        data_type = type,
                        parameter = point,
                        void = 1
                       )
       session.add(entry)

def store_static(fun, places):
    """Record that a function is static."""
    for place in places:
        session.query(position) \
               .filter_by(function = fun,
                          source_file = place.file,
                          line = place.line,
                          column = int(place.column) + 1
                         ) \
               .update({"static": 1})

@void_single_function_call@
identifier caller,
           input,
           member,
           release =~ "^(?x)
(?:
   (?:kz?|slob_)free
|
   (?:
# Alternation placeholder
   )
)$";
type input_type;
position pos;
@@
 void caller@pos(input_type input)
 {
(
  release(
(
          input
|
          input.member
)
         );
|
(
  release(
(
          input
|
          input.member
)
         );
)
  return;
)
 }

@script:python void_collection depends on void_single_function_call@
typ << void_single_function_call.input_type;
fun << void_single_function_call.caller;
point << void_single_function_call.input;
places << void_single_function_call.pos;
@@
store_void(fun, typ, point, places)

@non_void_single_function_call@
expression return_value;
identifier caller,
           input,
           member,
           result,
           non_void_release =~ "^(?x)
(?:
# non-void alternation placeholder
)$",
           release =~ "^(?x)
(?:
   (?:kz?|slob_)free
|
   (?:
# Alternation placeholder
   )
)$";
type data_type, input_type, return_type;
position pos;
@@
 return_type caller@pos(input_type input)
 {
(
  return non_void_release(
(
                          input
|
                          input.member
)
                         );
|
  release(
(
          input
|
          input.member
)
          );
  return return_value;
|
  data_type result = non_void_release(
(
                                      input
|
                                      input.member
)
                                     );
  return result;
)
 }

@script:python non_void_collection depends on non_void_single_function_call@
typ << non_void_single_function_call.input_type;
fun << non_void_single_function_call.caller;
point << non_void_single_function_call.input;
places << non_void_single_function_call.pos;
@@
store_positions(fun, typ, point, places)

@find_static_void depends on void_single_function_call@
identifier void_single_function_call.caller;
position void_single_function_call.pos;
@@
 static void caller@pos(...)
 {
  ...
 }

@find_static_non_void depends on non_void_single_function_call@
identifier non_void_single_function_call.caller;
type non_void_single_function_call.return_type;
position non_void_single_function_call.pos;
@@
 static return_type caller@pos(...)
 {
  ...
 }

@script:python void_addition depends on find_static_void@
fun << void_single_function_call.caller;
places << void_single_function_call.pos;
@@
store_static(fun, places)

@script:python non_void_addition depends on find_static_non_void@
fun << non_void_single_function_call.caller;
places << non_void_single_function_call.pos;
@@
store_static(fun, places)

@finalize:python@
@@
session.commit()
          
from sqlalchemy import func
entries = session.query(func.count("*")).select_from(position).scalar()

if entries < 1:
   sys.stderr.write("No result for this analysis!\n")

Places

File find_input_parameter_validation_template-with_static2.cocci of Package Deletion_of_checks_before_specific_function_calls_in_Linux_source_files (Revision aabfc3f59a9a7cfa2a0952d48165a55b)

Places