Analizzatori di programmi in C
Upcoming SlideShare
Loading in...5
×
 

Analizzatori di programmi in C

on

  • 1,076 views

Studio dei tre tools di analisi CFlow , Fjalar e Metre. Verranno messi a confronto per i loro requisiti di installazione, semplicità di utilizzo e funzionalità offerte.

Studio dei tre tools di analisi CFlow , Fjalar e Metre. Verranno messi a confronto per i loro requisiti di installazione, semplicità di utilizzo e funzionalità offerte.

Statistics

Views

Total Views
1,076
Views on SlideShare
1,005
Embed Views
71

Actions

Likes
1
Downloads
8
Comments
0

3 Embeds 71

http://boymix81.mynickname.info 68
http://www.slideshare.net 2
http://localhost 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Analizzatori di programmi in C Analizzatori di programmi in C Presentation Transcript

    • Tools di analisi di programmi sviluppati in ANSI C
      • Studio dei tre tools di analisi CFlow , Fjalar e Metre. Verranno messi a confronto per i loro requisiti di installazione, semplicità di utilizzo e funzionalità offerte.
      • Autore: Maurizio Pianfetti
      • Esame per “Linguaggi e Traduttori” seguito da Armando Tacchella, Jacopo Mantovani e Luca Pulina
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow
      • il progetto GNU Cflow è un analizzatore di sorgenti C che restituisce come output il flusso computazionale del programma in base alle funzioni richiamate dalla funzione di partenza ( normalmente il main )‏
      • attualmente la versione stabile è la 1.2 ultimata il 29/06/2007
      • software rilasciato sotto licenze GPLv3, usufruibile gratuitamente
      • riferimenti all'applicazione: http://www.gnu.org/software/cflow/
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( funzionalità )‏
      • è possibile avere il flow del programma da due punti di vista diversi
        • Direct graph : partendo dalla funzione principale si elencano le chiamate e sotto chiamate in modo ricorsivo alle funzioni nel programma ( caller — callee dependencies )‏
        • Reverse graph: partendo da tutte le funzioni nel programma si risale a chi chiama la singola funzione in ordine inverso ( callee — caller dependencies )‏
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( funzionalità )‏
      • informazioni aggiuntive: oltre alle firme delle funzioni e l'ordine con cui vengono chiamate è possibile avere:
        • variabili o funzioni di tipo statico e globali ( i simboli )‏, non è possibile una analisi locale
        • tipi, parametri e valori di ritorno delle variabili e funzioni rilevate
        • è possibile fare una analisi di tipo PreProcessor
        • è possibile avere l'elenco delle dichiarazioni di ogni singolo simbolo ( cross-reference listings )‏
      • segnala le funzioni richiamate ricorsivamente
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( Output )‏
      • l'output di cflow può essere di due tipi:
        • POSIX: si ha l'elenco delle firme di ogni singola funzione con dei caratteri aggiuntivi per definire l'ingresso in esse, col numero progressivo di ordine di chiamata e richiamo alla riga di dichiarazione nel caso di funzione ricorsiva. Questo standard è utilizzato da ulteriori tools di analisi che utilizzati in “pipe” dopo CFLow creano grafici costruendo flow del programma [ cflow2vcg http://cflow2vcg.sourceforge.net/ xvcg http://rw4.cs.uni-sb.de/users/sander/html/gsvcg1.html Comando: cflow --format=posix --omit-arguments --level-indent='0= ' --level-indent='1= ' --level-indent=start=' ' $* | cflow2vcg | xvcg -
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( Output )‏
      • GNU Output: si ha l'elenco delle firme di ogni singola funzione con dei caratteri di tabulazione per definire ciò che avviene all'interno di esse. L'output generato è configurabile ed è possibile:
          • aggiungere il numero progressivo di chiamata
          • cambiare i caratteri di ingresso nelle funzioni
          • omettere la firma delle funzioni
      • Attualmente non esiste l'estensione per un output XML o HTML , probabilmente funzione presente nelle versioni future
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( Usabilità )‏
      • può essere installato come plugin di Emacs
      • può essere facilmente integrato come parte di progetto facendo una configurazione opportuna nel file Makefile.am
      • è possibile definire delle configurazioni di default settando delle variabili di ambiente o utilizzando un file di configurazione
      • è possibile utilizzarlo agganciando l'analisi ad un debugger ( Es. gdd ) ‏
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Caratteristiche ( Installazione )‏
      • per l'installazione necessita soltanto delle librerie “header” del kernel Linux per poter essere compilato
      • l'installazione comporta l'esecuzione dei classici tre comandi: ./configure; make; make install
      • è un programma senza interfaccia grafica command-line adatto per sistemi di automazione e punto di partenza per analisi più complesse
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Esempio
        • #include <stdlib.h> #include <stdio.h> #include <assert.h>
        • int division(int dividend, int divisor) {
        • int remainder = dividend;
        • int quotient = 0;
        • assert(divisor > 0);
        • //assert(dividend > 0);
        • while (divisor <= remainder) {
        • remainder = remainder - divisor;
        • ++quotient;
        • }
        • return quotient;
        • }
        • int main(int argc, char *argv []) {
        • int dividend, divisor;
        • if (argc != 3) {
        • printf(&quot;Usage: div <dividend> <divisor>&quot;);
        • exit(EXIT_FAILURE);
        • }
        • dividend = atoi(argv[1]);
        • divisor = atoi(argv[2]);
        • //if (divisor <= 0) return 2;
        • printf(&quot;%d&quot;, division( dividend, divisor ));
        • return 0;
        • }
        • Si consideri il seguente programma C che esegue una divisione tra due numeri
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Direct Flow
        • Formato di default
        • main() <int main (int argc,char *argv[]) at division.c:18>: printf() exit() atoi() division() <int division (int dividend,int divisor) at division.c:6>: assert()‏
        • Formato posix
        • 1 main: int (int argc,char *argv[]), <division.c 18> 2 printf: <> 3 exit: <> 4 atoi: <> 5 division: int (int dividend,int divisor), <division.c 6 > 6 assert: <>
        • Ecco i due output possibili come flow diretto del codice d'esempio
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Reverse Flow
        • assert(): division() <int division (int dividend,int divisor) atdivision.c:6>: main() <int main (int argc,char *argv[]) atdivision.c:18>
        • atoi(): main() <int main (int argc,char *argv[]) at division.c:18>
        • division() <int division (int dividend,int divisor) atdivision.c:6>: main() <int main (int argc,char *argv[]) at division.c:18>
        • exit(): main() <int main (int argc,char *argv[]) at division.c:18>
        • main() <int main (int argc,char *argv[]) at division.c:18>
        • printf(): main() <int main (int argc,char *argv[]) at division.c:18>
        • Viene evidenziata ogni singola funzione da chi viene richiamata
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Numero di richiami e simboli
        • assert division.c:9 atoi division.c:24 atoi division.c:25 division *division.c:6 int (int dividend,int divisor) division division.c:27 exit division.c:22 main *division.c:18 int (int argc,char *argv[]) printf division.c:21 printf division.c:27
        • 1 main: int (int argc,char *argv[]), <division.c 18>
        • 2 printf: <>
        • 3 exit: <>
        • 4 EXIT_FAILURE: <>
        • 5 atoi: <>
        • 6 division: int (int dividend,int divisor), <division.c 6>
        • 7 assert: <>
        • Cflow evidenzia tutti i singoli richiami alle varie funzioni, visualizza le dichiarazioni e i simboli di compilazione
    • Tools di analisi di programmi sviluppati in ANSI C : CFlow Visualizzazione umana
        • E' anche possibile una visualizzazione ad albero
        • 1 +-main() <int main () at division.c:18>
        • 2 +-printf()‏
        • 3 +-exit()‏
        • 4 +-atoi()‏
        • 5 -division()‏
    • Tools di analisi di programmi sviluppati in ANSI C : Metre
      • il progetto Metre è un analizzatore di sorgenti ANSI C che restituisce come output una analisi statistica secondo alcune metriche che descrivono il livello di complessità / ottimalità di funzionamento del sorgente scritto e analizzato
      • attualmente la versione stabile è la 2.3 ultimata il 03/04/1995
      • software rilasciato con Copyright “Metre Copyright (c) 1993-1995 by Paul Long All rights reserved” . La licenza specificata è l'utilizzo gratuito per applicazioni No profit, diversamente bisogna richiedere la licenza d'uso direttamente allo sviluppatore (Paul Long) http://www.lysator.liu.se/c/metre-v2-3.html
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Metriche )‏
      • vengono calcolate le seguenti metriche:
      • McCabe's cyclomatic complexity : calcola la complessità del programma analizzando il numero di costruttori con punti di decisione. L'antologia su questo argomento mette a confronto complessità con numero di possibili bug
      • Myers' extended complexity : evoluzione della metrica precedente, rileva l'effettivo numero di decisioni considerando il numero di condizioni per ogni costrutt o
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Metriche )‏
      • Halstead's program length : vengono calcolati il numero di “parole” e “operatori” del linguaggio usate , con questi numeri vengono a loro volta calcolati i seguenti parametri : Considerando un programma di due funzioni:
      • operatori univoci f1 n1
      • operatori univoci f2 n2
      • totali operatori f1 N1
      • totali operatori f2 N2
      • velocità di scrittura S = 18 momenti / secondo
      • fattore di secondo all'ora f = 60 * 60
        • Si calcolano i segunti parametri:
      • Lunghezza Prog. N = N1 + N2
      • Vocabolario n = n1 + n2
      • Volume V = N * log2(n)‏
      • Livello L^ = (2 / n1) * (n2 / N2)‏
      • Effort E = V / L^
      • Durata del programma in ore T^ = E / (S * f)‏
      • Intelligenza I = L^ * V
      • Livello del linguaggio L' = L^ * L^ * V
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Metriche )‏
      • Line Classifications : vengono calcolate le righe di codice, commenti e linee senza testo. Nel caso in cui si analizza il programma in modalità preprocessor per avere l'analisi dei commenti bisognerà compilarlo considerando eliminazione / mantenimento dei commenti
      • Statement-Counting Standard : si classificano le “parole” del linguaggio utilizzate secondo l'antologia e regole descritte nel libro “Applied Software Measurement” di Capers Jone, in particolare si contano:
        • Executable-Statement: direttive del linguaggio utilizzato ( C )‏
        • Declaration-Statement: dichiarazioni di variabili e funzioni
        • Preprocessor Statements: vengono contate le parole di codice per il preprocessore ( nel caso del C le linee che iniziano con “#” )‏
      • Backfired function points : parametro empirico che descrive il rapporto tra numero di “function points” e numero di righe di codice, utilizzato nei grandi progetti per valutarne la complessità
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Metriche )‏
      • Maximum control depth : definisce la profondità di annidiamento dei costrutti utilizzati
      • Identifier count and length : definisce il numero di identificatori ( nomi ) variabili e funzioni con la loro lunghezza massima
      • Number of functions and modules: definisce il numero di funzioni e moduli, intesi come file separati, librerie e sorgenti nell'intero progetto analizzato
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Output )‏
      • Esistono due tipi di output:
      • standard : per ogni modulo e funzione vengono calcolate le singole metriche e viene visualizzata una lista con il totale, il minimo, il massimo e la media del valori trovati secondo il seguente formato:
        • per ogni funzione : Cyclomatic: total
        • Extended: total
        • Halstead Length: total
        • Vocabulary: total
        • Volume: total
        • Level: total
        • Effort: total
        • Intelligence: total
        • Time (hours) total
        • Lang Level: total
        • Lines: total
        • Code: total
        • Comment: total
        • Blank: total
        • Exec Statements: total
        • Decl Statements: total
        • Max Depth: total
        • Identifiers: total
        • Length: <min >max ~avg
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Output )‏
      • per ogni modulo : -Function-
      • Cyclomatic: <min >max ~avg
      • Extended: <min >max ~avg
      • Halstead Length: <min >max ~avg
      • Vocabulary: <min >max ~avg
      • Volume: <min >max ~avg
      • Level: <min >max ~avg
      • Effort: <min >max ~avg
      • Intelligence: <min >max ~avg
      • Time (hours) <min >max ~avg total
      • Lang Level: <min >max ~avg
      • Lines: <min >max ~avg total
      • Code: <min >max ~avg total
      • Comment: <min >max ~avg total
      • Blank: <min >max ~avg total
      • Exec Statements: <min >max ~avg
      • Decl Statements: <min >max ~avg total
      • Max Depth: <min >max ~avg
      • -Module-
      • Lines: total
      • Code: total
      • Comment: total
      • Blank: total
      • Exec Statements: total
      • Decl Statements: total
      • PP Statements: total
      • Function Points: total
      • Identifiers: total
      • Length: <min >max ~avg
      • Functions: total
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Output )‏
      • per ogni modulo : -Function-
      • Cyclomatic: <min >max ~avg
      • Extended: <min >max ~avg
      • Halstead Length: <min >max ~avg
      • Vocabulary: <min >max ~avg
      • Volume: <min >max ~avg
      • Level: <min >max ~avg
      • Effort: <min >max ~avg
      • Intelligence: <min >max ~avg
      • Time (hours) <min >max ~avg total
      • Lang Level: <min >max ~avg
      • Lines: <min >max ~avg total
      • Code: <min >max ~avg total
      • Comment: <min >max ~avg total
      • Blank: <min >max ~avg total
      • Exec Statements: <min >max ~avg
      • Decl Statements: <min >max ~avg total
      • Max Depth: <min >max ~avg
      • -Module-
      • Lines: total
      • Code: total
      • Comment: total
      • Blank: total
      • Exec Statements: total
      • Decl Statements: total
      • PP Statements: total
      • Function Points: total
      • Identifiers: total
      • Length: <min >max ~avg
      • Functions: total
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Output )‏
      • CSV ( comma separated value ): viene generata una riga di output per ogni funzione, modulo o progetto analizzato. Ogni riga è composta da diversi campi divisi per “,”. E' possibile personalizzare quali metriche stampare e disabilitare i messaggi di warning che non vengono stampati nel formato standard ma come righe separate mod , insertsort.c , 3,3,3,3,3,3,146,146,146,33,33,33,736,736,736,0.051,0.051,0.051,14510,14510,14510,37,37,37,0.2,0.2,0.2,0.2,1.89,1.89,1.89,33,33,33,33,32,32,32,32,0,0,0,0,1,1,1,1,26,26,26,1,1,1,1,2,2,2,86,37,42,7,26,2,12,0,46,1,6,2,1
      • non è supportato XML
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Caratteristiche ( Installazione )‏
      • per l'installazione necessita soltanto delle librerie “header” del kernel Linux per poter essere compilato
      • l'installazione comporta l'esecuzione del comando di compilazione dei sorgenti. Sono disponibili due tools, metre e mtree gcc -ansi -w -o metre metrules.c ytab.c lex_yy.c -lm gcc -ansi -w -o mtree trerules.c ytab.c lex_yy.c -lm
      • è un programma senza interfaccia grafica command-line adatto per sistemi di automazione
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Considerazioni‏
      • se un sorgente non è ANSI C, per esempio contiene righe con commenti “//” viene generato un “Fatal Error” e non viene completata l'analisi
      • l'autore consiglia l'analisi di sorgenti di tipo PREPROCESSED
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Confronto tra “Mtree” di Metre e la funzione “tree” di CFLow
      • Cflow - tree
      • 1 +-main() <int main () at division_ANSI.c:18>
      • 2 +-printf()‏
      • 3 +-exit()‏
      • 4 +-atoi()‏
      • 5 -division()‏
      Metre – Mtree ision_ANSI.c main +---printf +---exit +---atoi ision_ANSI.c `---division `---assert Table of Contents division_ANSI.c division . . . . . . . . . . . 6 main . . . . . . . . . . . . . 18 #include <stdlib.h> #include <stdio.h> #include <assert.h> int division(int dividend, int divisor) { int remainder = dividend; int quotient = 0; assert(divisor > 0); /* assert(dividend > 0); */ while (divisor <= remainder) { remainder = remainder - divisor; ++quotient; } return quotient; } int main(int argc, char *argv []) { int dividend, divisor; if (argc != 3) { printf(&quot;Usage: div <dividend> <divisor>&quot;); exit(EXIT_FAILURE); } dividend = atoi(argv[1]); divisor = atoi(argv[2]); /* if (divisor <= 0) return 2; */ printf(&quot;%d&quot;, division( dividend, divisor )); return 0; }
    • Tools di analisi di programmi sviluppati in ANSI C : Metre Esempio
      • Module Summary
      • -Function-
      • Cyclomatic: <2 >2 ~2
      • Extended: <2 >2 ~2
      • Halstead Length: <30 >43 ~37
      • Vocabulary: <16 >24 ~20
      • Volume: <120 >197 ~159
      • Level: <0.086 >0.167 ~0.127
      • Effort: <1182 >1400 ~1291
      • Intelligence: <10 >33 ~22
      • Time (hours): <0.0 >0.0 ~0.0 0.0
      • Lang Level: <0.88 >5.47 ~3.18
      • Lines: <10 >11 ~11 21
      • Code: <9 >10 ~10 19
      • Comment: <1 >1 ~1 2
      • Blank: <0 >0 ~0 0
      • Exec Statements: <6 >8 ~7
      • Decl Statements: <1 >2 ~2 3
      • Max Depth: <1 >1 ~1
      • -Module-
      • Lines: 29
      • Code: 26
      • Comment: 2
      • Blank: 1
      • Exec Statements: 14
      • Decl Statements: 3
      • PP Statements: 3
      • Function Points: 0
      • Identifiers: 34
      • Length: <4 >12 ~7
      • Functions: 2
      #include <stdlib.h> #include <stdio.h> #include <assert.h> int division(int dividend, int divisor) { int remainder = dividend; int quotient = 0; assert(divisor > 0); /* assert(dividend > 0); */ while (divisor <= remainder) { remainder = remainder - divisor; ++quotient; } return quotient; } int main(int argc, char *argv []) { int dividend, divisor; if (argc != 3) { printf(&quot;Usage: div <dividend> <divisor>&quot;); exit(EXIT_FAILURE); } dividend = atoi(argv[1]); divisor = atoi(argv[2]); /* if (divisor <= 0) return 2; */ printf(&quot;%d&quot;, division( dividend, divisor )); return 0; } mod,division_ANSI.c,2,2,2,2,2,2,30,43,37,16,24,20,120,197,159,0.086,0.167,0.127,1182,1400,1291,10,33,22,0.0,0.0,0.0,0.0,0.88,5.47,3.18,10,11,11,21,9,10,10,19,1,1,1,2,0,0,0,0,6,8,7,1,2,2,3,1,1,1,29,26,2,1,14,3,3,0,34,4,12,7,2
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar
      • il progetto Fjalar è un framework per lo sviluppo di tools analizzatori del comportamento a compile-time e run-time di programmi C e C++, sfruttando il noto simulatore di CPU Valgrind, verificando problemi di allocazione di memoria legati alle dichiarazioni di variabili
      • attualmente la versione stabile è la 1.3 rilasciata il 30/08/2007
      • il software è rilasciato con licenza GNU General Public License e Copyright (C) 2004-2006 Philip Guo ( [email_address] ), MIT CSAIL Program Analysis Group http://groups.csail.mit.edu/pag/fjalar/
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( struttura )‏ Valgrind Fjalar Framework Kvasir ( rileva strutture dati ) DynComp ( analisi dinamica di strutture astratte )
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( funzionalità )‏
      • fornisce informazioni relative all'accesso alle variabili, tipi, indirizzi fisici, spazio allocato e visibilità (file, static, private, public)
      • rileva associazioni tra strutture e tipi di classe, con variabili per capire eventuali annidamenti e definizioni di strutture in modo ricorsivo
      • fornisce informazioni relative all'accesso alle funzioni, indirizzi, prototype, visibilità, parametri associati con valore e tipo di ritorno
      • crea nomi univoci per le variabili e funzioni globali per eliminare ambiguità in modo da facilitare l'analisi globale per altri ipotetici tools collegati
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( funzionalità )‏
      • offre molte informazioni Run-time basate sull'esecuzione del programma per fare analisi di crash e memory lack
      • è possibile analizzare solo parte del programma definendo quali funzioni analizzare
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( output )‏
      • offre diversi formati di output, derivati dai formati garantiti da Valgrind:
        • default output su standard error
        • stampa su file, se ci sono più processi è possibile fare un unico file o più files per ogni processo
        • stampa su socket per la stampa via rete, Valgrind offre un listener ed un client rispettivamente per ricevere e inviare messaggi
      • offre il formato XML per strutturare le varie informazioni in modo maggiormente interpretabile da altri tools
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Caratteristiche ( Installazione )‏
      • per l'installazione necessita soltanto delle librerie “header” del kernel Linux per poter essere compilato
      • l'installazione comporta l'esecuzione di alcuni comandi per la compilazione dei sorgenti. ./autogen.sh ./configure make make install
      • è un programma senza interfaccia grafica command-line adatto per sistemi di automazione
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Esempio
      • <executable-name>./select</executable-name>
      • <global-variable-declarations>
      • <variable>
      • <name><![CDATA[/arr]]></name>
      • <global-var>
      • <location>0x8049860</location>
      • <filename>./select.c</filename>
      • </global-var>
      • <static-array>
      • <num-dimensions>1</num-dimensions>
      • <upper-bound>19</upper-bound>
      • </static-array>
      • <var-type pointer-levels=&quot;1&quot;>
      • <declared-type>D_UNSIGNED_FLOAT</declared-type>
      • <byte-size>4</byte-size>
      • </var-type>
      • </variable>
      • </global-variable-declarations>
      float arr[20] = { 5, 4, 10.3, 1.1, 5.7, 100, 231, 111, 49.5, 99, 10, 150, 222.22, 101, 77, 44, 35, 20.54, 99.99, 888.88 };
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Esempio
      • <function>
      • <name><![CDATA[select]]></name>
      • <fjalar-name><![CDATA[..select()]]></fjalar-name>
      • <start-PC>0x8048364</start-PC>
      • <end-PC>0x8048640</end-PC>
      • <filename>./select.c</filename>
      • <formal-parameters>
      • <variable>
      • <name><![CDATA[k]]></name>
      • <var-type>
      • <declared-type>D_UNSIGNED_INT</declared-type>
      • <byte-size>4</byte-size>
      • </var-type>
      • </variable>
      • <variable>
      • <name><![CDATA[n]]></name>
      • <stack-byte-offset>4</stack-byte-offset>
      • <var-type>
      • <declared-type>D_UNSIGNED_INT</declared-type>
      • <byte-size>4</byte-size>
      • </var-type>
      • </variable>
      • </formal-parameters>
      • <return-value>
      • <variable>
      • <name><![CDATA[return]]></name>
      • <var-type>
      • <declared-type>D_UNSIGNED_FLOAT</declared-type>
      • <byte-size>4</byte-size>
      • </var-type>
      • </variable>
      • </return-value>
      • </function>
      float select(unsigned long k, unsigned long n)‏ { unsigned long i,ir,j,l,mid; float a,temp; int flag, flag2; ... ... ... } return arr[k] ; }
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Esempio
      • <function>
      • <name><![CDATA[main]]></name>
      • <fjalar-name><![CDATA[..main()]]></fjalar-name>
      • <start-PC>0x8048640</start-PC>
      • <end-PC>0x8048670</end-PC>
      • <filename>./select.c</filename>
      • <formal-parameters>
      • </formal-parameters>
      • <return-value>
      • <variable>
      • <name><![CDATA[return]]></name>
      • <var-type>
      • <declared-type>D_INT</declared-type>
      • <byte-size>4</byte-size>
      • </var-type>
      • </variable>
      • </return-value>
      • </function>>
      main()‏ { select(10, 20); }
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Considerazioni‏
      • è necessario compilare il programma per poterlo analizzare e se la compilazione non termina con successo non si ha l'analisi del programma
      • non vengono considerate le variabili all'interno delle funzioni ma solo quelle globali, parametri e funzioni, poichè non è ingrado di avere informazioni nella fase di registry dal compilatore
      • se il programma non contiene un main e non si può compilare, non è possibile analizzarlo
    • Tools di analisi di programmi sviluppati in ANSI C Analisi di sorgenti Benchmark Tools di analisi di programmi sviluppati in ANSI C : Fjalar Considerazioni‏
      • è necessario compilare il programma per poterlo analizzare e se la compilazione non termina con successo non si ha l'analisi del programma
      • non vengono considerate le variabili all'interno delle funzioni ma solo quelle globali, parametri e funzioni, poichè non è ingrado di avere informazioni nella fase di registry dal compilatore
      • se il programma non contiene un main e non si può compilare, non è possibile analizzarlo
    • Tools di analisi di programmi sviluppati in ANSI C : Fjalar Considerazioni‏
      • è necessario compilare il programma per poterlo analizzare e se la compilazione non termina con successo non si ha l'analisi del programma
      • non vengono considerate le variabili all'interno delle funzioni ma solo quelle globali, parametri e funzioni, poichè non è ingrado di avere informazioni nella fase di registry dal compilatore
      • se il programma non contiene un main e non si può compilare, non è possibile analizzarlo