Documente Academic
Documente Profesional
Documente Cultură
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
Kovacs-Vinan Ioan-Luca Sistem de analiz static a proiectelor
1. Introducere
Cap. 1 - Introducere 1
Sistem de analiz static a proiectelor Kovacs-Vinan Ioan-Luca
2 Cap. 1 Introducere
Kovacs-Vinan Ioan-Luca Sistem de analiz static a proiectelor
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
Cap. 1 - Introducere 3
Sistem de analiz static a proiectelor Kovacs-Vinan Ioan-Luca
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.
4 Cap. 1 Introducere
Kovacs-Vinan Ioan-Luca Sistem de analiz static a proiectelor
Cap. 1 - Introducere 5
Sistem de analiz static a proiectelor Kovacs-Vinan Ioan-Luca
6 Cap. 1 Introducere
Kovacs-Vinan Ioan-Luca Sistem de analiz static a proiectelor
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.
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.
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.
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.
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.
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.
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.
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.
worksheetA = funcii.worksheetA;
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.
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.
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.
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 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:
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.
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.
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.
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.
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.
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.
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.
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.
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:
Dup ce acesta i-a ncheiat procesul, atributele tipc i tipuri ale clasei sunt
iniializate.
while (thread.IsAlive)
{
}
tipc = structuri.tipc;
tipuri = structuri.tipuri;
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++;
}
Stream myStream;
SaveFileDialog saveFileDialog2 = new SaveFileDialog();
saveFileDialog2.Filter = "excel files (*.xls)|*.xls";
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.
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.
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
blocului try-catch, putem afla care anume este fiierul n cauz. Iar de acolo
problema trebuie analizat i rezolvat).
try {...}
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 ("/*")
verif = file.ReadLine();
//verif are scopul de a verifica dac exista acolada
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);
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);
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;
}
public FunctionClass()
{
worksheetA = new Worksheet("FINAL");
i = 2;
}
this.worksheetA = worksheetA;
this.i = i;
}
if (line.ToString().Contains("("))
{
for (int q = 0; q < tipc; q++)
{
if (line.StartsWith(tipuri[q]))
numefuncie = w;
if (!CheckForType(numefuncie,tipuri,tipc))
if (w.Equals(@"\"))
{
numefuncie = file3.ReadLine(); //citim
urmatoarea linie
numefuncie = RemoveFinalParantesys(numefuncie);
}
numefuncie = RemoveSigns(numefuncie);
iar apoi, este adaugat n worksheetA prin funcia AddFunctionToExcel.
AddFunctionToExcel(numefuncie,f);
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)
}
if ((numara == 2))
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);
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
}
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
while ((worksheet.Cells[j,5].Text
!="")||(worksheet.Cells[(j+1),5].Text!= "")
{
}
MessageBox.Show("Puteti salva fiierul Excel cu funciile folosite");
{
if (worksheetA.Cells[q, 5].ToString() != "")
{
AddFuncAndUsingFunc(text, q);
}
else
{
AddFunc(text, q);
}
if ((worksheetA.Cells[qw,
1].ToString().Equals((worksheetA.Cells[q,4]..
{
worksheetB.Cells[count, 1] = new Cell(text);
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.
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:
2) Sinteza contribuiilor:
3) Perspective de dezvoltare:
Referine bibliografice
Referine bibliografice 63
Kovacs-Vinan Ioan-Luca Sistem de analiz static a proiectelor
Review 4/07
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.
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).
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.
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.
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.
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
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.
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.