Lucrare

Facultatea de Automatic i Calculatoare
Calculatoare i Tehnologia Informaiei
Sistem de analiz
static a proiectelor
Candidat:
Kovacs-Vinan Ioan-Luca
Coordonator tiinific:
Conf. Dr. Ing. Lucian Prodan
2017
Kovacs-Vinan Ioan-Luca Sistem de analiz static a proiectelor
Cuprins
1. Introducere.................................................................................................. 1
1.1. Domeniul abordat i obiectivele generale ................................................. 3
1.2. Contextul de realizare............................................................................... 4
1.3. Specificaii generale ................................................................................. 6
2. Programe moderne de analiz a proiectelor ............................................ 7
3. Algoritmi pentru detectarea funciilor existente .................................... 13
3.1. Algoritmul de detectare a funciilor declarate .......................................... 14
3.1.1. Algoritmul de detectare a structurilor ................................................ 14
3.1.2. Algoritmul de detectare a funciilor ................................................... 15
3.1.3. Algoritmul de detectare a macrourilor ............................................... 15
3.2. Algoritmul de cutare a funciilor folosite: ............................................... 16
3.2.1 Algoritmi ce folosesc instruciuni de baz ale irurilor ....................... 17
3.2.2. Algoritmi ce folosesc instruciuni de baz ale tabelelor Excel ........... 17
4. Descrierea general a sistemului AnalysisTool .................................... 19
4.1. Arhitectura clasei funcionFinder ............................................................ 20
4.2. Arhitectura clasei StructFinder ............................................................... 24
4.3. Arhitectura clasei funcionClass ............................................................. 27
4.4. Arhitectura clasei MacroClass ................................................................ 29
4.5. Arhitectura clasei UsedFuncClass .......................................................... 32
5. Proiectarea i implementarea sistemului de analiz Clasa
functionFinder ................................................................................................ 37
6. Preluarea funciilor ..................................................................................... 41
6.1. Clasa StructClass ................................................................................... 41
6.2. Clasa functionClass ................................................................................ 46
6.3. Clasa MacroClass .................................................................................. 50
7. Detectarea funciilor folosite prin clasa UsedFuncClass........................ 55
8. Concluzii i perspective............................................................................. 61
Referine bibliografice ................................................................................... 63
Anexa 1: Rapoarte al progresului proiectului .............................................. 65
Anexa 2: Ghidul utilizatorului pentru aplicaia Analysis Tool .................... 69
1. Introducere
Proiectul de licen se refer la implementarea unei automatizri n domeniul

tehnologiei prin realizarea unui program care nlocuiete o munc manual, reducnd astfel
costurile si timpul necesar n cadrul analizei i testrii diverselor proiecte.
Succesiunea de evenimente din munca n cadrul serviciului i al facultii, m-a condus
la realizarea unui Tool, un program conceput n limbajul de programare C# Oriented Object
Programming.
Am identificat posibilitatea unei automatizri n analiza unor fiiere date, apartenente
unui proiect. Am realizat i apoi am generalizat automatizarea prin generarea unor tabele
Excel, cuprinznd toate funciile apelate n cadrul unor fiiere date, n plus, gsirea tuturor
fiierelor n care funciile sunt definite. n final am testat realizarea cerinei iniiale
identificarea anumitor funcii n anumite fiiere, din situaia general toate funciile n toate
fiierele.
Fig 1-1 Imagine de ansamblu a tool-ului
Urmtoarele pagini trec cititorul prin procesul de creeare al tool-ului, rezultatele

acestuia, aplicabilitatea i utilitatea lui.
Obiectivul principal al proiectului este s art c este mult mai important munca ce se
ocup cu automatizarea unui proces, dect efectuarea manual a procesului. Dei iniial este
mai time-consuming i necesit o implicare mult mai mare la nivel mental dect cea care o
necesit completarea manual a unui fiier Excel, aceast munc scutete ulterior chiar de
munca monoton manual anterioar. Un astfel de program care automatizeaz un proces,
dac este bine pus la punct, poate servi apoi utilizatorului pentru mult timp i repetitiv, fr s
mai fie nevoie de ncredinarea de task-uri persoanelor i plata acestora.
Vorbim despre procese banale, care ns datorit dimensiunilor mari ale proiectelor
necesit foarte mult timp. n plus, n cadrul automatizrii autovehiculelor, testele i analizele
sunt repetitive.
Lucrarea de licen trece cititorul prin procesul crerii software-ului i prezint
diversitatea lui, raportnd-o la simplitatea rezultatul final obinut.
Cap. 1 - Introducere 1
Sistem de analiz static a proiectelor Kovacs-Vinan Ioan-Luca
Proiectul ofer un instrument de automatizare a proceselor de analiz static i testare i

scurteaz considerabil timpul de desfurare al acestora.
Existena proiectului se justific prin raportarea utilitii sale viitoare la timpul necesar
implementrii. Dei iniial implementarea a durat mai mult dect gsirea i completarea
manual a funciilor ce sunt apelate n anumite fiiere, acest tip de analiz se realizeaz la
fiecare proiect asemntor. Aceste analize i testri verific dac se respect anumite
standarde, cum ar fi standardul MISRA, ct i dac se respect anumite principii de nglobare
sau modularizare. Modularizarea este cea pe care se axeaz programul, deoarece scopul lui
final este de a verifica dac un modul de fiiere, prin apelurile de funcii pe care le realizeaz,
nu are nevoie s apeleze alte funcii n afar de acelea definite n modul. Astfel el poate fi
nlocuit fr s afecteze restul proiectului (lucrrii).
Programul automatizeaz procesul de analiz a acestor programe, iar principala
contribuie pe care o aduce utilizatorului, este timpul economisit.
Dei ceva complet banal generarea unui tabel Excel cuprinznd o list de fiiere,
funciile apelate, fiierele n care acestea au fost definite, apartenena lor la o list dat,
apartentena la un domeniu analiza manual dureaz o lun jumtate. Acest timp, analiza
automat l reduce la o jumtate de or, cu mici variaii, n funcie de dimensiunea proiectului
i de puterea de procesare a computerului.
n continuare, pentru o mai bun nelegere, voi prezenta tabelul Excel de analiz,
completat manual cu funciile utilizate.
Fig 1-2 Imagine cu tabelul Excel care contine analiza fiierelor
Dup cum observm, se analizeaz modularizarea programelor de pe prima coloan.

Dup ce au fost analizate funciile folosite, cele care nu aparin modulului sunt completate
ulterior de ctre alte persoane, care specific riscul pe care acea funcie l are, ca i n cazul de
fa.
Sunt evideniate cu rou celulele care conin funcii ce folosesc macroinstruciuni i
pentru a cror gsire a fost necesar o dezvoltare a tool-ului. n urma a mai multor analize i
modificri, am reuit acoperirea tuturor funciilor folosite, exceptnd acele funcii care aparin
modulului, dar nu se cer analizate.
n plus, cutarea cu AnalysisTool a identificat i a importat n tabelul generat automat
funcii care manual nu au fost gsite (sau nu a fost gsit locaia de definire a acestora).
2 Cap. 1 Introducere
1.1. Domeniul abordat i obiectivele generale
Tool-ul a fost conceput n limbajul de programare C#. Acesta este un limbaj care
folosete metoda de proiectare Programare Orientat pe Obiect (POO).
Domeniul abordat de proiect folosete conceptele acestei metode de proiectare i
cunotinele de baz ale limbajului C.
Programarea Orientat pe Obiecte (POO, uneori i Programarea Orientat
Obiect) este o paradigm de programare axat pe ideea ncapsulrii, adic a gruprii datelor i
codului care opereaz asupra lor ntr-o singur structur. [1]
Un alt concept important asociat Programrii Orientate Obiect este polimorfismul, care
permite abstractizri ce au ca scop o descriere conceptual mai simpl a soluiei.
Principalele concepte care stau la baza POO sunt:
abstractizarea
ncapsularea
modularitatea
ierarhizarea
Programul dezvoltat folosete conceptele astfel:
abstractizarea, prin mprirea funcionalitilor pe module, acestea
reprezentnd obiecte care grupeaz anumite informaii, pe baza operaiilor efectuate de ctre
obiectul principal asupra lor, n urma interaciunii cu utilizatorul.
modulele ncapsuleaz atributele i metodele specifice fiecrui obiect a crui
clas a fost dezvoltat n program.
n continuarea dezvoltrii programului se are n vedere implementarea
conceptului de ierarhizare. n varianta actual acesta nu se regsete nc, deoarece
majoritatea claselor din cadrul programului opereaz cu iruri de caractere i mpart cte dou
metode comune.
Folosind limbajul de programare C# i 2 library-uri care opereaz cu fiiere xls,
respectiv xlsx, am realizat importarea i manevrarea datelor, apoi, pe baza rezultatelor astfel
obinute, construirea a unor fiiere Excel noi, care conin informaiile cerute iniial.
n continuare se prezint un scurt istoric al limbajului C# n care tool-ul a fost dezvoltat:
Lansat publicului n iunie 2000 i oficial n primvara anului 2002, C# este un limbaj de
programare care combin faciliti testate de-a lungul timpului cu inovaii de ultim moment.
Creatorii acestui limbaj au fost o echip de la firma Microsoft condus de Anders Hejlsberg.
Dei limbajul este creat de Microsoft, acesta nu este destinat doar platformelor Microsoft.
Compilatoare C# exist i pentru alte sisteme precum Linux sau Macintosh. Creat ca
instrument de dezvoltare pentru arhitectura .NET, limbajul ofer o modalitate facil i
eficient de a scrie programe pentru sistemul Windows, Internet, componente software etc. C#
deriv din dou dintre cele mai de succes limbaje de programare: C i C++. De asemenea,
limbajul este o rud apropiat a limbajului Java. Pentru o mai bun nelegere a limbajului
C# este interesant de remarcat care este natura relaiilor acestuia cu celelalte trei limbaje
menionate mai sus. n continuare vom prezenta i limbajul C++ pentru o mai bun nelegere
a posibilitii de dezvoltare. [2]
Limbajul C++. Programarea orientata obiect. La sfritul anilor 70 dimensiunile multor
programe erau aproape de limitele impuse de limbajul C. Pentru a rezolva problema a aprut o
modalitate nou de programare i anume programarea orientat obiect (POO). Limbajul C nu
permitea programarea orientat obiect. Fiind cel mai rspndit limbaj, s-a dorit extinderea s
n vederea implementrii noii modaliti de programare: programarea POO. Limbajul C++ a

fost creat de ctre Bjarne Stroustrup ncepnd din 1979, la laboratoarele Bell din Murray Hill,
New Jersey. Limbajul a fost denumit iniial C cu clase, iar n 1983 numele acestuia a fost
modificat n C++. n esen, C++ reprezint versiunea orientat obiect a limbajului C. n anii
80, limbajul C++ a suferit dezvoltri i perfecionri masive, astfel c n anii 90 a devenit cel
mai rspndit limbaj de programare. [3]
Obiectivele programului sunt:

realizeaz analiza static asupra fiierelor unui proiect
Analiza servete la verificarea modularizrii proiectului, din punctul de vedere al
ncapsulrii anumitor fiiere ntr-un grup independent de restul fiierelor prezente.
Modularizarea trebuie realizat pentru ca un software implementat s poat fi folosit i n
cadrul altor proiecte, ce difer numai prin anumite module.
Modularizarea trebuie s respecte standardele impuse de ctre MISRA.
MISRA C este un set de ajutoare pentru dezvoltarea software-ului conceput n
limbajul de programare C. Acest set a fost dezvoltat de catre Motor Industry Software
Reliability Associations. Scopurile lui sunt de a facilita sigurana, securitatea i portabilitatea
codului, n contextul de sisteme-embedded. [4]
asigur posibilitatea testrii diferitelor module n cadrul unui proiect
asigur posibilitatea nlocuirii unor module cu altele mai performante
1.2. Contextul de realizare
n cadrul firmei Continental, unde lucrez de aproximativ 6 luni (n perioada de

internship), mi s-au dat task-uri pentru a-mi testa capacitatea intelectual i modul n care
abordez diferite probleme. Ca oricrui student, mi s-a cerut s dezvolt un tool, un program
simplu, ntr-un limbaj ales de mine, care s analizeze fiierele header dintr-un proiect i s
genereze un fiier Excel cu toate macrourile definite (#define), ct i unde sunt folosite. La
sugestia colegilor am ales limbajul C#, n care nc nu dezvoltasem programe; dar derivat
fiind din limbajul C i eu dornic s dobndesc noi cunotine, mi-a fost relativ uor s mi-l
nsuesc prin diferite tutoriale.
Dup ce am realizat acest tool, mi s-a dat alt task i anume: avnd dat un tabel Excel,
completat cu o list de nume de fiiere, s deschid fiecare fiier n parte i cu ajutorul unui
program de pe Internet (scump i avnd o perioad de ncercare de 15 zile), s gsesc funciile
apelate.
Programul fcea posibil vizualizarea interconectrilor dintre funcii, n sensul: ce
funcii sunt apelate dintr-o funcie i n continuare pe mai multe niveluri. Interesul nostru
cuprindea nivelurile unu i doi. Urma, tot cu acest program, s gsim n ce fiiere au fost
definite funciile apelate. Dup care, s verificm dac fiierul care definete o anumit
funcie, aparine modulului iniial de fiiere.
Analiza are ca scop nglobarea diferitelor elemente, verific dac anumite fiiere sunt
dependente numai ntre ele sau sunt dependente i de alte fiiere ale proiectului.
Am propus superiorului de la lucru realizarea unui tool care s nglobeze sarcinile

programul de pe Internet (cu care lucram n perioada de ncercare), ct i munca manual ce
urma s cad n sarcina mea i a colegului meu.
El a fost ncntat, deoarece n cazul realizrii programului, pentru viitoarele proiecte nu
ar mai fi fost necesar o persoan care s lucreze mai mult de o lun pentru completarea
fiierului Excel, ci doar de cteva click-uri.
M-am gndit c o s fie ceva simplu i i-am spus c ar trebui s termin ntr-o
sptmn: ct de greu e s gseti toate funciile dintr-un proiect i s vezi unde sunt
folosite?
Ei bine, nu e foarte greu, dar necesit totui mai mult timp, pn acum am lucrat
aproape 3 luni de zile special pentru acest program. M-am lovit de diferite obstacole despre
care o s vorbesc n capitolele urmtoare.
Dar a dat rezultat i dei are nevoie de un timp destul de mare pentru a procesa
informaie (pn i o or), tot nu se compar cu timpul mare de o lun jumtate, dou, n care
analiza manual a fost realizat n paralel de ctre colegul meu.
Pe parcursul realizrii, mi-am dat seama c dei programul nu face ceva foarte special,
modul n care este el folosit aduce o contribuie important n dezvoltarea proiectelor de la
Continental i atunci m-am gndit s dezvolt acest program ca lucrare de licen. Deoarece
este proiectul la care am lucrat cel mai mult, din tot timpul facultii.
Apoi m-am gndit c lucrarea de licen ar trebui s fie accesibil unui grup mai mare
de oameni i tool-ul ar trebui s poat fi folosit i de ali oameni care au probleme
asemntoare, astfel l-am dezvoltat cu urmtoarele: am mbinat cele dou tool-uri (cel de
gsire a define-urilor i cel de gsire a funciilor), introducerea manual a numrului coloanei
pe care se gsesc fiierele i pe care se compar fiierele Excel i am adaugat o a 3-a interfa
accesibil unor operaii de baz cum ar fi: posibilitatea cutrii unor anumite cuvinte cheie
fr s fie necesar generarea vreunui fiier, posibilitatea cutrii manuale a anumitor
macrouri sau funcii i unde sunt acestea folosite.
Img. 1-3 Tool-ul afind rezultatele cutrii unui cuvnt
1.3. Specificaii generale
Subcapitolul conine descrierea pe scurt a proiectului, precum i enumerarea

specificaiilor generale ale proiectului.
Programul permite utilizatorului s realizeze cutri de cuvinte, funcii, macrouri sau
anumite poriuni de text, ntr-un folder specificat de ctre el. De asemenea, programul acoper
funcionalitatea primului tool dezvoltat, ncorporndu-l n gsirea macrourilor, pentru a
determina legturile i redefinirile dintre funcii.
Funcionalitatea cea mai important permite utilizatorului s genereze tabele:
cu funciile declarate ntr-un proiect,
cu funciile folosite n fiiere specificate de utilizator ntr-un tabel Excel.
Utilizatorul interacioneaz cu programul printr-o interfa grafic ce cuprinde:
butoane, o caset n care sunt listate rezultatele i casete de dialog care permit specificarea
detaliilor din partea utilizatorului.
Interfaa permite utilizatorului i o funcionalitate simpl, de ncrcare a dou fiiere
Excel i comparare a acestora printr-una sau dou coloane. Programul genereaz un fiier
Excel cu toate liniile care nu apar n primul fiier. Aceast funcionalitate este necesar n
situaia n care au fost aduse modificri succesive unui fiier Excel.
Interfaa este deschis pentru utilizatorii cu cunotine de baz n domeniul Tehnologiei
Informaiei i Comunicaiilor, dar coninutul tool-ului l recomand utilizatorilor care folosesc
cunotine din programare: definirea funciilor, apelarea funciilor, interconectarea dintre ele,
macrouri, structuri.
2. Programe moderne de analiz a proiectelor
n capitolul de fa se vor prezenta pe scurt sistemele actuale de analiz a funciilor din

diferite proiecte, ce folosesc limbajele de programare C i C#.
Fiecare limbaj n parte are nevoie de un mediu de dezvoltare pentru a putea fi analizat,
compilat, rulat.
Prin definiie, un mediu de dezvoltare reprezint o aplicaie software care furnizeaz
faciliti complexe utilizatorului programator pentru dezvoltarea de software.
n general, un mediu de dezvoltare este denumit IDE. Aceast denumire provine din
limba englez i este prescurtarea textului Integrated Development Environment.
Majoritatea mediilor de dezvoltare consist din:
un editor de cod surs,
tool-uri pentru automatizarea construirii software-ului,
Includ procese precum: compilarea codului surs n cod binar, rularea testelor automate.
tool pentru debugging: acesta este un program care e folosit pentru testarea i
depanarea codului surs.
Cele mai moderne medii de dezvoltare au completare inteligent a codului (ex: pop-up
de completare automat). Alte medii cum ar fi NetBeans i Eclipse conin i un compilator i
un executor. De asemenea, n unele medii sunt integrate diferite tool-uri pentru simplificarea
construciei Intefeei Grafice cu Utilizatorul (GUI). [5]
Aici am i vrut s ajung, deoarece tool-ul creat se apropie de procesele unor extensii ale
unui IDE.
n majoritatea mediilor de programare care faciliteaz dezvoltarea software-ului orientat
pe obiect, sunt incluse programe cum ar fi: class browser (caut clasele dintr-un proiect), class
hierarchy diagram (afieaz clasele unui proiect modul, n care acestea sunt interconectate),
generator de diagrame UML.
Pe lng acestea exist o sumedenie de extensii dezvoltate i puse la dispoziie pe
platforme online, care uureaz munca utilizatorului cnd vine vorba de testare, analiz cum
ar fi tool-ul Understand pentru Eclipse, care face posibil vizualizarea funciilor i a
legturilor dintre ele.
Tool-ul Understand este foarte eficient n colectarea metricilor despre cod i n redarea
diferitelor modaliti pentru utilizator de a le vedea. Exist o colecie substanial de metrici
standard disponibile, ct i opiuni pentru scrierea propriilor metrici n cazul n care tool-ul nu
acoper exact cerinele. [6]
Cap. 2 Programe moderne de analiz a proiectelor 7

Img 2-1:n imaginea de mai sus este prezentat tool-ul Understand, care genereaz grafic legturile dintre
fiierele existente.
Alt exemplu ar fi Tool-ul Doxigen, folosit pentru a genera documentaia pentru proiecte
de tip C++, suport i alte limbaje de programare populare cum ar fi C, C#, PHP, Java,
Python. Cu ajutorul lui putem extrage structuri de cod din fiiere surs. De asemenea, cu
ajutorul lui se pot vizualiza relaiile dintre variate elemente, cum ar fi: grafuri de dependen,
diagrame de motenire. [7]
Ei bine, cu un astfel de tool am avut de a face n cadrul lucrului la firma Continental.
Superiorul meu avea nevoie de un tabel n care s fie completate pe prima coloan numele
fiierului, pe a doua funciile ce le apeleaz i pe a treia unde au fost definite aceste funcii.
Mai pe scurt, avea nevoie s tie care sunt toate funciile apelate dintr-un anumit modul
de fiiere. Urmnd ca apoi s se identifice acele funcii care nu fac parte din modul.
Avea nevoie de aceast list de rezultate, pentru a efectua o analiz n detaliu asupra
unui modul de fiiere (un grup de fiiere ce aparineau folderului surs al proiectului). De ce
se dorete modularizarea acelor fiiere voi vorbi n capitolele urmtoare.
8 Cap. 2 Programe moderne de analiz a proiectelor

Img. 2-2: n imaginea de mai sus este reprezentat, folosind extensia Understand n mediul de dezvoltare
Eclipse, o funcie i apelurile ce le efectueaz asupra altor funcii, ct i apelurile funciilor apelate. Gradul de
adncime se poate seta manual.
Deci, ca s realizez aceast analiz, am nevoie de:

un IDE n primul rnd, iar IDE-ul stabilit era Eclipse;
un tool, Understand, cu care se poate vizualiza tree-ul funciilor: reprezentarea
grafic a legturilor dintre funciile proiectului.
Trebuie apoi:
s verific cu acest tool fiecare funcie, din fiecare fiier apartenent modulului,
s vizualizez funciile apelate,
s aflu cu ajutorul tool-ului Understand fiierul n care acea funcie este definit,
s verific dac acel fiier aparine sau nu modulului i s semnalez aceasta prin YES/
NO.
V dai seama c o astfel de munc este consumatoare de timp. Implic un proces
constant, obositor, care ofer foarte puin satisfacie unui programator care dorete s devin
viitor inginer.
A copia pe rnd, manual, fiecare funcie apelat de ctre program i a verifica manual
apartenena ei, dei sunt operaii de cteva click-uri pentru o singur funcie, reprezint un
consum important de timp, n special pentru fiiere foarte mari, cu sute de funcii. n cadrul
acestei analize vorbim de 120 de fiiere din proiect.
Deci, ca s ne facem o idee, n final putem s ne ateptm la un fiier Excel cu cteva
mii de linii. E necesar s menionez faptul c extensia Understand nu este gratuit, software-ul
cost bani; n plus, perioada de testare de dou sptmni implic o restricie de timp pentru
finalizarea analizei.

Img 2-3: Reprezentnd extensia nWire pentru mediul de programare Java
Dei sunt disponibile multe medii de dezvoltare i de asemenea multe tool-uri care
permit vizualizarea legturilor dintre fiiere sau dintre apelurile funciilor; programul care s
gseasc toate funciile definite ntr-un proiect, fr s foloseasc un mediu de programare, iar
rezultatele s le stocheze ntr-un tabel Excel, este conceput cu aceast ocazie. Software-ul
conine partea de gsire a funciilor (unde sunt ele definite), partea de folosire a funciilor
(unde sunt ele apelate) i partea de generare a rezultatelor sub form de tabel Excel.
Acest software:
nu va fi limitat de timp,
va fi mereu disponibil persoanelor din firma care trebuie s efectueze analize
asemntoare,
va reduce costurile firmei, deoarece nu va mai fi nevoie ca aceasta s plteasc o
persoan s lucreze o lun ntreag pentru a face analiza respectiv,
va reduce timpul de efectuare al analizei de la nivelul sptmnilor, la nivelul zecilor
de minute.
Acest tool nu vine n ajutorul dezvoltrii unui IDE i nici n simplificarea muncii
programatorului care folosete un mediu de programare. El este dezvoltat pentru a extrage
date dintr-un proiect scris n limbaj C sau C# i de a le analiza i stoca intr-o baza de date,
opernd cu tabele Excel.
Ideea dezvoltrii unui astfel de soft, care s nu aib de a face cu un mediu de dezvoltare,
care s poat analiza n mod independent un proiect i s extrag date despre toate funciile
existente, am vzut-o ca aducnd beneficii firmei n care lucrez i am considerat c poate fi i
o lucrare de licen.
n continuare prezint interfaa tool-ului AnalysisTool.

Img. 1-4: Imagine de ansamblu a programului de analiz
Rezultatul unei munci ndelungate este prezentat n imaginea urmtoare:
Img. 2-5: Imagine cu tabelul final ce conine funciile folosite
Nu este nimic special, ns rezultatul este exact rezultatul de care am nevoie i de care
firma a avut nevoie. Software-ul dezvoltat reuete s automatizeze un proces destul de
ndelungat (perioada depinde de mrimea proiectului, n cazul de fa a fost vorba de o lun
jumtate), care implic alte software-uri, iar pe lng acestea, analiza manual care ncetinete
considerabil procesul.

Nu m consider un fanatic al automatizrii, care triete mereu cu impresia c totul

poate fi automatizat. ns am reuit s descopr o prticic unde automatizarea este posibil i
este necesar. Sincer, nu cred c persoana care a completat acel fiier Excel n mod manual, a
fost ncntat de munca sa.
Am dezvoltat acest tool i deoarece consider c orice inginer, viitor inginer sau
programator, ar trebui tratat ca atare, iar o astfel de munc ar trebui ntotdeauna automatizat.

3. Algoritmi pentru detectarea funciilor existente
n acest capitol se vor prezenta la un nivel moderat de detaliere, algoritmii de baz

folosii pentru detectarea funciilor.
Algoritmul este noiunea fundamental a informaticii. Totul este construit n jurul
algoritmilor i a structurilor de date, cum ar fi listele sau grafurile. [8]
Tipurile de algoritmi folosite n cadrul proiectului sunt: tipul recursiv (face uz de sine
nsui n mod repetat) i tipul iterativ (repetitiv). Aceti algoritmi au fost construii specific
dup cerine.
Spunem c o noiune este definit recursiv, dac n definirea ei apare nsi noiunea
care se definete. [9]
Nivelul de complexitate este mediu, deoarece algoritmii construii recurg la operaii de
baz, cum ar fi: citire, scriere, comparare i manipulare de text. Asupra vitezei acestor
algoritmi nu s-a acionat foarte mult, deoarece timpul necesar generrii analizei este mult mai
scurt, chiar i dac algoritmii folosii ar fi mai ncei (indiferent dac este vorba de un proiect
de amploare mare: mii de fiiere, sau un proiect mic: zeci sau sute). ns s-a cutat mereu ca
procesul de detecie al funciilor s se realizeze printr-un numr minim de operaii.
Ca o scurt introducere, o s prezint modul iniial n care s-a gndit abordarea
problemei. Pentru procesul detectrii i extragerii numelui funciei dintr-o linie de text stocat
ntr-un string f, este necesar ca linia s conin caracterul ( .Caracterul ) poate s existe pe
liniile urmtoare, dac funcia are parametrii definii pe mai multe linii de cod, datorit
numrului mare al acestora). Pe lng aceasta, este necesar ca n antecedentul caracterului (
s se situeze un cuvnt care s difere de cuvintele folosite ca i expresii de baz (cum ar fi
while, if, for) n limbajul C i limbajele derivate din acesta.
Trebuie aflate funciile folosite, apoi unde sunt ele definite, n urmtoarea manier:
Se gsete linia care conine ( i se verific s nu fie naintea caracterului cuvinte de
baz ale limbajului (de ex. while, if, for, switch).
ns dup cum tim, o funcie se poate apela i n interiorul corpului while, aa c, dac
este gsit un cuvnt instruciune (while, if, etc), nu trebuie s trecem la linia urmtoare, ci s
verificm dac n corpul acesteia se folosete o funcie. Aceast verificare se poate face prin
substringuri ale irului iniial, care i au limitele ntre indecii parantezelor.
Ei bine, procesul pare destul de complicat cnd l punem n practic, deoarece genereaz
rezultate eronate. Pot exista multe cazuri n care caracterul ( s fie implicat fr ca s fie
folosit o funcie. Cum ar fi interiorul condiiilor while sau if, cnd parantezele definesc
ordinea de execuie a operaiilor. Deci trebuie s avem grij i la semne (ex: +, -, &&,
||).
Dup gsirea unui nume de funcie, trebuie cutat unde anume este funcia definit.
n locul acestui mod de cutare miglos, care necesit mult precauie, deoarece
trebuie s acopere toate celelalte cazuri n care parantezele sunt implicate, vom afla mai nti
numele funciilor definite, dup care le vom cuta pe fiecare n toate liniile.
Este abordat o manier mai logic din punct de vedere constructiv, anume maniera
invers, exemplificat n continuare:
Pasul 1: nti se gsesc toate funciile declarate. Acestea se stocheaz ntr-un tablou care
memoreaz numele funciilor i fiierul din care fac parte.
Cap. 3 Algoritmi pentru detectarea funciilor existente 13

Pasul 2: Dup aceasta, se parcurge din nou folderul, fiier cu fiier. Fiecare linie este
verificat dac folosete una sau mai multe dintre funciile stocate precedent n tablou.
n continuare prezentm n detaliu modul n care algoritmii construii acioneaz pentru
realizarea pailor prezentai mai sus.
3.1. Algoritmul de detectare a funciilor declarate
Acest algoritm este unul iterativ, deoarece parcurge liniile fiierului i le compar ntr-
un mod repetitiv cu diferite cuvinte specifice, apoi le supune repetitiv unor algoritmi
secundari ce lucreaz cu liste, cuvinte i caractere.
Adevrata sarcin, este de fapt detectarea funciilor declarate. Algoritmul de detectare al
acestora este structurat pe trei niveluri:
Primul nivel : Detectarea tipurilor de date.
Orice funcie definit este de un anumit tip. ns tim c pe lng tipurile de date
definite standard (int, char), se pot defini structuri, iar acestea pot fi folosite n
definirea funciilor.
Al doilea nivel: Detectarea tuturor funciilor definite.
Funciile sunt detectate prin verificarea existenei caracterului ( i verificarea
existenei la nceputul liniei text, a tipurilor de date, inclusiv cele definite prin
structuri.
Al treilea nivel: Detectarea tuturor macrourilor.
Aceasta se face din nou prin verificarea liniei: dac ncepe cu #define i dac
ea conine caracterul (. La acest nivel se mai realizeaz o analiz: verificarea dac
funciile definite n macrouri redenumesc sau folosesc alte funcii deja definite.
Verificarea se realizeaz recursiv, pentru a ne asigura c sunt gsite toate funciile.
Lund n considerare cele de mai sus, observm c algoritmul de cutare a funciilor
definite, la rndul lui se folosete de rspunsul algoritmului de cutare a structurilor de date,
ct i de ali algoritmi folosii pentru prelucrarea liniilor (eliminarea din linie a comentariilor,
a parantezelor sau ce se afl ntre ele, a spaiilor goale). Datorit interconectrii ntre
algoritmi, i vom structura ca algoritmi de baz i algoritmi secundari. Algoritmii secundari
folosii de algoritmul de detectare a funciilor declarate sunt detaliai pe scurt n urmtoarele
subcapitole.
3.1.1. Algoritmul de detectare a structurilor

Acest algoritm lucreaz cu cuvinte cum ar typedef, struct, i enum. El se folosete
de modul de declarare specific pentru structuri, pentru a extrage numele ei.
Algoritmul detecteaz toate structurile definite n cadrul unui anumit proiect, i le
stocheaz ntr-o list de string-uri.
Modul n care aceast detecie se realizeaz la nivel mediu, se poate explica simplu:
Acesta detecteaz liniile care ncep cu cuvintele specifice definirii unei structuri, dup
care, n cazul existenei acoladei deschise {, citete linii din fiier pn la gsirea acoladei
nchise }, urmnd s extrag cuvntul care precede acest semn.
Ei bine, la fel ca i n dezvoltarea celorlali algoritmi, i acesta se lovete de anumite
probleme, care necesit o nou abordare. Cum ar fi folosirea acoladelor n interiorul definirii
structurii. Despre rezolvarea acestor probleme, se vorbete detaliat n capitolele urmtoare.
14 Cap. 3 Algoritmi pentru detectarea funciilor existente

3.1.2. Algoritmul de detectare a funciilor

Dup gsirea structurilor definite, se poate realiza cutarea funciilor. Aceast cutare se
realizeaz prin compararea liniilor de text cu cuvintele specifice structurilor definite, ct i a
cuvintelor de baz folosite n C pentru definirea tipurilor de date.
Pentru a realiza compararea, algoritmul verific nti existena parantezelor rotunde,
dup care separ linia n cuvinte. Atta timp ct cuvntul de la nceputul liniei coincide cu un
tip de date sau structur, este citit urmtorul. Cnd se ajunge la un cuvnt care nu aparine
listei de tipuri, acesta este stocat ca fiind numele funciei ntr-un tabel.
Expresii regulate (Regex)
Pentru gsirea funciilor n liniile de text ale fiierelor, acest algoritm folosete anumite
abloane de cutare.
Dup cum am nvat la materia Sisteme de Operare, abloanele de cutare sunt
definite de ctre un ir de caractere. Aceste iruri se numesc expresii regulate.
Ele sunt folosite de motoarele de cutare, de dialogurile de cutare i inlocuire ale
editoarelor de text, de utilitarele de prelucrare a textului i n analiza lexical. Majoritatea
limbajelor de programare permit accesul la aceste expresii regulate, fie built-in fie prin
intermediul anumitor biblioteci.
Expresiile regulate i au originea n 1956, cnd matematicianul Stephen Cole
Kleene a descris limbajele regulate cu ajutorul notaiei sale matematice numit
mulimi regulate. [10]
Astfel de expresii regulate am folosit i eu, de exemplu pentru eliminarea coninutului
dintre paranteze, ns pe parcurs am renunat la folosirea expresiilor regulate, deoarece am
ntmpinat probleme pe care am reuit s le abordez mai simplu cu metodele obiectelor de tip
string.
Exemplificm tipul de expresie regulat folosit n proiect:
Regex yourRegex = new Regex(@"\(([^\}]+)\)");
Aceast expresie extrage coninutul dintre paranteze.
3.1.3. Algoritmul de detectare a macrourilor

Ca i algoritmul antecedent, acesta opereaz tot cu string-uri i caut pe fiecare linie a
fiierelor existena cuvntului cheie #define; algoritmul detecteaz de asemenea i situaiile
n care exist spaiu ntre # i define. Acesta verific existena parantezelor i n caz
afirmativ extrage, printr-un proces explicat n detaliu mai trziu, numele funciilor definite.
Acest algoritm are un grad de complexitate mai ridicat, deoarece n afar de cutarea
macrourilor, el le i compar pe acestea cu funciile deja declarate. Deoarece pot exista cazuri
n care un anumit macrou s redefineasc o funcie, dac se ntmpl aceasta, pentru
verificarea apartenenei la modulul de fiiere, va trebui verificat dac cea original este
definit ntr-un fiier din cadrul modulului i nu cea redefinit.
De asemenea, n cazul n care macroul definete o funcie care se folosete de alte
funcii i acele funcii trebuie trecute ca fiind folosite i verificate dac aparin modulului de
fiiere.
n caz contrar, macroul este stocat n tabelul de funcii definite ca i funcie
independent, care nu are legtur cu altele.

Img 3-1: Reprezentarea tabelului Excel ce conine funciile declarate
n imaginea de mai sus, este prezentat coninutul tabelului de Funcii declarate. Coloana
A, spune dac funcia a fost definit ca macrou, n coloana B stocm numele funciei, n
coloana C, locul unde a fost declarat, n D informm dac aparine sau nu modulului, iar
coloana E este completat doar n cazul redefinirii unei alte funcii.
S-a luat aceast imagine c exemplu, pentru a arata c pot exista foarte multe funcii
care s redefineasc altele.
De asemenea, dac o funcie a fost redefinit, pot exista cazuri n care i numele funciei
redefinite s fie din nou redefinit. De aceea, dup parcurgerea ntregului folder, atta timp ct
s-au descoperit funcii redefinite, algoritmul se apeleaz recursiv pentru a verifica dac acele
funcii sunt din nou redefinite sau folosite altundeva.
Avem nevoie s reinem aceste informaii despre redefinire sau folosire n tabelul de
funcii, deoarece ele ne vor spune legturile dintre funcii i vor fi folositoare n detecia
funciilor folosite n fiierele din modulul cerut.
3.2. Algoritmul de cutare a funciilor folosite:
Dup parcurgerea algoritmului de detectare a funciilor definite, urmeaz algoritmul de

detectare a funciilor folosite, care, n acest caz, este destul de simplu, deoarece deja se cunosc
toate funciile declarate, definite i redefinite.
Tot ce trebuie acesta s fac este s parcurg fiecare linie din fiiere i s o compare cu
elementele din tabelul de funcii definite. Singurul lucru care trebuie luat n vedere este ca
linia s nu conin la nceputul acesteia cuvinte care s reprezinte tipuri de date (tipuri definite
prin structuri, int, float, etc). Adic cutarea funciilor folosite trebuie s evite linia unde
acestea sunt declarate.
Deci pentru gsirea funciilor, algoritmul execut urmtoarele:
n primul rnd, parcurge linie cu line, verificnd existena caracterului (.
n al doilea rnd, nceputul liniei nu trebuie s conin cuvintele specifice
definirilor de funcii. Deoarece acum cutm unde sunt ele folosite.
16 Cap. 3 Algoritmi pentru detectarea funciilor existente

Dac linia respect aceste condiii, ea este analizat mai departe i comparat cu fiecare
nume de funcie stocat din tablou. n caz afirmativ este extras numele funciei folosite
(numele, ct i locul unde a fost definit), din tabelul Excel, dup care se stocheaz ntr-un alt
tabel numele fiierului care se verific, funcia care o folosete, numele acelei funcii i dac
aparine sau nu modulului de fiiere listat ntr-un alt tabel Excel ncrcat manual. Acestui
Excel i putem atribui numele de funciiFolosite.
Algoritmul verific informaiile puse la dispoziie de ctre algoritmul anterior. Anume
dac funcia este o redefinire a unei funcii, sau dac folosete o alt funcie. Acesta opereaz
n mare parte, pe lng citirea liniilor, cu operaii cu tabele. Deoarece toate informaiile au
fost stocate ntr-un anumit mod n Excel-ul de funciiDefinite (vom numi astfel primul tabel
Excel), putem extrage din el tot ce este necesar pentru completarea liniilor i coloanelor din
Excel-ul de funciiFolosite.
De aceea acest algoritm nu este att de amplu, ns la rndul lui se folosete de
algoritmii ce opereaz cu tabelele existente. Amintim fr s detaliem aceti algoritmi
secundari.
3.2.1 Algoritmi ce folosesc instruciuni de baz ale irurilor

Aici ne folosim de funciile obiectelor de tip string. Printre aceste funcii, pentru a
exemplifica, se numr: contains, equals, index of, substring.
Aceti algoritmi ndeplinesc urmtoarele:
Compar fiecare nume de funcie din tabel prin metoda Contains cu liniile fiierului.
3.2.2. Algoritmi ce folosesc instruciuni de baz ale tabelelor Excel

Aceti algoritmi extrag informaii folositoare din tabelul cu funciiDefinite, construind,
cu ajutorul algoritmilor ce lucreaz cu iruri, tabelul cu funciiFolosite.
Adic n funcie de interdependenele dintre funcii, stocheaz datele n tabel.
n codul de mai jos, este prezentat o parte din funcia care adaug numele funciei n
fiierul Excel final.
public void AddFunc(string text,int q){
worksheetB.Cells[count, 1] = new Cell(text);
//numele fiierului
worksheetB.Cells[count, 2] = new Cell(worksheetA.Cells[q, 1].ToString());
//numele funciei folosite
//apartine sau nu

4. Descrierea general a sistemului AnalysisTool

MM
Materialul acestui capitol descrie la nivel de arhitectura, aplicaia AnalysisTool,
dezvoltata n cadrul proiectului.
n urmtoarele pagini, se va prezenta structura proiectului prin scheme bloc cat i prin
legturile dintre ele. De asemenea, voi enumera toate funciile folosite de ctre fiecare clas,
ct i comunicarea dintre acestea ns fr s intru n detaliu, modul de funcionare al lor fiind
explicat n capitolul urmtor.
n nceputul proiectului, nu am luat n calcul toate elementele, i m-am gndit, ca un

novice ce sunt, c acest Tool de extragere a funciilor folosite din anumite fiiere este ceva
uor de realizat, care nu necesit mult timp, i nu necesit definirea multor clase i funcii. Pe
parcursul proiectului, mi-am dat seama de amploarea lui, i de numrul mare de instruciuni.
Pn la final am ajuns s construiesc un program, cu o singur clas de aproape 2000 de linii,
n care se petrecea toat aciunea. Aceasta coninea patru mari funcii: funcia de gsire a
structurilor, a macrourilor, a funciilor definite, i a celor folosite. Interiorul acestor funcii era
foarte voluminos, coninnd i multe buci de code duplication.
n programarea orientat pe obiect, dup cum am nvat la materia de Calitate i
Evoluie Software este pus mare accent pe concepte cum ar fi god class sau code
duplication, i evitarea lor, iar faptul c programul funciona printr-o singur mare clas,
acestea executnd operaii extrem de multe, m-a fcut s regndesc structura lui i s mpart
operaiile, ct i variabilele n mod echilibrat, n urmtorul mod:
Pentru modularizarea structurii proiectului, am mprit totul n 6 clase, ca i n figura
urmtoare.
Img 4-1: Legtura dintre clasele proiectului

Astfel totul pornete de la clasa principal funcionFinder. Aceast clas se folosete de

celelalte clase pentru crea i salva fiierele Excel care conin funciile definite i funciile
folosite. Totodat, ea rspunde aciunilor realizate de ctre utilizator prin apsarea diferitelor
butoane din interfa. Dar nainte s intrm n aceste detalii, vom prezenta procesul de baz al
programului.
Dac privim imaginea de la dreapta la stnga, ea respect ordinea crerii obiectelor de

tip clase definite.
n primul rnd, n clasa funcionFinder se creeaz un obiect denumit StructClass
(numele face referire la operaia care ii este asignat clasei). Aceast clas are ca scop
detectarea tuturor structurilor dintr-un proiect (path-ul proiectului fiind cunoscut n clasa
principal i trimis ca parametru clasei StructClass), iar un obiect de acest tip este creeat
automat la selectarea caii de proiect.
Dup acest proces, din obiectul de tip StructClass, se pot extrage informaiile despre
structuri intr-un vector de iruri;
n pasul urmtor, dup ce se cunosc toate structurile definite, clasa funcionFinder
creeaz un obiect de tipul funcionClass. Acest obiect se ocup cu detectarea tuturor
funciilor declarate, i o face prin intermediul anumitor funcii, cat i prin intermediul datelor
obiectului de tip MacroClass, cu ajutorul cruia se completeaz variabila comun de tip
Worksheet cu numele funciilor, i legturile dintre acestea. (aceast variabil este un obiect
care aparine bibliotecii ExcelLibrary)
Obiectul de tip Worksheet al claselor este de tip public, astfel dup ce obiectele de tip
funcionClass i MacroClass i finalizeaz operaiunea de parcurgere a folderului i de
analizare i extragere a funciilor din fiiere, putem accesa cmpul Worksheet din clasa
principal funcionFinder.
De aici cu ajutorul interfeei tool-ului, putem genera fiierul Excel construit, sau putem
cauta direct funciile folosite, deoarece Worksheet-ul rmne stocat n memorie pe perioada
rulrii programului.
Ultima parte o reprezint gsirea funciilor folosite. De aceasta se ocup clasa
UsedFunc, care preia obiectul Worksheet-ul dezvoltat anterior, i cu ajutorul lui i al
metodelor din interiorul clasei, completeaz un nou obiect Worksheet, care din nou poate fii
accesat din clasa principal , i de asemenea salvat.
n continuare se va prezenta interiorul fiecrei clase, adic variabilele acesteia, metodele

ei, ns nu i modul n care ele realizeaz task-ul care le este dat, ci doar modul n care
comunic intre ele. Numele metodelor este reprezentativ, iar scopul acestora este uor de
neles.
4.1. Arhitectura clasei funcionFinder
n aceste subcapitole se va prezenta arhitectura fiecrei clase n parte. Clasa principal,

funcionFinder, este foarte ampl cnd vine vorba de numrul funciilor, deoarece interfaa
cu utilizatorul folosete multe butoane, textbox-uri, listbox-uri, ct i diferite label-uri (casete
de text, liste de cuvinte, respectiv etichete). De aceea n imaginea urmtoare nu am putut
ncadra toate funciile de rspuns ale butoanelor.
20 Cap. 4 Descrierea general a sistemului AnalysisTool

Pentru simplitate, n prezentarea metodelor claselor din aceste subcapitole, se va folosi

numele lor, dar nu se va specifica, dect prin schemele bloc, care sunt parametrii acestora.
Metodele sunt prezentate mai detaliat, cu instructiuni de cod, n capitolele urmtoare.
Img 4-2: Unele dintre metodele i variabilele clasei principale

n aceast clas, obiectele button, i funciile butttonX_Click, sunt generate automat de
ctre programul Visual Studio, prin interfaa grafic care permite utilizatorului s o
construiasc fr s fie necesar de a scrie cod.
n continuare prezentm fiecare buton i scopul care l ndeplinete. De asemenea
adugm pe aceast pagin imaginea cu interfaa programului, pentru o nelegere mai uoar
a aciunii butoanelor, prin modul n care sunt poziionate.
Aceast funcie se ocup n special cu interfaa operrii cu utilizatorul.
Img 4-3: Imagine de ansamblu a tool-ului
1. Butonul Alege Folder

private void button1_Click(object sender, EventArgs e) Alege Folder
Cap. 4 Descrierea general a sistemului AnalysisTool 21

Butonul este primul de sus, cu indexul 1 n dreptul lui,

Cnd acest buton este apsat, se apeleaz metoda button1_Click unde se creeaz un
obiect de tip FolderBrowserDialog care permite stocarea ntr-un string a unui path prin
intermediul interfeei redate de ctre acest tip de obiect.
Img 4-4: Imagine cu exemplu de interfa familiar a clasei FolderBrowserDialog
De asemenea, tot n aceast metod se creeaz obiectul de tip StructClass, care

analizeaz fiecare fiier din path-ul ales i caut structuri definite, folosindu-se de metodele
clasei.
2. Butonul Adaug Excel cu fiierele ce trebuie procesate

Acest buton creeaz un obiect de tip OpenFileDialogue, care permite memorarea ntr-
un string a numelui fiierului Excel ce urmeaz s fie prelucrat. n acest fiier Excel se afl
lista cu numele fiierelor ce trebuie analizate. Altfel zis, informaiile despre componentele
modulului.
3. Butonul Gsete Funcii Definite

Aici se creeaz un obiect de tip funcionClass, iar prin intermediul unui nou thread, se
apeleaz metoda din interiorul acestei clase, care caut funciile folosite. Threading-ul este
folosit deoarece n cazul operrii pe acelai thread, interfaa se blocheaz i devine
inaccesibil pn la finalizarea operaiei de cutare.
4. Butonul Salvare Funcii Definite

n cazul acestui buton, obiectul de tip Worksheet al clasei principale este
echivalat cu worksheet-ul obiectului de tip funcionClass, prin simpla operaie
worksheetA = funcii.worksheetA;
Acest worksheetA este adugat ntr-un fiier Excel de tip Workbook.

Dup care este creat un obiect de tip SaveFileDialogue, care folosind un path ales de
utilizator prin interfaa obiectului, salveaz fiierul Excel cu funciile definite.
5. Butonul Adaug fiier Excel cu funcii definite

n cazul n care s-a generat deja anterior un fiier Excel cu funciile definite, i asupra
proiectului nu s-au efectuat modificri la definirile de funcii, atunci se poate ncrca vechiul
Excel, i preluate direct toate funciile, fr s mai fie necesar cutarea acestora n folder.
Aceast opiune a fost introdus deoarece procesul de detectare a tuturor funciilor n cadrul
proiectului la care lucram, era ndelungat. Iar n cazul modificrii clasei care gsete funciile
folosite, trebuia mereu procesat din nou tot folderul pentru a se gsi funciile definite, lucru
nenecesar.
6. Butonul Gsete funcii folosite

Acest buton, dup cum ii spune i numele, are ca scop gsirea funciilor folosite. Pentru
aceasta iniializeaz un obiect de tip UsedFuncClass cu parametrii urmtori
usedfunc=new UsedFuncClass(worksheetA,file,i,director);
Acest obiect are nevoie de worksheetul cu funciile declarate, denumit i worksheetA,

mai are nevoie de stringul file care i spune locaia fiierului Excel cu fiierele care trebuie
analizate, variabila i este de tip int i memoreaz dimensiunea Excel-ului, iar stringul director
indica locaia unde trebuie cutate funciile.
Dup aceasta, folosind un nou thread, apelm metoda de gsire a funciilor folosite
dinluntrul clasei. Aceast metod, precum i celelalte, vor fi detaliate n capitolul urmtor.
7. Butonul Salveaz Excel funcii folosite
Ultimul buton are ca scop la fel ca i butonul de Salvare Excel funcii definite, de a
aduga worksheetul generat de ctre obiectul de tip UsedFuncClass n obiectul
funcionFinder. Worksheetul este numit worksheetB, i dup egalare, este adugat n fiierul
Excel WorkbookB, care este salvat folosind un obiect de tip SaveFileDialogue ntr-un path
selectat de ctre utilizator.
8. Butonul Caut Text
Dup cum i spune i numele, acest buton are ca scop gsirea tuturor liniilor unde un
anumit cuvnt introdus de la tastatur exist.
El se folosete de stringul introdus n textbox-ul alturat, pentru a afia n listbox-ul de
deasupra, numele fiierului, numele liniei ct i lina n sine unde exist acest cuvnt.
Aceast interfa a fost adugat pe parcursul dezvoltrii proiectului. Deoarece existau
funcii pe care tool-ul nu le identifica, a fost nevoie s aflu exact unde numele lor apare. Cu
ajutorul interfeei am descoperit c ele sunt redefinite de ctre macrouri, de aceea nu sunt
gsite.
Am pstrat n continuare modulul de cutare a cuvintelor (fraze), gndindu-m c poate
fi de folos i altor persoane dac m-a ajutat n astfel de probleme.

Img. 4-6 Cutarea unor cuvinte specifice intr-un folder
4.2. Arhitectura clasei StructFinder
Aceast clas opereaz cu iruri de caractere, i are ca scop extragerea tuturor

structurilor definite dintr-un proiect, sau un ansamblu de proiecte. Extragerea se realizeaz cu
ajutorul anumitor funcii care comunica unele cu celelalte. Legturile i numele acestor funcii
sunt exemplificate prin diagrama de dependenta a clasei din figura urmtoare.
Img. 4-8 Metodele i legturile dintre ele ale clasei StructFinder
Nu se va intra n detaliu despre modul n care fiecare funcie a fost definit, ns n

continuare vom explica scopul metodelor existente i modul n care acestea comunic unele
cu altele.
Metoda init_tipuri, dup cum i spune i numele, iniializeaz ntr-un vector de cuvinte,
tipurile de baz pe care le regsim n limbajul C.

Metoda StructFinder primete un string ca parametrul. Acesta reprezint locaia

directorului de cutare. Metoda parcurge folderul, i trimite pe rnd metodei
GetStructFromFile numele fiierelor.
Metoda GetStructFromFile reprezint metoda principala, deoarece ea manevreaz

liniile de text din nuntrul fiierului.
Ea face apel la urmtoarele metode:
Metodele CommentFiltre i CommentFiltre2 care primesc ca i parametru

un string i l returneaz fr comentarii de tip // , respectiv /*
Metoda LineContainStruct verifica dac linia definete o structur. n caz

afirmativ, metoda GetStructFromFile trece la urmtorul pas i apeleaz
Metoda AddStructName
Aceast metod, foarte important, determin modul n care este definit
structura, pentru a ti cum s caute cuvntul cheie care definete un nou tip de date.
Adic, o structur se poate defini cu acolade sau nu, sau se poate defini pe mai
multe rnduri. Toate aceste cazuri trebuie luate n considerare i fiecare tratat aparte.
Astfel n funcie de parametrul de tip boolean pe care l primete, ea va apela fie:
Metoda StructNameExtract aceasta se ocupa cu extragerea cuvntului

de pe linie n cazul n care aceasta conine acolade. Metoda apeleaz la
rndul ei Remove Characters
Fie doar Metoda RemoveCharacters, care elimin din numele tipului

caractere cum ar fi sau ; n cazul n care structura nu conine
acolade.
De asemenea, metoda AddStructName este suprascris fr nici un

parametru.
Ea este apelat atunci cnd structura definit se ntinde pe mai multe linii. n
acest caz, aciunea ei este asemntoare, ns apeleaz ambele metode precedente.
Adic StructNameExtract i RemoveCharacters.
Schema bloc a clasei este urmtoarea:

Img. 4-9 Diagrama UML a clasei
Aceast clas are ca parametrii dou variabile de tip int i de tip string. n
acestea dou se memoreaz numrul de tipuri gsite, relativ numele acestor tipuri.
Variabilele sunt de tip public deoarece ele sunt accesate de clasa principal
FindFunction
De asemenea, pentru exemplu, metoda StructFinder este public deoarece ea
este rulat pe un thread din clasa FindFunction.
Metodele care se ocup cu adugarea structurilor n vectorul de cuvinte sunt
private, deoarece dac ar fi apelate din exteriorul clasei, ar genera erori.

De precizat un detaliu minor, cnd obiectul StructClass apeleaz metoda

StructFinder ce ia ca parametru directorul n care se caut structurile, aceasta creeaz
un obiect de tip LoadingForm, care este n esen o fereastr nou ce are ncorporat
n ea o bar de progres. Cu ajutorul acestui obiect calculeaz numrul de fiiere i
iniializeaz noua fereastr n funcie de acesta. Dup care pe msur ce analizeaz
fiierele, incrementeaz bara de progres.
4.3. Arhitectura clasei functionClass
n acest subcapitol se prezint subsistemele existente ale clasei functionClass, adic

metodele acestora, i modul n care sunt interconectate.
Aceast clas are legturi i cu alte clase definite n cadrul proiectului. Cum ar fi MacroClass
i LoadingForm. Legtura cu cele doua este prezentata la nivel de schema n figura
urmtoare.
Figura 4-10.Legturile dintre metodele clasei funcionClass.
n esen i aceast clas se aseamn cu cea prezentat nainte (StructClass), deoarece

are nevoie de un string care stabilete directorul asupra cruia se efectueaz cutarea.
Metoda DirSearch paseaz pe rnd metodei FindFunction fiierele existente n

locaia stabilit i pe msur ce progreseaz, afieaz acest lucru printr-un
LoadingForm.
Metoda FindFunction manipuleaz ntreaga aciune asupra extragerii
funciilor declarate dintr-un folder surs. Ea se folosete de metodele tere i cu

ajutorul acestora, preia numele funciilor definite. n continuare voi prezenta fiecare
metod apelat de ctre FindFunction i scopul acesteia.
Metoda Comment Filtre filtreaz seciunile de comentarii din
fiierele analizate. Ea nu se aseamn ns cu metodele prezentate n clasa
StructClass, deoarece scopul ei este s treac peste poriuni mari de cod, fr s le
analizeze, n cazul n care ele sunt comentate. Dei aceast metod nu pare foarte
important, ea a fost construit pentru a evita o eroare a tool-ului (rezultate eronate n
urma analizei liniilor de comentarii), ct i pentru a optimiza viteza de cutare.
Metoda RemoveEmptySpace are ca scop eliminarea
spaiilor goale care pot exista naintea declarrii unei funcii. Putem lua ca exemplu
acest proiect, unde funciile (metodele) sunt declarate ncepnd de la o distan de
cteva spaii fa de nceputul liniei, deoarece aparin unor clase.
Metoda RemoveSigns dup cum se traduce i numele, prelucreaz un

string i elimin semne cum ar fi ; pentru ca numele funciei s poat fi extras.
Metoda RemoveParanthesys a fost construit pentru a elimina de pe
linia citit, n cazul prezenei unei funcii, coninutul reprezentat de parametrii
funciei. Deoarece acetia de asemenea pot folosi paranteze rotunde, nu putem
elimina coninutul dintre paranteze indexnd prima apariie a parantezei
deschise ( i prima apariie a celei nchise ). Astfel a fost nevoie de
dezvoltarea unei metode care s analizeze i s elimine ntr-un mod iterativ
coninutul dintre paranteze.
Metoda RemoveFinalParanthesys are ca scop nlturarea parantezelor
finale, acestea au fost necesare n detectarea cuvntului care reprezint numele
funciei din linia citit. Aceast metod, la fel ca i antecedenta, au fost
construite i ca msur de precauie n cazul n care cutarea structurilor
genereaz erori. Astfel evitndu-se posibilitatea de a se prelua un cuvnt ca fiind
nume de funcie, cnd el este de fapt nume de structur, deoarece nu conine
caracterele ().

4-11: Blocul clasei funcionClass
Cele dou metode funcionClass reprezint constructorii clasei, primul are rolul
de a iniializa parametrii ei, anume variabila int (ntreag) i, care reprezint
dimensiunea tabelului Excel n care sunt stocate funciile, acesta fiind reprezentat
prin variabila Worksheet (tabel Excel) worksheetA. Al doilea constructor iniializeaz
variabilele cu valori fixe.
Dup ce metoda FindFunction parcurge, analizeaz i extrage funciile din
ntregul folder, ea creeaz un obiect de tip MacroClass, care are o utilitate important
deoarece se ocup cu extragerea funciilor definite sub form de macrouri. Aceast
clas este prezentat n subcapitolul urmtor i alctuiete mpreun cu primele dou
clase: StructClass i FunctionClass, sistemul complet de detectare al funciilor
declarate, deoarece pentru o bun analiz static a dependenelor ntre fiierele
sistemului, trebuie s avem n vedere aceste dou aspecte: ce tip poate fi funcia n
cadrul proiectului i sub ce nume este ea redefinit sau folosit n definiri de
macrouri.
4.4. Arhitectura clasei MacroClass
Aceast clas are ca scop detectarea tuturor funciilor care au fost definite cu ajutorul
macrourilor. Ea are o importanta majora n analiza dependentelor intre fiierele unui proiect,
deoarece prin redefiniri de funcii, s poate crea confuzie, i rezultate eronate n cazul n care
acestea nu sunt luate n calcul. Astfel un obiect de tip MacroClass se folosete de informaiile
aduse de ctre obiectul FunctionClass, comparnd modul n care macrourile sunt definite, cu
funciile descoperite pn acum. Pentru analiza corecta a proiectelor, metoda principal de
gsire a macroului a avut nevoie de o implementare de tip recursiv, ce satisface condiia ca
atta timp cat se gsesc macrouri ce redefinesc funcii, metoda s se apeleze din nou, i s
caute dac acele macrouri sunt la rndul lor redefinite.

Ca exemplu de necesitate a implementrii unei astfel de clase, pentru proiectul asupra

cruia s-a fcut analiza, au existat 3 nivele de redefiniri.
Img. 4-12 Metodele si legturile dintre ele ale clasei MacroClass
Clasa are n corpul ei patru variabile, dintre care trei sunt necesare pentru
gsirea macrourilor. Anume
Variabila string director, care reprezint locaia de cutare,
Variabila de tip tabel, worksheetA, care deine tabelul cu toate funciile
definite
Variabila de tip ntreg i, care reprezint mrimea.
Variabila tura are ca scop memorarea ciclurilor de recursivitate efectuate,
n scop de analiz.
Variabilele sunt iniializate prin apelul metodei constructor, MacroClass.
Metoda Macrofinder este metoda principal care se apeleaz recursiv. Aceasta

analizeaz att directorul, ct i coninutul fiierelor din el. Analizeaz liniile i caut
definiri de macro-uri. n acest sens ea are grij la macro-uri definite pe mai multe
linii i macro-uri care folosesc funcii. Pe baza acestei analize, apeleaz metoda
AddMacro.
Metoda AddMacro mparte macro-urile n trei categorii:
Macro-uri care redefinesc funcii
Macro-uri care folosesc funcii
Macro-uri care doar definesc funcii
n urma structurrii, metoda decide care din metodele FindDefinedFunct,

FindRedefinedMacro le va folosi pentru extragerea macro-ului.
Metoda FindDefinedFunct este metoda cea mai simpl, ea este apelat
dac macro-ul nu se folosete de nici o alt funcie definit.

Metoda FindRedefinedMacro este metoda apelat n cazul n care

macro-ul redefinete sau conine o funcie declarat. Ea tie s fac diferena dintre acestea
dou printr-o variabil de tip boolean, iar n cazul n care cuvntul pe care macro-ul l
definete este egal cu numele unei funcii, acea variabil este true, iar metoda stocheaz
numele funciei redefinite pe o coloan. n cazul n care variabila este false, nseamn c
macro-ul doar conine acea funcie, iar numele acesteia este stocat pe o alt coloan dect cea
dinainte. Stocarea funciilor se face cu ajutorul metodei AddDefineToExcel care opereaz cu
tabelul Excel al clasei.
Img 4-13 Reprezentarea bloc a clasei MacroClass
Atributele clasei sunt de tip public deoarece acestea trebuie accesate de ctre
clasa funcionClass, n special worksheetA i variabila ntreag i. Deoarece acestea
acum conin noi informaii n urma analizei macro-urilor.
Cnd obiectele funcionClass i MacroClass i-au finalizat cutarea, obiectul
principal funcionFinder extrage informaia tabelului Excel i o pune la dispoziie
prin salvarea tabelului sub form de fiier Excel ntr-o locaie stabilit de utilizator
prin interfaa clasei.
De asemenea, ca i n cazul arhitecturii clasei StructClass, ea creeaz prin
metoda principal un nou LoadingForm care s afieze progresul analizei, n funcie
de numrul de fiiere pe care le-a analizat.
Img 4-14: Fereastra de ncrcare

4.5. Arhitectura clasei UsedFuncClass
Numele acestei clase provine de la prescurtarea cuvintelor used funcions i reprezint

scopul pe care l ndeplinete un obiect de acest tip. Anume acela de a gsi n anumite fiiere,
(specificate printr-un Excel care trebuie adugat prin interfa), funciile care sunt folosite. El
se folosete de tabelul cu funciile declarate n cadrul proiectului, iar maniera n care le caut
este foarte simpl, realizndu-se o comparare a fiecrei linii, cu fiecare funcie existent. n
cazul n care o funcie este gsit, ea este trecut ntr-o nou foaie de lucru (Worksheet),
worksheetB. Acest worksheet va conine informaia tuturor funciilor folosite n cadrul
fiierelor asupra crora utilizatorul vrea s obin analiza modulelor proiectului.
Clasa principal functionFinder creeaz un obiect de acest tip dup ce Excel-ul
cu funciile definite a fost completat. Dup ce execut funcia de cutare a acestuia
printr-un thread, preia informaia extras de ctre obiectul UsedFuncClass i o pune
la dispoziia utilizatorului sub form de fiier Excel, care conine o list cu fiierele
asupra crora s-a cerut analiza, funciile care le folosesc, ct i locul unde acestea sunt
definite.
Datorit dimensiunii mari a unei astfel de clase (numrul mare de metode i
atribute) care trebuie s foloseasc toate rezultatele obinute anterior de ctre
program, reprezentarea grafic ocup loc destul.
Img 4-15: Legturile metodelor clasei UsedFunctionClass reprezentate grafic
Aceast clas poate prea destul de complicat, datorit numrului mare de

metode, ns n mare parte, n afar de citirea din fiiere a liniilor, opereaz cu tabelele
Excel. Cutarea funciilor se face pe baza tabelului deja existent, iar din momentul n

care o funcie a fost gsit, se efectueaz o pasare din tabelul cu funcii definite n
tabelul cu funcii folosite, n funcie de tipul ei.
Tipul funciei n acest context depinde de:

dac este o funcie declarat
dac este o funcie definit
dac redefinete o funcie
dac o funcie definit folosete o alt funcie.
Iar aceste informaii se cunosc, pe baza tabelului cu funcii
Imaginea de mai jos are ca scop crearea unei vizualizri mai bune a modului n
care un obiect de tip UsedFunctionClass interacioneaz cu tabelul de funcii definite.
Img 4-16: Exemplu de poriune a tabelului cu funciile folosite
Am inclus i prezentarea tabelului n acest capitol, deoarece el se bazeaz pe arhitectura

tabelului de funcii declarate i extrage informaiile pe baza anumitor cmpuri completate la
fiecare linie.
n imaginea de mai sus, a doua coloana (B) este completat cu numele funciilor gsite,
iar a treia (C) este completat cu informaia despre locaia unde acestea au fost definite.
Restul coloanelor informeaz programul dac:
(Coloana D): Face parte din modulul de fiiere asupra cruia se dorete analiza
(Coloana E): funcia este o redefinire a unei alte funcii
(Coloana F): funcia este definit ca macro i folosete alte funcii
Prima coloan indic dac funcia este definit ca macro i nu folosete nici o alt
funcie.
Pe baza acestor informaii, obiectul de tip UsedFuncClass stocheaz n noul tabel ce
conine funciile folosite (worksheet 2),

Modul n care realizeaz stocarea este prezentat la nivel de comunicare ntre metodele
clasei, ca i n subcapitolele anterioare. Metodele din aceast clas se apeleaz n lan, iar
modul n care acestea sunt legate este prezentat n continuare:
Metoda funciifolosite extrage numele fiierelor ce trebuie

procesate (din tabelul introdus de utilizator) i apeleaz n continuare
metoda FindFile.
Metoda FindFile caut numele fiierului n folderul sursa. n
cazul n care gsete fiierul respectiv, apeleaz metoda AnalizeFile. n
caz contrar, apeleaz metoda AddUnfound
Metoda AnalizeFile caut liniile care conin caracterul
( specific definirii funciilor, i n caz afirmativ, linia s nu nceap cu
cuvinte cheie specifice tipurilor de funcii. Ea este definit pentru a mri
viteza de procesare a fiierelor, srind peste liniile care nu conin paranteze
rotunde. Ctigul din punct de vedere al vitezei va fi neles prin metoda
urmtoare, pe care aceasta metoda o apeleaz n cazul n care gsete o
astfel de linie. Se apeleaz metoda CheckForFunctions.
Metoda CheckForFunctions compar fiecare
linie cu fiecare funcie din tabelul de funcii definite i n cazul n care
gsete o anumit funcie, apeleaz metoda AddUsedFuncToExcel
Metoda AddUsedFuncToExcel analizeaz
pe baza coloanelor completate (coloanele D sau E) a funciei gsite n
tabel, ce metod s apeleze n continuare. Aceste metode sunt:
1. Metoda AddFunc n cazul n care funcia nu depinde de
alte funcii. Aceast metod adaug n fiierul Excel numele
fiierului analizat, numele funciei, numele fiierului unde
funcia a fost definit i dac aparine modulului.
2. Metoda AddRedefinedFunc - n cazul n care funcia este o
redefinire a unei alte funcii, se apeleaz aceast metod. Ea
completeaz tabelul Excel ca i metoda precedent, ns
folosete numele funciei originale i locaia definirii acesteia.
3. Metoda AddFuncAndUsingFunc n cazul n care funcia
definit folosete alte funcii, se apeleaz aceast metod,
care adaug att funcia definit prin metoda AddFunc, ct i
funcia care o folosete, prin metoda AddRedefinedFunc.

Img. 4-16 Reprezentarea bloc a clasei UsedFuncClass

5. Proiectarea i implementarea sistemului de analiz
Clasa FunctionFinder
ncepnd cu acest capitol, lucrarea descrie modul de abordare al problemelor ntlnite,

explicnd prin poriuni de cod, implementarea diferitelor funcii eseniale n analiza
proiectelor. Vorbim n cadrul acestei lucrri, despre o analiz a dependenelor ntre fiiere.
Interfaa programului a fost construit prin modulul de design al IDE-ului Visual Studio.
Clasa functionFinder reprezint clasa principal a proiectului. Ea stabilete procesele
urmtoare n funcie de interaciunile utilizatorului cu interfaa pus la dispoziie.
n primul rnd trebuie specificat ca ea se folosete de dou biblioteci care permit

operarea cu tabele Excel.
i anume:
using ExcelLibrary.SpreadSheet;
Care opereaz cu fiiere Excel de format .xls

using OfficeOpenXml;
Care opereaz cu fiiere Excel de format .xlsx

Ct i biblioteca care permite folosirea thread-urilor
using System.Threading;
n continuare voi prezenta atributele acestei clase.

Ea opereaz cu tabele Excel. Are nevoie de dou tabele, dup cum s-a
explicat n decursul lucrrii, n care s fie stocate n primul, funciile definite dintr-
un proiect, iar n al doilea, funciile folosite de anumite programe din acel proiect.
Worksheet worksheetA = new Worksheet("FUNCTII DECLARATE");
Worksheet worksheetB = new Worksheet("FUNCTII FOLOSITE");
ct i de dou variabile de tip ntreg, n care s stocheze mrimile tabelelor

(numrul de linii).
int counter = 0;
//counter memoreaza cate elemente sunt n tabelul de funcii
int i = 2; // retine cate linii se afla n tabelul excel, cu
aceasta variabila opereaza aproape toate clasele
Trebuie s cunoatem calea ctre directorul n care vom executa cutarea, ct

i calea ctre fiierul Excel care conine numele fiierelor ce trebuie analizate,
astfel avem nevoie de urmtoarele atribute.
string director; //retine numele directorului n care se efectueaza

public string file; //pathul exelului incarcat
Cap. 5 Proiectarea i implementarea sistemului de analiz 37

Clasa public partial class FunctionnFinder : Form opereaz cu

obiecte a cror tip a fost prezentat n capitolele anterioare. Acestea sunt:
FunctionClass funcii; ///obiectul care gaseste funciile definite
UsedFuncClass usedfunc; ///obiectul care gaseste funciile folosite
De asemenea opereaz i cu obiectul de tip StructClass, ns acesta nu este

declarat ca atribut, iar n locul lui este preferat declararea unui vector de iruri de
caractere, n care s fie stocate toate tipurile de date gsite, ct i numrul lor.
string[] tipuri = new string[6000];
//opereaza cu clasa StructClass , contine numele structurilor
int tipc; //retine cate tipuri de date exista
Ultimele atribute sunt de tip binar

bool verifExcel=false; //retine dac a fost incarcat un excel cu
funcii definite
bool VerifLoadExcel = false; //verifica dac s-a incarcat un
fiier excel cu fiierele ce trebuie cautate
Se vor exemplifica n continuare, metodele acionate de butoane care

creeaz obiectele de tip StructClass, funcionClass, UsingFuncClas.
Prin apsarea butonului IntroducerePath acioneaz o metod care preia

informaia despre directorul ce urmeaz s fie analizat
FolderBrowserDialog fbd = new FolderBrowserDialog();
if (fbd.ShowDialog() == DialogResult.OK)
director = fbd.SelectedPath;
i creeaz un obiect de tip StructClass,

StructClass structuri = new StructClass();
structuri.init_tipuri();
cu ajutorul cruia analizeaz directorul selectat, prin metoda Structfinder(string s),

ce are ca parametru numele directorului. Metoda este apelata printr-un alt thread
dect cel principal, pentru ca interfaa s rmn nc accesibil utilizatorului.
Thread thread =new Thread(()=>structuri.Structfinder(director));
thread.Start();
Dup ce acesta i-a ncheiat procesul, atributele tipc i tipuri ale clasei sunt
iniializate.
while (thread.IsAlive)
{
}
tipc = structuri.tipc;
tipuri = structuri.tipuri;
38 Cap. 5 Proiectarea i implementarea sistemului de analiz

Butonul Gaseste funcii definite iniializeaz prin metoda constructor,

obiectul de tip funcionClass, pe nume funcii, dup care, la fel ca i n cazul
anterior, Este creat un nou thread, prin care se apeleaz metoda de cutare a
funciilor ntr-un anumit director. Observm c aceast metod ia ca i parametrii
inclusiv vectorul cu tipurile de date i numrul acestora.
funcii = new funcionClass(worksheetA, i);
Thread t1;
t1 = new Thread(() => funcii.DirSearch(director,tipuri,tipc));
t1.Start();
n cazul n care exist rezultate mai puine de 100, datorit limitei bibliotecii
Excel, nu putem genera un fiier Excel, de aceea trebuie iniializate primele 100 de
celule.
worksheetA = funcii.worksheetA;
i = funcii.i;
while (i < 110)
{
worksheetA.Cells[i, 1] = new Cell("");
i++;
}
De altfel i butonul Gsete funcii Folosite iniializeaz obiectul de tip

UsedFuncClass cu tabelul existent ce conine informaii despre funciile definite
(worksheetA), numrul acestora (i), locaia fiierului Excel ce conine lista cu
fiierele (file), directorul unde trebuie se execute cutarea (director).
private void button5_Click(object sender, EventArgs e)
{
usedfunc=new UsedFuncClass(worksheetA,file,i,director);
Thread t;
t = new Thread(()=>usedfunc.funciifolosite());
t.Start();
}
Salvarea fiierelor Excel se face prin butoanele de Salvare funcii definite

/Salvare funcii folosite. n continuare prezentm pe scurt o parte din coninutul
uneia dintre metodele de comand a acestor butoane:
Stream myStream;
SaveFileDialog saveFileDialog2 = new SaveFileDialog();
saveFileDialog2.Filter = "excel files (*.xls)|*.xls";
Se folosete de obiecte tip SaveFileDialog i restricioneaz formatul

fiierului la .xls
worksheetB = usedfunc.worksheetB;
workbookB.Worksheets.Add(worksheetB);
workbookB.Save(XLS2);
unde XLS2 reprezint o variabil de tip ir de caractere n care este memorat

locaia unde fiierul trebuie salvat.
n cazul n care apsm butonul de Adaug Excel cu funcii definite, tabelul

de funcii va fi egalat cu tabelul ncrcat de ctre utilizator,
Cap. 5 Proiectarea i implementarea sistemului de analiz 39

Workbook book = Workbook.Load(numeexcel);

var worksheet = book.Worksheets[0];
worksheetA = worksheet;
iar variabila binara v-a fi setata pe true
verifExcel = true;
n continuare se vor detalia la nivel de cod, clasele care fac posibil analiza
fiierelor. Capitolele 5, 6 i 7 sunt legate i explic n detaliu cum a fost programul construit,
ce greuti a ntmpinat acesta i modul n care le-a abordat.
40 Cap. 5 Proiectarea i implementarea sistemului de analiz

6. Preluarea funciilor
Capitolul este structurat pe trei subcapitole, care prezint pe rnd, fiecare tip al
obiectelor ce sunt necesare n descoperirea funciilor declarate, la nivel de cod, comparat cu
modul n care acesta a fost implementat i cum funcioneaz.
6.1. Clasa StructClass
Aceast clas se ocup cu gsirea tipurilor de date sub care funciile pot
fi definite. Modul de funcionare al obiectului de tip StructClass, adic metodele
definite, ct i atributele folosite se vor explica n detaliu prin poriuni de cod.
class StructClass
Atributele pe care clasa le are sunt declarate de tip public, deoarece

sunt accesate de ctre clasa principal. Ele sunt dou:
1. un vector de iruri de caractere, pe poziiile cruia sunt stocate
numele tipurilor de date existente, ct i cele create prin structur;
public string[] tipuri=new string[6000];
Mrimea acestui vector a fost setat cu o valoare aproximativ de dou

ori mai mare dect numrul maxim de tipuri gsit n proiectul analizat. Nu s-a
folosit alocarea dinamic.
2. o variabil de tip ntreg, n care se memoreaz numrul de tipuri
existente. Cu ajutorul ei adugm informaii n vectorul de string-uri
prezentat mai sus.
public int tipc;
Metodele clasei, n ordinea apelurilor, sunt prezentate n comparaie cu

seciuni de cod, mai jos.
StructFinder se folosete de parametrul tip string pe care l primete

cnd este apelat.
public void Structfinder(string sDir)
n corpul metodei se creeaz o fereastr de tip LoadingForm, care este

iniializat, folosindu-ne de metoda VerificaDimensiune a obiectului, care
calculeaz dimensiunea directorului, pe baza numrului fiierelor.
LoadingForm load = new LoadingForm();

load.InitialiseProgressBar(load.VerificaDimensiune(sDir));
load.Show();
n continuare se execut ntr-o manier try-catch parcurgerea folderului

i cutarea specific a fiierelor cu formate .c,.cpp,.cs,.h(n cazul n care
programul ntmpin o situaie necunoscut i genereaz o eroare, datorit
Cap. 6 Preluarea funciilor 41

blocului try-catch, putem afla care anume este fiierul n cauz. Iar de acolo
problema trebuie analizat i rezolvat).
try {...}
catch (System.Exception excpt)

{
Console.WriteLine(excpt.Message);
MessageBox.Show("Eroare la gasirea tipurilor de date.
\n fiierul cauza: "+NumeFisier);
}
n interiorul corpului try, parcurgerea fiierelor din folder se face cu

instruciunea foreach, care se folosete de parametrul pe care metoda l primete,
n felul urmtor:
foreach (string f n Directory.GetFiles(sDir, "*.*",
SearchOption.AllDirectories))
{
load.MakeStep(f); //aceasta comanda afiseaza progresul cautarii
if ((f.EndsWith(".c")) || (f.EndsWith(".h")) ||
(f.EndsWith(".cs")))
{
NumeFisier = f;
GetStructFromFile(f);
}
}
OBSERVAIE: Pe msur ce prezentarea modului de proiectare al

programului va avansa n urmtoarele pagini, n cazul n care vorbim de o
parcurgere de fiiere a unui director, nu se va mai exemplifica din nou sub form
de cod modul n care este implementat, deoarece explorarea folderului este
identic.
Pentru fiecare fiier gsit, metoda apeleaz n continuare metoda

GetStructFromFile, creia i trimite ca parametru stringul f ce conine informaia
despre locaia fiierului i numele lui.
Metoda GetStructFromFile poate fi considerat metoda principal a

clasei StructClass. Aceasta face apel la majoritatea funciilor, n funcie de
modul n care structura este definit.
private void GetStructFromFile(string f)
{
string verif = "";
string line; //Se memoreaza continutul liniei curente a

fiierului
string tineminte; //Variabila care tine minte linia urmatoare
a fiierului
string[] words; //Variabila n care se stocheaza cuvintele din linie
string[] separator = { " " };
42 Cap. 6 Preluarea funciilor

Dup cum este prezentat, funcia are nevoie de o variabil pentru a

retine o linie din fiier i de o variabil pentru a reine precedenta. Variabila
separator ajut la mprirea liniei n mai multe cuvinte, acestea fiind separate
prin spaiu (tasta space);
Pentru iniializarea fiierului se folosete biblioteca System.IO (Input,

Output). Citirea se execut linie cu linie, pn la captul fiierului.
System.IO.StreamReader file = new System.IO.StreamReader(f);
while ((line = file.ReadLine()) != null)
{
n corpul instruciunii while se analizeaz dac linia conine cuvinte
specifice cum ar fi: typedef, struct. Aceast analiz se realizeaz prin metoda
LineContainStruct ce ia ca parametru linia n cauz.
private bool LineContainStruct(string line)
{
if (line.StartsWith("typedef")||line.StartsWith("struct"))
return true;
return false;
}
Funcie simpl de tip boolean (poate returna doar dou valori: adevrat
sau fals).
n cazul n care linia conine o definire a unei structuri, ea este filtrat
de comentarii prin metodele CommentFiltre(string line). Aceste metode nu vor
fi exemplificate, deoarece realizeaz o operaie simpl, de extragere a subirului
existent dintr-un sir, pn la ntmpinarea caracterelor specifice adugrilor de
comentarii
ex: line.IndexOf("//") sau ("/*")
if (LineContainStruct(line)) //in cazul n care contine o structura

{
line = CommentFiltre(line);
line = CommentFiltre2(line);
words = line.Split(separator,
StringSplitOptions.RemoveEmptyEntries);
verif = file.ReadLine();
//verif are scopul de a verifica dac exista acolada
Dup detectarea liniei, ncepe repartizarea modului de definire al

structurilor. Aici este prezentat cum sunt implementare cele 3 cazuri descrise
n capitolul de arhitectur al clasei.
1) Cazul n care linia curent nu conine acolade i nici linia urmtoare:

Acest lucru indic faptul c structura este definit pe o singur linie,
fr corp, iar numele ei poate fi extras simplu, fiind acela care este
diferit de termenii folosii pentru a defini structuri
if ((!line.Contains("{")) && (!verif.Contains("{")) && (!line.Contains("}")))
foreach (var w n words)

if ((w != "typedef") && (w != "struct") && (w != "union") && (w !=

"enum"))
AddStructName(w,false);
n cazul n care cuvntul difer de aceti termeni, el este stocat

n vectorul string tipuri[] prin metoda AddStructName despre care se va vorbi n
detaliu imediat.
2) n cazul n care linia conine ambele acolade, ea este mult mai simplu
de manevrat, deoarece este sub forma:
ex: typedef struct RamImag{ .} Nume;
ntr-o astfel de situaie, trebuie doar s extragem numele de dup
acolada nchis. Astfel se apeleaz tot metoda AddStructName, dar de
data aceasta cu parametrul boolean de tip true.
else if (line.Contains("{") && line.Contains("}"))
AddStructName(line, true);
3) Cazul n care linia curent nu conine acolade, n schimb urmtoarea

conine acolada deschis, lucru ce nseamn c numele se afl dup
acolada nchis.
Exemplu:
typedef struct _nvm_MKE_RESERVED_RamImage
{ ...
}nvm_Mke_RESERVED_RamImage;
Acesta este ultimul caz i este cel mai amplu, deoarece el trebuie s
aib grij la acoladele nchise din interiorul structurii. Nu se poate
aborda cutarea numelui ntr-o manier de tip: cnd se gsete prima
acolad nchis, extrage numele de pe acea linie.
n instruciunile pentru gsirea numelui funciei, se face mereu o
verificare la fiecare citire de linie, ca aceasta s nu nceap cu acolada
deschis { , iar n cazul n care ncepe, se citesc linii pn la gsirea
acoladei nchise. Pe viitor se va ncerca o implementare recursiv, ns
pn acum nu a fost mai mult de un nivel de acolade n interiorul
structurii.
else
{
line = verif;
line = RemoveEmptySpace(line);
if (line != "")
{
while (!line.StartsWith("}"))
{
line = file.ReadLine();
line = RemoveEmptySpace(line); //de fiecare data cand
citim linia
line = CommentFiltre(line); //ea este filtrata de
spatiile
line = CommentFiltre2(line); //din fata, i de
comentarii

tineminte = line.ToString();
if (tineminte.StartsWith("{"))
while (!tineminte.StartsWith("}"))
line = file.ReadLine();
}
tineminte = line.ToString();
if (line != "")
AddStructName(tineminte, true);
Metoda AddStructName, conine dou variabile ca i parametrii. Un

string prin care este reprezentat linia care conine structura, ct i o variabil
boolean care specific metodei cum s acioneze
private void AddStructName(string s,bool check)
{
s = CommentFiltre(s);
if (check)
tipuri[tipc] = StructNameExtract(s);
else
tipuri[tipc] = RemoveCharacters(s);
if (!tipuri[tipc].Equals(""))
tipc++;
}
n cazul n care metoda primete valoarea true (adic structura este
declarat pe o singur linie i conine i un corp), n vectorul de string-uri se
memoreaz numele tipuri folosindu-ne de metoda StructNameExtract(string s)
public string StructNameExtract(string s)
{
int index;
index = s.IndexOf("}");
s = s.Substring(index, s.Length - index - 1);
s = s.Replace("}", "");
s = RemoveCharacters(s);
return s;
}
Aceast metod este simpl i extrage substringul de dup caracterul },

care reprezint numele funciei, dup care l returneaz. Substringul ns mai
poate conine semne ca i ; sau * pentru pointeri. De aceea a fost necesar
crearea unei metode care elimin aceste caractere din ir. Anume metoda
RemoveCharacters(string s), care returneaz un string fr toate acele
caractere
public string RemoveCharacters(string s)
{
int index;
index = s.IndexOf("/");
if (index > 0)
s = s.Substring(0, index);
s = s.Replace(" ", "");
s = s.Replace(";", "");
s = s.Replace("\t", "");
s = s.Replace("*", "");
(...)

n cazul n care metoda AddStructName primete valoarea false, ceea ce

nseamn c structura este definit pe o singur linie i nu exist acolade, se
apeleaz doar metoda RemoveCharacters menionat mai sus.
6.2. Clasa FunctionClass
Reamintim faptul c aceast clas are proprietatea de a extrage i analiza

funciile declarate n cadrul unui proiect. Obiectul de acest tip este legat de un
obiect tip MacroClass prin apelul metodei FindFunction().
class FunctionClass
Un obiect de tipul functionClass stocheaz rezultatele obinute, ct i

numrul acestora n dou atribute. Primul este obiectul de tip tabel Excel
worksheetA. Pentru a crea un astfel de obiect trebuie s includem de asemenea
biblioteca ExcelLibrary . Al doilea este reprezentat printr-o variabil de tip
ntreg, denumit i
public Worksheet worksheetA;
public int i;
Aceste dou atribute, la fel ca n cazul clasei precedente, sunt de tip
public, deoarece informaiile sunt apoi extrase de ctre obiectul principal de tip
functionFinder.
Clasa conine doi constructori prin care se iniializeaz valorile
atributelor.
Primul iniializeaz atributele cu valori de baz:
public FunctionClass()
{
worksheetA = new Worksheet("FINAL");
i = 2;
}
Al doilea se folosete de parametrii primii:

public FunctionClass(Worksheet worksheetA, int i)
{
this.worksheetA = worksheetA;
this.i = i;
}
De asemenea, obiectul beneficiaz de metode precum CommentFiltre,

RemoveEmptySpace. Acestea au fost prezentate anterior. n continuare se caut
o modificare a structurrii claselor StructClass, FunctionClass, MacroClass,
UsedFuncClass, astfel nct ele s moteneasc o singur clas. Noua structur
ar elimina aceste duplicri de cod. Dei sunt doar dou funcii, n cazul evolurii
n continuare a programului, este posibil apariia mai multor astfel de cazuri, iar
problema trebuie rezolvat ct mai curnd.

Cutarea funciilor dintr-un anumit fiier se realizeaz prin apelul

metodei FindFunction care ia ca trei parametrii: variabila string cu informaia
directorului, ct i vectorul de iruri tipuri[] i variabila ntreag tipc.
private void FindFunction(string f, string[] tipuri, int tipc)
//f reprezinta numele folderului
Metoda preia fiecare fiier folosindu-se de variabila f. Deschide fiierul

existent n cazul n care respect anumite extensii i analizeaz fiecare linie
precum s-a prezentat n capitolul anterior.
Modul prin care este implementat algoritmul de parcurgere seciuni de

comentarii este descris n continuare:
while ((line.ToString().StartsWith(@"/*"))) //
{
while ((!line.ToString().Contains(@"*/")))
{
if ((acc = file3.ReadLine()) != null)
line = acc;
else
break;
}
if ((acc = file3.ReadLine()) != null)
line = acc;
else
break;
}
Metoda extrage comentariile i spaiile goale de la nceputul liniei prin

metodele CommentFiltre i RemoveEmptySpace pe care le-am menionat mai
sus, dup care ncepe analiza liniei. Ea trebuie s respecte dou condiii. n
primul rnd linia trebuie s conin caracterul parantez deschis (, care este
specific definirii oricrei funcii. De aici linia este filtrat i mai departe,
verificndu-se dac nceputul ei este reprezentat de ctre un tip de date.
Verificarea se face prin compararea cu fiecare element din vectorul tipuri[]
if (line.ToString().Contains("("))
{
for (int q = 0; q < tipc; q++)
{
if (line.StartsWith(tipuri[q]))
n cazul n care linia ncepe cu un tip de date, se trece mai departe, la

extragerea numelui funciei de pe linia existent. n continuare este extras
coninutul dintre parantezele funciei, adic parametrii acesteia, prin dou
funcii, RemoveParantesys(line) i RemoveFinalParantesys(line), care vor fi
explicate ulterior. Acum linia ar trebui s conin doar tipurile de date i numele
funciei, iar de aici cuvintele sunt separate prin spaiu. Vom cuta cuvntul care
nu reprezint un tip de date.
words = line.Split(separator,
StringSplitOptions.RemoveEmptyEntries);
foreach (var w n words)
{

numefuncie = w;
if (!CheckForType(numefuncie,tipuri,tipc))
Verificarea se face prin apelul funciei CheckForType(), care ia ca

parametrii vectorul cu tipurile existente i cuvntul care trebuie s l detecteze
dac este sau nu tip de date. Ea este de tip bool i modul de funcionare nu va fi
prezentat deoarece folosete un algoritm de parcurgere iterativ, care compar
cuvntul de pe fiecare poziie a vectorului tipuri[], cu cuvntul primit ca
parametru, la fel ca i compararea tipurilor cu nceputul liniei.
n cazul n care ultimul cuvnt de pe linie este caracterul \ care

semnific faptul c instruciunea se continu pe linia urmtoare, metoda citete
urmtoarea linie din fiier i extrage numele funciei, nlturnd parantezele.
if (w.Equals(@"\"))
{
numefuncie = file3.ReadLine(); //citim
urmatoarea linie
numefuncie = RemoveFinalParantesys(numefuncie);
}
Dup ce numele funciei a fost gsit, i se nltur posibilele caractere care

nu reprezint numele ei prin metoda RemoveSigns.
numefuncie = RemoveSigns(numefuncie);
iar apoi, este adaugat n worksheetA prin funcia AddFunctionToExcel.
AddFunctionToExcel(numefuncie,f);
n continuare, se vor prezenta i metodele care ajut la ndeplinirea task-

urilor metodei anterioare. Anume:
Metoda AddFunctionToExcel
private void AddFunctionToExcel(string numefuncie,string f)
opereaz cu atributele clasei. Mai nti verific dac numele funciei

exist deja n fiierul Excel, comparnd fiecare linie. n caz contrar, o adaug n
tabelul Excel ntr-o manier asemntoare cu cea prezentat pn acum.
if (!check)
{
worksheetA.Cells[i, 1] = new Cell(numefuncie);
worksheetA.Cells[i, 2] = new Cell(f);
i++;
}
Metoda RemoveParantesys are ca scop eliminarea coninutului dintre
parantezele funciei. Pentru c parametrii pe care i primete funcia pot fi la
rndul lor funcii, este implementat o cutare care elimin treptat coninutul
parantezelor interioare, apoi coninutul celor exterioare.
public string RemoveParantesys(string line)

string rez, rez2;

int indexA, indexB, indexC, indexD;
while ((line.ToString().Contains("(")) &&

(line.ToString().Contains(")")))
{
indexA = line.ToString().IndexOf("(");
indexB = line.ToString().IndexOf(")");
rez = line.ToString().Substring(indexA, indexB - indexA +
1);
//se verifica ce este intre paranteze
if (rez.Substring(1, rez.Length - 1).Contains("("))

//daca rezultatul contine n continuare paranteze
{
indexC = rez.LastIndexOf("(");
indexD = rez.IndexOf(")");
rez2 = rez.Substring(indexC, indexD - indexC + 1);
line = line.Replace(rez2, " ");
//inlaturam continutul din ele
}
line = line.Replace(rez, " "); /
//apoi inlaturam continutul celor dinainte
}
return line;
}
Au fost prezentate metodele eseniale ale clasei, pentru evitarea

repetiiilor. Mai este o singur metod ns fr de care cutarea nu s-ar putea
realiza. Anume metoda DirSearch, care este apelat de ctre obiectul principal
FuncFinder pentru a iniializa cutarea n directorul selectat, aceasta trimite pe
rnd metodei FindFunction numele i calea fiierului pe care trebuie s l
analizeze, prin parametrul de tip string. Explorarea fiierelor se face ca i n
cazul clasei StructClass, ntr-o instruciune de tip try{...} -> catch{...}
public void DirSearch(string sDir,string[] tipuri,int tipc)
Am pstrat aceast metod pentru sfrit, deoarece ea face legtura cu

subcapitolul urmtor. Dup ce execut cutarea funciilor declarate, metoda
DirSearch creeaz un obiect de tip MacroSearch, cruia i trimite mai departe
locaia directorului i tabelul Excel pe care l-a completat.
MacroClass macrouri = new MacroClass(sDir, worksheetA, i);
macrouri.MacroFinder(2);
MessageBox.Show("S-au gasit macrourile");
worksheetA = macrouri.worksheetA;
i = macrouri.i;
Dup ce execut cutarea macro-urilor prin metoda MacroFinder a

obiectului, adaug n tabelul Excel pe care l are ca argument, noile completri
aduse de ctre obiectul MacroClass, ct i numrul funciilor care este obinut
prin variabila i.

6.3. Clasa MacroClass
Clasa are ca scop descoperirea macrourilor din cadrul proiectului, i

legtura acestora cu funciile descoperite pn acum.
class MacroClass
Ea se folosete de constructor pentru a iniializa argumentele acestuia cu

informaiile extrase de ctre obiectul de tip funcionClass, anume: tabelul Excel,
variabila ce ine minte numrul elementelor, variabila string ce ine minte
directorul.
public Worksheet worksheetA = new Worksheet("FUNCTII

DEFINITE");
public int i;
public string director; //numele directorului
public int tura = 0;
public MacroClass(string director, Worksheet worksheetA,int

i)
{
this.director = director;
this.worksheetA = worksheetA;
this.i=i;
}
Dup ce argumentele au fost iniializate, se apeleaz metoda
MacroFinder, care are ca scop, precum i spune i numele, de a detecta macro-
urile din proiect. Aceast metod, la fel ca i metoda FindFunction a clasei
funcionClass, exploreaz directorul i deschide fiierele de anumit format, dup
care citete linie cu linie, n aceeai manier. De aceea codul nu se va mai
prezenta din nou. Se prezint n schimb modalitatea de cutare a macrourilor pe
liniile citite.
while ((line = f.ReadLine()) != null)
{
if (line.StartsWith(@"#define") ||
line.StartsWith(@"# define")
{
line = CommentFiltre(line,"//");
line = CommentFiltre(line,"/*");
line = line.Replace("define", "");
line = line.Replace("#", "");
words = line.Split(separator3,
StringSplitOptions.Remove...);
numara = 0;
n cazul n care linia ncepe cu cuvntul cheie pentru a defini un macro

#define, ea este analizat, modificat (i se extrag comentariile i cuvntul
#define), dup care spart n cuvinte. n urma operaiilor asupra liniei trebuie
s rmn dou cuvinte n cazul n care macroul redefinete o funcie.
foreach (var a n words)
{
numara++;

}
if ((numara == 2))
n cazul n care condiia este respectat, se verific al doilea cuvnt s nu

fie caracterul \, iar dac este, se va citi linia urmtoare de unde se va extrage
numele funciei redefinite
if (words[1].Equals(@"\"))
{
line = f.ReadLine();
line = CommentFiltre(line, "//");
line = CommentFiltre(line, "/*");
words[1] = line;
words[1] = words[1].Replace(" ", "");
words[1] = words[1].Replace(";", "");
}
Dup verificarea anterioar, macro-ul se adaug n tabel prin metoda
AddMacro
AddMacro(words, q, rec, file);
care primete ca parametrii cele dou cuvinte (numele macroului i

numele funciei redefinite, variabila q este de tip ntreg i reprezint numrul de
elemente, rec reprezint numrul elementului din tabelul Excel de unde se
ncepe cutarea, iar file reprezint adresa ctre fiierul care conine funcia.
n cazul n care numrul de cuvinte este mai mare dect 2, dar numele
macroului conine paranteze rotunde, nseamn c acesta nu redefinete o
funcie, dar el este o funcie i de asemenea trebuie stocat n tabelul Excel.
Aceast stocare se realizeaz prin metoda FindDefinedFunc ce primete ca
parametrii numele macroului i locul unde e definit.
else if (((words[0].Contains("()")) ||
((words[0].Contains("(") &&
words[0].Contains(")")))) && (rec == 2))
{
FindDefinedFunct(words,file);
}
De precizat faptul c metoda se apeleaz recursiv. Deoarece odat cu

gsirea macrourilor de tip funcii, creste i numrul funciilor existente n tabelul
Excel. Noile funcii adugate trebuie de asemenea verificate dac sunt
redenumite, astfel pn cnd n tabel nu se mai stocheaz noi funcii, metoda se
apeleaz pe sine nsi.
if (tineminte != i) //define la define la define
{
tura++;
MacroFinder(tineminte);
Variabila tineminte de tip ntreg a metodei, memoreaz cte funcii sunt

existente la nceputul apelului metodei. Apoi la sfrit este comparat cu
variabila i, care reprezint numrul real de elemente. n cazul n care cele dou

sunt diferite, metoda se reapeleaz. Cnd cele dou variabile au ajuns la

egalitate, cutarea macrourilor s-a finalizat.
if (tineminte == i)
MessageBox.Show("Cautarea funciilor s-a finalizat");
Corpul catch al acestei metode, n cazul n care gsirea macrourilor

arunc o excepie, ne spune i la a cta tur de recursivitate a ajuns programul.
catch (System.Exception excpt)
{
MessageBox.Show("Erroare la gasirea macrourilor ");
MessageBox.Show(tura.ToString());
}
Metoda FindDefinedFunc este o metod de tip private, care verific

dac funcia macro exista deja n tabel, prin compararea cu fiecare linie, iar n
caz contrar, funcia este adugat n tabelul Excel.
private void FindDefinedFunct(string[] words,string file)
{
for (fa = 2; fa < i; fa++) //fa=rec
{
if (worksheetA.Cells[fa, 1].ToString().Equals(words[0]))
{
check = false;
}
}
if (check)
{
worksheetA.Cells[i, 1] = new Cell(words[0]);
worksheetA.Cells[i, 2] = new Cell(file);
worksheetA.Cells[i, 0] = new Cell("DEFINED funcION");
i++;
}
Metoda FindMacro de tip private, verific dac ce este stocat pe a doua
poziie a vectorului de cuvinte
este egal cu un nume de funcie din tabel
conine un nume de funcie din tabel
nu conine nici un nume de funcie.
Pe baza acestei mpriri, alege cum vor fi stocate aceste funcii n tabelul
de funcii definite, pentru a putea fi completat corect tabelul de funcii folosite,
care este de fapt i rezultatul analizei. Metoda este prezentat n totalitate,
datorit uoarei nelegeri a acesteia.
private void AddMacro(string[] words, int q, int rec,string file)

{
string text;
bool check = false;
for (q = rec; q < i; q++) //parcurgem lista de funcii

{
text = worksheetA.Cells[q, 1].ToString();
if (words[1].Equals(text))
//Daca gasim o funcie care este egala cu cuvantul

{
FindRedefinedMacro(words, q, 0);
//o adaugam n lista de funcii dar specificam ca redefineste o alta
funcie
check = true;
break;
}
else if (words[1].Contains(text))
{
FindRedefinedMacro(words, q, 1);
//o adaugam n lista de funcii dar specificam ca foloseste alte funcii
check = true;
break;
}
}
if (!check)
{
FindDefinedFunct(words,file);
//daca nu intra pe cazurile precedente, o adauga n lista pur i simplu
}
Metoda FindRedefinedMacro are trei parametrii, vectorul de cuvinte

words, variabila ntreag q, care reprezint poziia tabelului Excel unde se
regsete o anumit funcie (cea redefinit sau folosit), i o variabil de tip
boolean, denumit verif, care informa metoda dac macroul redefinete o
funcie, sau folosete una. Aceast metod filtreaz numele de paranteze (),
apoi n cazul n care nu mai exist n tabelul de funcii definite, este adugat prin
metoda AddDefineToExcel care primete i ea 3 parametri (verif, q i numele
funciei).
private void FindRedefinedMacro(string[] words, int q, int verif)
{
Regex yourRegex = new Regex(@"\(([^\}]+)\)");
words[1] = words[1].Replace("()", "");
words[0] = yourRegex.Replace(words[0], "");
words[0] = words[0].Replace("()", "");
//Verificarea existentei a fost scoasa din metoda pt. simplitatea
prezentrii
if (check && ((words[0]) != "") && (words[0] != words[1])

AddDefineToExcel(words[0], verif, q); //il adauga n excel
}
n cele din urm, metoda AddDefineToExcel, adaug n tabel pe lng

numele macroului gsit i unde este acesta definit, numele funciei pe care o
redefinete pe coloana 5, sau numele funciei pe care o folosete n coloana 6.
Metoda tie s fac aceast repartizare n funcie de parametrul primit de tip
bool, verif.
private void AddDefineToExcel(string numeDefine, int verif, int q)

{

worksheetA.Cells[i, 1] = new Cell(numeDefine);

worksheetA.Cells[i, 2] = new Cell(worksheetA.Cells[q, 2].ToString());
if (verif == 1)
{
}
if (verif == 0)
{
}
i++;
}

7. Detectarea funciilor folosite prin clasa UsedFuncClass
Acesta este capitolul final al lucrrii care descrie n detaliu i la nivel de cod modul n
care funciile folosite ale anumitor fiiere sunt descoperite.
Cutarea se realizeaz prin metodele clasei UsedFuncClass.
class UsedFuncClass
Pentru a extrage aceste informaii, avem nevoie n primul de o lista cu

fiierele care trebuie analizate. n cadrul firmei la care lucrez, lista este stocata
tot intr-un fiier de tip Excel. Printre atributele clasei, se numr i atributul file
n care memorm adresa acestui fiier.
string file;
Clasa se folosete, asemntor cu precedentele, de tabelul cu funciile

declarate, ns pe lng acesta i de un nou tabel n care s stocheze funciile
folosite.
public Worksheet worksheetA,worksheetB;
Alturi de tabele, sunt definite i atributele care memoreaz

dimensiunea lor.
public int i; //numar funciiDefinite
public int count = 2; //numar funciiFolosite
i ultima informaie de care avem nevoie n continuare este locaia

folder-ului n care se execut cutarea.
public string director;
Apelnd metoda GetFiles, se deschide fiierul Excel care conine lista

de fiiere din care trebuie extrase funciile folosite. Apoi se caut aceste fiiere
n destinaia aleas de ctre utilizator, pe care metoda o primete ca parametru.
public void FindFiles()
Tabelul Excel importat este de format .xlsx, astfel trebuie folosit

biblioteca OfficeOpenXml prin care putem manipula formate mai noi ale
fiierelor Office. Numele foii de lucru din fiier este prestabilit, acesta fiind
Dashboard_FUSI.
var existingFile = new FileInfo(file);
var pck = new ExcelPackage(existingFile);
var worksheet = pck.Workbook.Worksheets["Dashboard_FUSI"];
VIITOARE IMBUNTIRI: Se dorete n continuare eliminarea acestor restricii,

pentru ca n cauza lipsei unui fiier Excel cu o list de nume de funcii, programul s gseasc
toate funciile folosite din toate fiierele directorului. De asemenea n cazul n care este
introdus un fiier, s se poat alege care anume foaie de calcul conine informaiile necesare
analizei.
Cap. 7 Detectarea funciilor folosite prin clasa UsedFuncClass 55

DE REINUT: Cutarea se face pe baza faptului c numele fiierelor ce trebuie

analizate sunt stocate pe o anumit coloan i nu exist mai mult de dou spaii goale ntre
acestea.
while ((worksheet.Cells[j,5].Text
!="")||(worksheet.Cells[(j+1),5].Text!= "")
{
text = worksheet.Cells[j, 5].Text;

if(text!="")
FindFile(text);
j++;
}
MessageBox.Show("Puteti salva fiierul Excel cu funciile folosite");
Dup importul numelor de fiiere, este apelata metoda FindFile, creia i

se trimite ca parametru numele fiierului.
Metoda FindFile caut acest fiier n director. n cazul n care este
gsit, se apeleaz metoda AnalizeFile. n caz contrar, se adaug n tabelul
Excel cu funcii definite (worksheetB) ca fiier negsit, prin metoda
AddUnfound.
private void FindFile(string text)

{
string tinemintef;
bool gasit = false; //ne spune dac a fost gasit sau nu
foreach (string f n Directory.GetFiles(director, "*.*", ....)

{
tinemintef = String.Empty;
if (f.EndsWith(text) && (text != ""))
{
count++;
gasit = true;
AnalizeFile(f,text); //nume path fiier, numele fiier
}
}
if (!gasit)
{
AddUnfound(text);
}
}
Metoda AnalizeFile primete ca parametrii att locaia fiierului ct i

numele lui, pentru a nu se extrage mereu numele din string-ul n care este
stocat locaia. Ea definete o variabil de tip string, pe nume line n care
stocheaz, pe rnd, liniile din fiierul pe care l deschide. Aceast metod
verific nti ca linia s nu nceap cu cuvinte cheie specifice tipurilor de date,
iar aceast verificare o face apelnd metoda de tip bool CheckForTypeWords,
care compar linia cu fiecare tip existent. n caz contrar, se verific ulterior
56 Cap. 7 Detectarea funciilor folosite prin clasa UsedFuncClass

dac linia conine caracterul ( pentru a optimiza viteza programului. n caz

afirmativ, se apeleaz metoda CheckForFunctions.
private void AnalizeFile(string f,string text)
{
string line;
System.IO.StreamReader fiier = new System.IO.StreamReader(f);
while ((line = fiier.ReadLine()) != null)

{
if (CheckForTypeWords())
{ }
else if(line.Contains("("))
{
CheckForFunctions(line, text);
}
}
fiier.Close();
}
Metoda CheckForFunctions primete prin parametrii si, dou string-
uri ce reprezint textul de pe o anumit linie i numele fiierului care este
analizat.
private void CheckForFunctions(string line,string text)
Metoda realizeaz o operaie simpl de comparare a fiecrei funcii

existente n primul tabel, cu textul primit ca parametrul (deoarece treaba grea
a fost fcut de ctre obiectele precedente i se cunosc numele funciilor care
pot fi apelate).
if (line.Contains(funcfol))
n cazul respectrii condiiei de mai sus, unde funcfol este variabila n

care se stocheaz pe rnd numele funciilor din tabel, se verific dac funcia
exist deja n al doilea tabel (worksheetB) prin metoda CheckIfExists. Modul n
care aceasta a fost definit nu va mai fi prezentat, deoarece este asemntor cu
verificrile altor metode prezentate anterior.
OBSERVAIE: Pentru a se optimiza viteza, s-a introdus o variabil
string pe nume tinemintef, care ine minte ultimul nume de funcie introdus n
tabel i verific n primul rnd ca funcia s nu fie aceeai. (deoarece tabelul de
funcii poate ajunge la proporii mari, unde vorbim de zeci de mii de funcii).
Dac funcia nu exist, ea este adugat n Excel ca nou funcie
folosit, prin metoda AddUsedFunctionToExcel.
AddUsedFunctionToExcel(text, q);
tinemintef = funcfol;
q reprezinta pozitia n tabel a numelui funciei folosite
Metoda AddUsedFunctionToExcel analizeaz linia cu numrul q,

primit ca parametru, din primul tabel i n funcie de care coloane sunt
completate, adaug funciile n cel de-al doilea tabel. Modul n care acioneaz
este urmtorul:
private void AddUsedFunctionToExcel(string text, int q)

{
if (worksheetA.Cells[q, 5].ToString() != "")
{
AddFuncAndUsingFunc(text, q);
}
else if (worksheetA.Cells[q, 4].ToString() != "")

{
AddRedefinedFunc(text, q);
}
else
{
AddFunc(text, q);
}
1) n cazul n care funcia este un macro i folosete alt funcie

(lucru pe care l cunoate n cazul n care a 5-a coloana este completat) i
aceea funcie trebuie adugat n tabelul de funcii folosite. Pentru adugarea
ambelor se folosete metoda AddFuncAndUsingFunc.
2) n cazul n care funcia este un macro i redefinete o alt
funcie (dac este completat coloana a 4-a), n noul tabel cu funcii folosite se
va aduga doar funcia care a fost redefinit i locaia acesteia. Adugarea se
face prin metoda AddRedefinedFunc.
3) Dac nu ntlnete nici unul dintre primele cazuri, funcia este
adugat n tabel normal, cu numele ei propriu i locaia unde a fost declarat,
prin metoda AddFunc
Metoda AddFuncAndUsingFunc apeleaz ambele metode de la paii 2 i 3
private void AddFuncAndUsingFunc(string text, int q)

{
AddFunc(text,q);
AddRedefinedFunc(text,q);
}
Metoda AddRedefinedFunc parcurge primul tabel Excel i gsete funcia

redefinit. Extrage informaia despre aceasta i o stocheaz n tabelul de funcii
folosite.
private void AddRedefinedFunc(string text, int q)
Un lucru destul de neimportant, se apeleaz metoda GetFileName ce primete

ca parametru un string, pentru a extrage din informaia despre calea numelui,
doar numele fiierului n sine.
while (qw <= i) //se parcurge tabelul excel.

{
if ((worksheetA.Cells[qw,
1].ToString().Equals((worksheetA.Cells[q,4]..
{
worksheetB.Cells[count, 1] = new Cell(text);
58 Cap. 7 Detectarea funciilor folosite prin clasa UsedFuncClass

worksheetB.Cells[count, 2] = new Cell(worksheetA.Cells[qw, 1]);

worksheetB.Cells[count, 4] = new Cell(worksheetA.Cells[qw, 3]);
worksheetB.Cells[count, 3] = new Cell(GetFileName(worksheetA.Cells[qw, 2]
count++;
break;
}
qw++;
}
Metoda AddFunc este cea din urm, care adaug, simplu, funcia
gsit n primul tabel, n cel de-al doilea i informaia despre locaia definirii,
ct i dac fiierul unde a fost definit face parte din modulul asupra cruia se
cere analiza.
private void AddFunc(string text,int q)

{
worksheetB.Cells[count, 1] = new Cell(text); //numele fiierului
//numele funciei folosite
//apartine sau nu
worksheetB.Cells[count, 3] = new Cell(GetFileName(worksheetA.Cells[q,
2].ToString()));
//numere fiierului unde funcia a fost definita
count++;

8. Concluzii i perspective
Ideea dezvoltrii unui astfel de program, a venit chiar din necesitatea unei
analize care dura foarte mult timp, dei implica aciuni elementare. nsa
mai mult de att, fora de a l construi a venit din dorina de a automatiza
un proces de analiza, pentru ca nici un programator sau viitor programator
sa fie constrns de o astfel de munca.
1) Concluzii:
n urma realizrii acestui proiect, se pot trage urmtoarele concluzii

Implementarea unui astfel de proiect este important dac aduce
beneficii pe termen lung.
Efortul depus conteaz, ns mai mult conteaz unde este depus,
n sensul n care programul dezvoltat va fi folosit pe viitor.
Construirea i testarea programului nu a durat o sptmn
precum m ateptam.
2) Sinteza contribuiilor:
Contribuiile proiectului se pot remarca la firma unde lucrez.

Cea esenial este reducerea timpului de analiz a proiectelor i anume
acela de detectare a funciilor folosite din cadrul anumitor module. Prin
implementarea tool-ului prezentat s-a reuit reducerea timpului de la o
lun jumtate (pentru proiectul de fa) la jumtate de or.
Un alt beneficiu, rezultat din prima contribuie, este faptul c se reduc i
costurile implicate de ctre firm pentru realizarea unei astfel de analize.
Astfel, programul reuete s automatizeze o parte din ramura de testare i
analiz a firmei.
3) Perspective de dezvoltare:
Sunt posibile cazuri pe care programul nc nu le detecteaz. De aceea

trebuie testat pe mai multe proiecte, pentru a i se asigura funcionalitatea.
De asemenea urmeaz implementarea conceptului de motenire n clasele
folosite, pentru eliminarea poriunilor de code-duplication. Se dorete i
extinderea programului pentru a nu se mai supune restriciilor de nume
foaie de calcul al Excel-ului cu programe ce trebuie analizate i
posibilitatea de a detecta funciile folosite din ntregul proiect, n cazul n
care acest Excel lipsete.
Cap. 8 Concluzii i perspective 61

Referine bibliografice
[1] Schach, Stephen (2006). Object-Oriented and Classical Software Engineering

[2] Herbert Schildt, C#, Ed.Teora (traducere, 2002)
[3] Kris Jamsa i Lars Klander, Totul despre C i C++ Manualul fundamental de
programare n C i C++, Ed. Teora
[4] "MISRA C and MISRA C++ Compliance". Programmingresearch.com. Retrieved
2014-06-3
[5] Website [https://en.wikipedia.org/wiki/Integrated_development_environment]
[6] Understand Website [https://scitools.com/features/]
[7] Doxigen Webpage [http://www.stack.nl/~dimitri/doxygen/index.html]
[8] Herbert S. Wilf - Algorithms and Complexity
[9] Pdf Online:
http://info.tm.edu.ro:8080/~junea/cls%2010/recursivitate/recursivitate.pdf
[10] Kleene 1956.
Referine bibliografice 63
Anexa 1: Rapoarte al progresului proiectului
Review 4/07
S-a reuit construirea unei pri a tool-ului.

Pn acum import toate numele de fiiere .c sau .h din Dashboard 00.10
Apoi le caut n fiierul src al proiectului
Pe cele care le gsete, le analizeaz i extrage toate funciile definite.
Urmeaz s l fac s verifice toate fiierele din src, inclusiv acelea care nu sunt n
Dashboard ,
Dup care, ultimul pas e s extrag din Excel-ul trimis de tine, de pe datasheet
Dashboard_FUSI, fiierele care trebuie verificate ce funcii folosesc i s le compar cu datele
stocate n Excel-ul generat.
Din cte am neles, folderele src ce mi le-a ataat Ionu nu sunt bune, aa c i Excel-ul
generat se poate s nu conin toate datele.
Fiierul ataat este o analiz a src_COC i momentan deduce toate funciile definite din
fiierele notate n Excel
4/14
Progresul tool-ului:
Este aproape de finalizare, singura problem o reprezint acele structuri, cnd ajunge la
ele, completeaz n Excel cu o celul blank, dar caut s rezolv problema ct de curnd.
4/28
Tool-ul este aproape gata, mai sunt unele tipuri pe care nc nu le-am acoperit, nici nu
tiam de ele:
cum ar fi T_UBYTE sau vuint8/16 , sptmna viitoare o s finisez tool-ul completnd
ultimele funcii.
5/08
Am primit att folderul src MOM de la Ionu, ct i fiierul lui Excel pe care l-a
completat.
Apoi am comparat rezultatele, nc nu toate, ns de la primele 3-4 fiiere.
Tool-ul a gsit toate funciile pe care le-a gsit i Ionu pn acum.
Mai puin unele funcii care, dup ce am analizat personal fiierul, nici eu nu le-am gsit
acolo. De aceea m gndesc c n acest caz, prin apelul unei funcii se apeleaz alt funcie,
care nici nu este scris n fiier.
La acest caz nu m-am gndit, ns o s vin cu o idee i pentru rezolvarea ei.
Ataez fiierul Excel de la Ionu, ct i cel de la mine.
Am colorat cu verde n Excel-ul de la Ionu funciile care le-am verificat. Nu am fcut-o
dect pentru primele 4-5 fiiere pn acum. Dar pn acum, cu acestea, a dat rezultate bune.
Anexa 1 Specificaiile proiectului i planul de lucru 65

Dac se acord timp l pot mbunti n sensul c Excel-ul generat s fie mprit pe
linii i coloane exact ca n datasheetul din fiierul tu (Dashboard).
Eu mine o s am un interviu tot aici la Continental i s-ar putea s fiu transferat.

Nu tiu cnd o s se ntmple i dac o s se ntmple transferul, dar pn atunci a vrea
tare mult s las o contribuie acestui departament, iar tool-ul s l poi folosi i n continuare,
pe alte proiecte.
5/17
Am acoperit toate cazurile mai puin funciile care sunt definite altundeva, n afara src-
ului.
ns au fost alte cazuri n care de exemplu pentru o funcie care era notat cu "?", adic
nu se tia de unde provine, s i gseasc locaia.
Deci alte funcii n afara src-ului nu le gsete. ns tool-ul poate cuta i n afara lui
dac are acces la proiect.
Am terminat de comparat Excel-ul MOM i am completat cu verde funciile care le

gsete.
Cele care nu le gsete de obicei sunt de tip Rte_ i a vrea tare mult s tiu de unde
provin, ca s acopr i cazul acesta exterior.
De asemenea, am completat n fiierul meu, tot cu verde, funciile care nu au fost gsite
n Excel-ul lui Ionu.
Acestea nu sunt multe, ns am observat c sunt anumite fiiere care nu au fost
verificate i de aceea la un moment dat o s vezi o parte foarte mare cu verde..
5/24
Am descoperit cum s afiez i funciile acelea care nu erau localizate (adic definite)
niciunde n src. (de ex: Rte_Write_ckvwreqsandout1_so_Frontwischer_Stufe_1_hw_safe_b )
Aceast funcie conine numele fiierului unde v-a fi folosit: ckvwreqsandout1.c
ns n acel fiier ea este apelat astfel:
Rte_Write_so_Frontwischer_Stufe_1_hw_safe_b (fr cuvntul "ckvwreqsandout1"
care e numele fiierului)
tiind asta, la cutarea funciilor folosite , voi aduga condiia s scoat din numele
funciilor declarate numele fiierului, n cazul n care apare.
Din cte am neles de la Ionu, acele funcii sunt cele mai importante i pentru ele se
face acest review
5/31
Am tot lucrat la tool deoarece nu memora typedef-urile bine,
Am modificat s arate mai frumos, spaiat, i s afieze doar numele fiierului
Un ultim pas ar fi s ia n considerare toate #define-urile n cazul n care funciile sunt
redenumite. Astfel ar descoperi i puinele funcii care au rmas neacoperite.
66 Anexa 1 Specificaiile proiectului i planul de lucru

tiu c sunt multe rezultate, ns asta e deoarece nc afieaz i funciile folosite n

fiiere .h (ceea ce ai spus ca nu e nevoie dac e completat fiierul .c) i pentru c funciile
Rte le afieaz de 2 ori, deoarece le gsete definite i n header. O s scot aceste duplicri
ns sptmna viitoare.
6/02
Am reuit s implementez n sfrit i citirea macro-urilor, adic s gsesc #defineurile
Prin aceasta, am gsit i funciile care lipseau.
Am lucrat tot cu EXCELUL de la Ionu, unde erau completate de el fiierele ce aparin
de MaCo pentru a observa diferenele i progresul de la rezultatele anterioare.
Am completat cu galben funciile care le descoper n plus acum.
Sunt ns cteva cazuri neacoperite:

Spre exemplu, era o funcie definit STATIC n loc de static i tool-ul nu a gsit-o. O s
l fac case insensitive
Se poate o funcie dup ce e redefinit, s fie din nou redefinit, iar tool-ul gsete
momentan doar prima redefinire.
6/13.
De cnd m-am apucat de macro-uri, am tot dat de probleme noi, i am realizat c nu e
aa uor s automatizez aceast munc.
Dar nici imposibil
Anexa 1 Specificaiile proiectului i planul de lucru 67

Anexa 2: Ghidul utilizatorului pentru aplicaia Analysis Tool
n acest capitol se va prezenta modul de operare al sistemului Analisys Tool.
Interfaa acestuia arat n felul urmtor
n continuare se vor urma paii 1, 2, 3, 4 din stnga ferestrei, pentru a analiza

fiierele dorite.
Pasul 1: Se alege o cale destinaie, prin butonul AlegeFolder, care programul o

va analiza i va extrage tipurile de date
Anexa 2 Ghidul utilizatorului pentru aplicaia DigitalSpeye 69

Pasul 2: Se adaug fiierul Excel ce conine numele fiierelor asupra crora se

nainteaz analiza (prin apsarea butonului Adaug Excel cu fiiere ce trebuie
proc.)
Pasul 3: Se apas butonul GasesteFunctii pentru a iniializa cutarea. Cnd

aceasta se finalizeaz, prin butonul Salvare funcii folosite se poate salva
tabelul generat de ctre program.
70 Anexa 2 Ghidul utilizatorului pentru aplicaia DigitalSpeye

In caz opional, se poate aduga un Excel care s conin deja informaii despre
definiri de funcii (de preferat acesta s fi fost generat tot de ctre tool), prin
care s nu mai fie nevoie de gsirea funciilor definite. Adugarea se face prin
butonul Adaug fiier Excel cu funcii definite. Aceast opiune a fost
adaugat pentru reducerea timpului de cutare.
Pasul 4: Se apas butonul Gsete funcii folosite, care iniializeaz cutarea

acestora. Iar dup finalizare, ca i n cazul precedent, tabelul se salveaz prin
apsarea butonului Salvare funcii folosite
Anexa 2 Ghidul utilizatorului pentru aplicaia DigitalSpeye 71

DECLARAIE DE AUTENTICITATE A
LUCRRII DE FINALIZARE A STUDIILOR
Subsemnatul _____________________________________________________,
legitimat cu _______________seria ________nr. ________________________,
CNP _____________________autorul lucrrii___________________________
__________________________________________________________________________
______________________________________________________
elaborat n vederea susinerii examenului de finalizare a studiilor de licen
________________________________________________________________organizat de
ctre Facultatea de Automatic i Calculatoare din cadrul Universitii Politehnica
Timioara, sesiunea ____________________ a anului
universitar________________________, lund n considerare coninutul art. 39 din RODPI
UPT, declar pe proprie rspundere, c aceast lucrare este rezultatul propriei activiti
intelectuale, nu conine poriuni plagiate, iar sursele bibliografice au fost folosite cu
respectarea legislaiei romne i a conveniilor internaionale privind drepturile de autor.
Timioara,
Data Semntura
_______________________ ______________________________
Declaraia se completeaz de mn i se insereaz n lucrarea de finalizare a studiilor, la sfritul acesteia, ca parte integrant.

Lucrare

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lucrare

Uploaded by

Copyright:

Available Formats

Facultatea de Automatic i Calculatoare

Calculatoare i Tehnologia Informaiei

Proiectul de licen se refer la implementarea unei automatizri n domeniul

Fig 1-1 Imagine de ansamblu a tool-ului

Urmtoarele pagini trec cititorul prin procesul de creeare al tool-ului, rezultatele

Proiectul ofer un instrument de automatizare a proceselor de analiz static i testare i

Fig 1-2 Imagine cu tabelul Excel care contine analiza fiierelor

Dup cum observm, se analizeaz modularizarea programelor de pe prima coloan.

1.1. Domeniul abordat i obiectivele generale

n vederea implementrii noii modaliti de programare: programarea POO. Limbajul C++ a

Obiectivele programului sunt:

1.2. Contextul de realizare

n cadrul firmei Continental, unde lucrez de aproximativ 6 luni (n perioada de

Am propus superiorului de la lucru realizarea unui tool care s nglobeze sarcinile

Img. 1-3 Tool-ul afind rezultatele cutrii unui cuvnt

1.3. Specificaii generale

Subcapitolul conine descrierea pe scurt a proiectului, precum i enumerarea

2. Programe moderne de analiz a proiectelor

n capitolul de fa se vor prezenta pe scurt sistemele actuale de analiz a funciilor din

Cap. 2 Programe moderne de analiz a proiectelor 7

8 Cap. 2 Programe moderne de analiz a proiectelor

Deci, ca s realizez aceast analiz, am nevoie de:

Cap. 2 Programe moderne de analiz a proiectelor 9

Img 2-3: Reprezentnd extensia nWire pentru mediul de programare Java

10 Cap. 2 Programe moderne de analiz a proiectelor

Img. 1-4: Imagine de ansamblu a programului de analiz

Rezultatul unei munci ndelungate este prezentat n imaginea urmtoare:

Img. 2-5: Imagine cu tabelul final ce conine funciile folosite

Cap. 2 Programe moderne de analiz a proiectelor 11

Nu m consider un fanatic al automatizrii, care triete mereu cu impresia c totul

12 Cap. 2 Programe moderne de analiz a proiectelor

3. Algoritmi pentru detectarea funciilor existente

n acest capitol se vor prezenta la un nivel moderat de detaliere, algoritmii de baz

Cap. 3 Algoritmi pentru detectarea funciilor existente 13

3.1. Algoritmul de detectare a funciilor declarate

3.1.1. Algoritmul de detectare a structurilor

14 Cap. 3 Algoritmi pentru detectarea funciilor existente

3.1.2. Algoritmul de detectare a funciilor

Regex yourRegex = new Regex(@"\(([^\}]+)\)");

Aceast expresie extrage coninutul dintre paranteze.

3.1.3. Algoritmul de detectare a macrourilor

Cap. 3 Algoritmi pentru detectarea funciilor existente 15

Img 3-1: Reprezentarea tabelului Excel ce conine funciile declarate

3.2. Algoritmul de cutare a funciilor folosite:

Dup parcurgerea algoritmului de detectare a funciilor definite, urmeaz algoritmul de

16 Cap. 3 Algoritmi pentru detectarea funciilor existente

3.2.1 Algoritmi ce folosesc instruciuni de baz ale irurilor

3.2.2. Algoritmi ce folosesc instruciuni de baz ale tabelelor Excel

Cap. 3 Algoritmi pentru detectarea funciilor existente 17

4. Descrierea general a sistemului AnalysisTool

n nceputul proiectului, nu am luat n calcul toate elementele, i m-am gndit, ca un

Img 4-1: Legtura dintre clasele proiectului

Astfel totul pornete de la clasa principal funcionFinder. Aceast clas se folosete de

Dac privim imaginea de la dreapta la stnga, ea respect ordinea crerii obiectelor de

n continuare se va prezenta interiorul fiecrei clase, adic variabilele acesteia, metodele

4.1. Arhitectura clasei funcionFinder

n aceste subcapitole se va prezenta arhitectura fiecrei clase n parte. Clasa principal,

20 Cap. 4 Descrierea general a sistemului AnalysisTool

Pentru simplitate, n prezentarea metodelor claselor din aceste subcapitole, se va folosi

Img 4-2: Unele dintre metodele i variabilele clasei principale

Img 4-3: Imagine de ansamblu a tool-ului

1. Butonul Alege Folder

Cap. 4 Descrierea general a sistemului AnalysisTool 21