Page d'accueil>Code source JSP>Autres catégories
Télécharger

Décomposition

Ensemble de méthodes de décomposition du code source.

Installation

  1. $ git clone [email protected]:acheshkov/program_slicing.git
  2. $ cd program_slicing
  3. $ git submodule update --recursive --init
  4. $ pip3 install ./program_slicing

Vous devriez avoir accès à Global Network pour utiliser PIP. Python 3.9 avec le compilateur C correspondant est requis. Exécutez la console Python pour vérifier la version du compilateur C.

Usage

Ce projet peut être utilisé via une interface de ligne de commande , ou il peut être inclus dans tout autre projet Python en tant que sous-module.

Interface de ligne de commande

tranche

Utilisez cette commande si vous souhaitez décomposer les fichiers source par une tranche de calcul complète (Nikolaos Tsantalis et Alexander Chatzigeorgiou. 2011. Identification des opportunités de refactorisation de méthode d'extrait pour la décomposition des méthodes). 

$ python cli.py slice [-h]
                      [-o OUTPUT]
                      source

Arguments de position:

Source - dossier source, fichier ou URL

Arguments facultatifs:

-O , - Output Output - Fichier de sortie ou répertoire: Selon ce que vous définissez en tant que sortie, vous obtiendrez un dossier plein de décompositions de tranche ou d'un seul fichier avec. Il utilise STDOUT s'il n'est pas spécifié

-H , --help - Montrez ce message d'aide et sortez

Exemples: 

$ python cli.py slice MyProjectPath
$ python cli.py slice MyFile.java
$ python cli.py slice MyProjectPath --output MyResultPath
$ python cli.py slice MyFile.java --output MyResultPath

Interface de sous-module

Graphique de dépendance du contrôle - Structure qui représente le graphique de dépendance au contrôle (héréditaire de NetworkX.Digraph ) avec des méthodes correspondantes. 

 from program_slicing . graph . cdg import ControlDependenceGraph
  • add_entry_point - Marquez le nœud spécifié comme point d'entrée.
  • get_entry_points - Renvoyez un ensemble de nœuds qui est marqué comme un point d'entrée.

Graphique de flux de contrôle - Structure qui représente le graphique de flux de contrôle (hérité de NetworkX.Digraph ) avec des méthodes correspondantes. 

 from program_slicing . graph . cfg import ControlFlowGraph
  • add_entry_point - Marquez le nœud spécifié comme point d'entrée.
  • get_entry_points - Renvoyez un ensemble de nœuds qui est marqué comme un point d'entrée.

Graphique de dépendance des données - Structure qui représente le graphique de dépendance des données (hérité de Networkx.Digraph ) avec des méthodes correspondantes. 

 from program_slicing . graph . ddg import DataDependenceGraph
  • add_entry_point - Marquez le nœud spécifié comme point d'entrée.
  • get_entry_points - Renvoyez un ensemble de nœuds qui est marqué comme un point d'entrée.

Graphique de dépendance du programme - Structure qui représente le graphique de dépendance du programme (hérité de NetworkX.Digraph ) avec des méthodes correspondantes. 

 from program_slicing . graph . pdg import ProgramDependenceGraph
  • add_entry_point - Marquez le nœud spécifié comme point d'entrée.
  • get_entry_points - Renvoyez un ensemble de nœuds qui est marqué comme un point d'entrée.

Instruction - Structure qui représente le graphique de dépendance au contrôle , le graphique de dépendance des données ou les nœuds de graphe de dépendance du programme . 

 from program_slicing . graph . statement import Statement
  • Statement_Type - Objet StateType .
  • start_point - Numéros de ligne et de colonne du début de l'instruction .
  • end_point - Numéros de ligne et de colonne de la fin de l'instruction .
  • affecté_by - ensemble de chaînes avec des noms de variables qui peuvent affecter l' instruction actuelle.
  • Nom - String avec le nom de l' instruction . Toutes les déclarations ne sont pas nommées.
  • AST_NODE_TYPE - String avec des informations supplémentaires sur le nœud (par exemple une classe de racine AST).

StateType - Structure qui énumère les types d'instructions . 

 from program_slicing . graph . statement import StatementType
  • Fonction - Instruction de déclaration de fonction.
  • Instruction de déclaration variable - variable .
  • Affectation - Instruction d'attribution variable (comme i = 0 , i += 1 , i++ , etc.).
  • Appel - Instruction d'appel de fonction.
  • SPOCE - instruction SPOPE (telles que les accolades {} ou le corps vide dans if (...) a = 0 ).
  • BRANCH - Énoncé qui branche le flux (comme if , try , catch , switch ).
  • Loop - Instruction de branche qui génère un flux arrière (comme for et while ).
  • GOTO - Déclaration qui dirige le flux vers une déclaration concrète (telle que break , continue , throw , return et même else ).
  • Inconnu - Toutes les autres déclarations .
  • Exit - instruction spéciale qui est placée dans la déclaration de fin de fonction, a une taille nulle et tous les nœuds «retour» et «jet» conduisent le flux (ainsi que la dernière instruction de l'écoulement).

Bloque de base - Structure qui représente les nœuds de graphe de flux de contrôle . 

 from program_slicing . graph . basic_block import BasicBlock
  • Instructions - Obtenez le contenu du bloc de base , c'est-à-dire une liste d' instructions .
  • root - Obtenez la première instruction du bloc de base . Aucun s'il est vide.
  • Ajouter - Ajoutez une instruction spécifiée au bloc de base .
  • IS_EMPTY - Renvoie True s'il n'y a pas d'instructions dans le bloc de base , sinon - false.
  • Split - Contenu divisé par l'indice donné, a quitté la première partie de la division au bloc de base d'origine et renvoyez un nouveau bloc de base qui contient toutes les instructions de repos.

Program Graphs Manager - Structure qui contient différents types de graphiques de programme (tels que le graphique de flux de contrôle ou le graphique de dépendance au contrôle ) basé sur le même code source et fournit un ensemble de méthodes pour leur analyse. 

 from program_slicing . graph . parse import Lang
from program_slicing . graph . parse import control_dependence_graph
from program_slicing . graph . parse import control_flow_graph
from program_slicing . graph . manager import ProgramGraphsManager

manager_by_source = ProgramGraphsManager ( source_code , Lang . JAVA )

manager_by_cdg = ProgramGraphsManager . from_control_dependence_graph ( control_dependence_graph ( source_code , Lang . JAVA ))

manager_by_cfg = ProgramGraphsManager . from_control_flow_graph ( control_flow_graph ( source_code , Lang . JAVA ))

Propriétés:

  • CONTROL_DEPENDENCE_GRAPH - Renvoyez le graphique de dépendance du contrôle .
  • CONTROL_FLOW_GRAPH - Renvoyez le graphique de flux de contrôle .
  • data_dependence_graph - renvoyez le graphique de dépendance des données .
  • Program_Dependence_Graph - Renvoyez le graphique de dépendance du programme .
  • SORED_STATSTATION - RETOUR Les instructions qui sont triées d'abord en augmentant leur start_point , puis en diminuant leur end_point .
  • General_statements - Retourne les instructions générales (celles qui ne sont contenues dans aucune instruction non SCOPE , BRANCH , LOOP , FUNCTION ou EXIT ).
  • SCOPE_STATSEMENT - Renvoyez toutes les instructions SCOPE , BRANCH , LOOP ou FUNCTION .

Méthodes publiques:

  • get_basic_block - Renvoie un bloc de base (qui est un nœud du graphique de flux de contrôle ) qui contient une instruction donnée.
  • get_boundary_blocks - Renvoie un ensemble de blocs de base qui l'intersection des blocs dominés et d'atteindre contiennent le bloc donné.
  • get_boundary_blocks_for_statement - Renvoie un ensemble de blocs limites pour le bloc de base dans lequel l' instruction donnée est placée.
  • get_domined_blocks Renvoie un ensemble de blocs de base qui sont dominés par celui donné (c'est-à-dire que leurs instructions sont placées dans un sous-arbre du graphique de dépendance de contrôle de la racine du bloc de base donné).
  • get_reach_blocks - Renvoyez un ensemble de blocs de base qui sont accessibles à partir de celui donné dans le graphique de flux de contrôle .
  • get_statement_line_numbers - Renvoie un ensemble de numéros de ligne dans lesquels l' instruction donnée est placée.
  • get_function_statement - renvoie l' instruction FUNCTION minimale dans laquelle l' instruction donnée est placée.
  • get_function_statement_by_range - Renvoyez l' instruction de fonction minimale dans laquelle la plage donnée est placée.
  • get_scope_statement - renvoyez une instruction minimale de «scope» ( SCOPE , LOOP , BRANCH ) qui contient une instruction donnée.
  • get_statements_in_scope - Renvoyez toutes les instructions de l' instruction SCOPE donnée.
  • get_statements_in_range - renvoyez toutes les instructions de la plage donnée.
  • get_exit_statements - des instructions de retour qui sont des enfants de dépendance à l'écoulement des instructions données mais pas une d'entre elles.
  • GET_AFFECTING_STATSTATION - RETOUR Les instructions de l'ensemble donné d' instructions qui affectent une instruction ne forment pas l'ensemble donné.
  • get_changed_variables_statements - return les instructions de VARIABLE qui représentent les variables modifiées dans l'ensemble donné des instructions .
  • get_involved_variables_statements - Retourne les instructions VARIABLE qui représentent les variables impliquées (y compris l'utilisation) dans l'ensemble donné des instructions .
  • contenu_redundant_statements - Vérifiez si l'ensemble des instructions donné contienne une partie d'une construction non entièrement incluse dans l'ensemble donné.

Méthodes de classe:

  • From_source_code - Créez tous les graphiques par une chaîne de code source donnée et une description de la langue.
  • From_Control_Dependence_Graph - Créez tous les graphiques par un graphique de dépendance de contrôle donné.
  • From_Control_Flow_Graph - Créez tous les graphiques par un graphique de flux de contrôle donné.
  • From_data_dependence_graph - Créez tous les graphiques par un graphique de dépendance de données donné.
  • From_program_dependence_graph - Créez tous les graphiques par un graphique de dépendance de programme donné.

Parse - Ensemble de fonctions qui permettent de créer différents graphiques de la chaîne de code source spécifiée et de la spécification du langage de programmation.

  • CONTROL_DEPENDENCE_GRAPH - AGRIEZ UN GRAPHE DE CONTRÔLE DE CONTRÔLE : 
 from program_slicing . graph . cdg import ControlDependenceGraph
from program_slicing . graph . parse import control_dependence_graph , Lang

cdg : ControlDependenceGraph = control_dependence_graph ( source_code , Lang . JAVA )
  • CONTROL_FLOW_GRAPH - AGRIEZ UN GRAPLE DE CONTRÔLE DE CONTRÔLE : 
 from program_slicing . graph . cfg import ControlFlowGraph
from program_slicing . graph . parse import control_flow_graph , Lang

cfg : ControlFlowGraph = control_flow_graph ( source_code , Lang . JAVA )
  • data_dependence_graph - analyser un graphique de dépendance des données : 
 from program_slicing . graph . ddg import DataDependenceGraph
from program_slicing . graph . parse import data_dependence_graph , Lang

ddg : DataDependenceGraph = data_dependence_graph ( source_code , Lang . JAVA )
  • Program_dependence_graph - analyser un graphique de dépendance du programme : 
 from program_slicing . graph . pdg import ProgramDependenceGraph
from program_slicing . graph . parse import program_dependence_graph , Lang

pdg : ProgramDependenceGraph = program_dependence_graph ( source_code , Lang . JAVA )
  • Tree_Sitter_ast - Analyser une syntaxe abstraite : 
 from tree_sitter import Tree
from program_slicing . graph . parse import tree_sitter_ast , Lang

ast : Tree = tree_sitter_ast ( source_code , Lang . JAVA )

Convertir - Il existe également une option pour convertir un type de graphique en un autre: 

 from program_slicing . graph import convert
from program_slicing . graph . cdg import ControlDependenceGraph
from program_slicing . graph . cfg import ControlFlowGraph

cdg : ControlDependenceGraph = ControlDependenceGraph ()
cfg : ControlFlowGraph = convert . cdg . to_cfg ( cdg )
new_cdg : ControlDependenceGraph = convert . cfg . to_cdg ( cfg )
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout