From 03aac382219d2fe0f5947129ecef394141bd8144 Mon Sep 17 00:00:00 2001 From: andrea Date: Fri, 26 May 1995 10:16:03 +0000 Subject: [PATCH] Aggiunta documentazione in line git-svn-id: svn://10.65.10.50/trunk@1398 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- include/assoc.h | 1 + include/checks.cpp | 107 ++++++++++- include/checks.h | 49 +++-- include/config.cpp | 178 +++++++++++++++-- include/config.h | 90 ++++++--- include/date.h | 3 +- include/execp.cpp | 21 +- include/execp.h | 47 +++-- include/expr.h | 470 ++++++++++++++++++++++++++++++--------------- include/real.cpp | 287 ++++++++++++++++++++++----- include/real.h | 169 ++++++++++++---- 11 files changed, 1102 insertions(+), 320 deletions(-) diff --git a/include/assoc.h b/include/assoc.h index 91e76c155..9971f25e4 100755 --- a/include/assoc.h +++ b/include/assoc.h @@ -12,6 +12,7 @@ // @base public | TObject class THash_object : public TObject { + // @cfriend TAssoc_array friend class TAssoc_array; // @access Private Member diff --git a/include/checks.cpp b/include/checks.cpp index 1d6f1401b..710470695 100755 --- a/include/checks.cpp +++ b/include/checks.cpp @@ -24,7 +24,18 @@ #ifndef FOXPRO -int fatal_box(const char* fmt, ...) +// @doc EXTERNAL + + +// @msg fatal_box | Crea una finestra di ERRORE FATALE con il relativo messaggio +int fatal_box( + const char* fmt, ...) // @parm Messaggio da stampare nella finestra + // (il formato e' come nella printf del C) + + + // @comm Se si opera in ambiente Windows crea la finestra con il bottone OK + // Il programma viene interrotto al momento in cui si e' verificato + // l'errore. { buildmsg(); @@ -51,7 +62,13 @@ int fatal_box(const char* fmt, ...) } -int error_box(const char* fmt, ...) +// @msg error_box | Crea una finestra di ERRORE con il relativo messaggio +int error_box( + const char* fmt, ...) // @parm Messaggio da stampare nella finestra + // (il formato e' come nella printf del C) + + // @comm Se si opera in ambiente Windows crea la finestra con il bottone OK + // e l'icona punto esclamativo. { buildmsg(); @@ -72,7 +89,13 @@ int error_box(const char* fmt, ...) } -int warning_box(const char* fmt, ...) +// @msg warning_box | Crea una finestra di ATTENZIONE con il relativo messaggio +int warning_box( + const char* fmt, ...) // @parm Messaggio da stampare nella finestra + // (il formato e' come nella printf del C) + + // @comm Se si opera in ambiente Windows crea la finestra con il bottone OK + // e l'icona punto di domanda. { buildmsg(); @@ -88,7 +111,13 @@ int warning_box(const char* fmt, ...) } -int message_box(const char* fmt, ...) +// @msg message_box | Crea una finestra di INFORMAZIONE con relativo il messaggio +int message_box( + const char* fmt, ...) // @parm Messaggio da stampare nella finestra + // (il formato e' come nella printf del C) + + // @comm Se si opera in ambiente Windows crea la finestra con il bottone OK + // e l'icona informazioni. { buildmsg(); @@ -101,7 +130,14 @@ int message_box(const char* fmt, ...) return 0; } -int sorry_box(const char* fmt, ...) + +// @msg sorry_box | Crea una finestra di SCUSE con il relativo messaggio +int sorry_box( + const char* fmt, ...) // @parm Messaggio da stampare nella finestra + // (il formato e' come nella printf del C) + + // @comm Se si opera in ambiente Windows crea la finestra con il bottone OK + // e l'icona informazioni. { buildmsg(); @@ -115,7 +151,21 @@ int sorry_box(const char* fmt, ...) return 0; } -int yesno_box(const char* fmt, ...) +// @msg yesno_box | Crea una finestra di RICHIESTA con il relativo messaggio +int yesno_box( + const char* fmt, ...) // @parm Messaggio da stampare nella finestra + // (il formato e' come nella printf del C) + + + // @comm Se si opera in ambiente Windows crea la finestra con i bottni SI e NO + // e l'icona col punto di domanda. + // + // @rdesc Ritorna il risultato della richiesta: + // + // @flag 1 | Se viene premuto il taso SI + // @flag 0 | Se viene premuto il taso NO + // + // @xref { buildmsg(); @@ -129,7 +179,23 @@ int yesno_box(const char* fmt, ...) } -int yesnofatal_box(const char* fmt, ...) +// @msg yesnofatal_box | Crea una finestra di RICHIESTA con il relativo +// messaggio, ma permette di terminare il programma +int yesnofatal_box( + const char* fmt, ...) // @parm Messaggio da stampare nella finestra + // (il formato e' come nella printf del C) + + // @comm Se si opera in ambiente Windows crea la finestra con i bottni SI e NO + // e l'icona col punto di domanda. + // A differenza della permette di terminare il prgramma + // se viene premuto il tasto SI + // + // @rdesc Ritorna il risultato della richiesta: + // + // @flag 1 | Se viene premuto il taso SI + // @flag 0 | Se viene premuto il taso NO + // + // @xref { buildmsg(); @@ -145,7 +211,21 @@ int yesnofatal_box(const char* fmt, ...) } -int yesnocancel_box(const char* fmt, ...) +// @msg yesnocancel_box | Crea una finestra di RICHIESTA con il relativo messaggio +int yesnocancel_box( + const char* fmt, ...) // @parm Messaggio da stampare nella finestra + // (il formato e' come nella printf del C) + + // @comm Se si opera in ambiente Windows crea la finestra con i bottni SI e NO + // e l'icona col punto di domanda. + // + // @rdesc Ritorna il risultato della richiesta: + // + // @flag K_YES | Se viene premuto il taso SI + // @flag K_NO | Se viene premuto il taso NO + // @flag K_ESC | Se viene premuto il tosto ESC + // + // @xref { buildmsg(); @@ -168,7 +248,16 @@ int yesnocancel_box(const char* fmt, ...) #endif } -int __trace(const char* fmt, ...) +// @msg __trace | Permette di mandare dei messaggi nel file trace.log +int __trace( + const char* fmt, ...) // @parm Messaggio da stampare + // (il formato e' come nella printf del C) + + // @comm Usato in fase di debug e permette di vedere se il programma ha + // fatto certe operazioni (deve essere definito il simbolo TRC in + // fase di compilazione). + // + // @rdesc Ritorna non 0 se riesca ad aprire il file trace.log { buildmsg(); FILE* f = fopen("trace.log", "a"); diff --git a/include/checks.h b/include/checks.h index f600ed94e..96c136107 100755 --- a/include/checks.h +++ b/include/checks.h @@ -4,7 +4,6 @@ #ifdef __cplusplus extern "C" { #endif - /* @FPUB */ int message_box(const char* fmt, ...); int warning_box(const char* fmt, ...); int sorry_box(const char* fmt, ...); @@ -14,28 +13,55 @@ extern "C" { int yesnocancel_box(const char* fmt, ...); int yesnofatal_box(const char* fmt, ...); int __trace(const char* fmt, ...); - - /* @END */ #ifdef __cplusplus } #endif +// Utilizzate in fase di debug (definire il simbolo DBG in compilazione) + +// @doc EXTERNAL -/* @M - Utilizzate in fase di debug (definire il simbolo DBG in compilazione) - */ #ifdef DBG +// @msg CHECK | Macro che richiama una per stampare messaggi a video #define CHECK(p, m) ( (p) ? (void)0 : (void) fatal_box( \ "Check failed in %s, line %d:\n\r%s", \ __FILE__, __LINE__, m) ) - + // @parm | p | Condizione per la stampa del messaggio (stampa se FALSE) + // @parm | m | Messaggio da stampare + // + // @comm Viene richiamata se

e' FALSE. + // Utilizzata in fase di debug (definire il simbolo DBG in compilazione). + // + // @xref + + // @msg CHECKS | Macro che richiama una per stampare messaggi a video #define CHECKS(p, m, s0) ( (p) ? (void)0 : (void) fatal_box( \ "Check failed in %s, line %d:\n\r%s%s", \ __FILE__, __LINE__, m, s0) ) - + // @parm | p | Condizione per la stampa del messaggio (stampa se FALSE) + // @parm | m | Messaggio da stampare + // @parm | s0 | Stringa aggiuntiva da stampare + // + // @comm Viene richiamata se

e' FALSE. Oltre al messaggio passato im

+ // stampa anche una strina aggiuntiva passata in

. + // Utilizzata in fase di debug (definire il simbolo DBG in compilazione). + // + // @xref + + // @msg CHECKD | Macro che richiama una per stampare messaggi a video #define CHECKD(p, m, d0) ( (p) ? (void)0 : (void) fatal_box( \ "Check failed in %s, line %d:\n\r%s%d", \ __FILE__, __LINE__, m, d0) ) + // @parm | p | Condizione per la stampa del messaggio (stampa se FALSE) + // @parm | m | Messaggio da stampare + // @parm | d0 | Stringa aggiuntiva da stampare + // + // @comm Viene richiamata se

e' FALSE. Oltre al messaggio passato im

+ // stampa anche un numero passato in

. + // Utilizzata in fase di debug (definire il simbolo DBG in compilazione). + // + // @xref + #else #define CHECK(p, m) @@ -43,17 +69,14 @@ extern "C" { #define CHECKD(p, m, d) #endif -/* @END */ +// Utilizzata in fase di debug (definire il simbolo TRC in compilazione) -/* @M - Utilizzata in fase di debug (definire il simbolo TRC in compilazione) - */ #ifdef TRC +// @msg TRACE | Macro che richiama la funzione #define TRACE __trace #else #define TRACE 1 ? 0 : __trace #endif -/* @END */ #endif // __CHECKS_H diff --git a/include/config.cpp b/include/config.cpp index 66ce7f418..7cb8485bb 100755 --- a/include/config.cpp +++ b/include/config.cpp @@ -13,8 +13,17 @@ extern "C" int rename(const char*, const char*); }; +// @doc INTERNAL + +// @mfunc Legge i dati del paragrafo +// +// @rdesc Ritorna i seguenti valori: +// +// @flag TRUE | Se il paragrafo c'ere +// @flag FALSE | Se il pragarafo non e' esitente bool TConfig::_read_paragraph() - // ritorna TRUE se il paragrafo c'era, FALSE altrimenti + + // @comm Legge il contenuto di tutte le variabili del paragrafo attivo { bool itwas = FALSE; _data.destroy(); @@ -53,7 +62,12 @@ bool TConfig::_read_paragraph() return itwas; } -void TConfig::_write_paragraph(ofstream& out) +// @mfunc Scrive i dati del paragrafo +void TConfig::_write_paragraph( + ofstream& out) // @parm Indirizzo dell'utput sul quale scrivere il paragrafo + + // @comm Scrive le variabili del paragrafo attivo. Nel caso il paragrafo non + // era presente viene aggiunto nel file. { _data.restart(); out << '[' << _paragraph << ']' << endl; @@ -66,6 +80,7 @@ void TConfig::_write_paragraph(ofstream& out) } void TConfig::_write_file() + { ifstream in(_file); TFilename temp; @@ -108,6 +123,7 @@ void TConfig::_write_file() remove(temp); // Cancella file temporaneo } +// @doc EXTERNAL void TConfig::set_paragraph(const char* section) { @@ -120,7 +136,19 @@ void TConfig::set_paragraph(const char* section) } } -bool TConfig::exist(const char* var, int index) +// @mfunc Controlla se esite una variabile nel paragrafo attivo +// +// @rdesc Ritorna i seguenti valori: +// +// @flag TRUE | Se la variabile esite +// @flag FALSE | Se la variabile non esite +bool TConfig::exist( + const char* var, // @parm Nome della variabile + int index) // @parm Indice dell'elemento dell'array (default -1) + + // @comm Se

e' = 0 viene costruito il nome dell'elemento + // dell'array da cercare, diversamente viene cercata la variabile + // normale passata in

. { if (index >= 0) { @@ -131,10 +159,25 @@ bool TConfig::exist(const char* var, int index) return _data.is_key(var); } -TString& TConfig::get(const char* var, const char* section, int index, const char* def) +// @mfunc Ritorna il valore della variabile nella sezione corrente o in +// quella specificata +// +// @rdesc Ritorna la stringa contenuta nella variabile, se questa esiste, altrimenti +// il valore di default che dovrebbe assumere determinato dal parametro +//

+TString& TConfig::get( + const char* var, // @parm Variabile della quale ritornare il valore + const char* section, // @parm Sezione della varaibile (default NULL) + int index, // @parm Eventuale indice della varaibailie (default -1) + const char* def) // @parm Valore default della varaibile (default "") + + // @comm Passando

= 0 viene appeso al nome della variabile per + // implementare un array. + // Il paragrafo passato in

diventa quello attivo. + // + // @xref + // { - // ritorna valore di variabile nella sezione corrente o in - // quella specificata HIDDEN TString256 s; const char* v = var; @@ -158,7 +201,24 @@ TString& TConfig::get(const char* var, const char* section, int index, const cha return s; } -long TConfig::get_long(const char* var, const char* section, int index, long def) +// @mfunc Ritorna il valore della variabile nella sezione corrente o in +// quella specificata +// +// @rdesc Ritorna il numero contenuto nella variabile, se questa esiste, altrimenti +// il valore di default che dovrebbe assumere determinato dal parametro +//

+long TConfig::get_long( + const char* var, // @parm Variabile della quale ritornare il valore + const char* section, // @parm Sezione della varaibile (default NULL) + int index, // @parm Eventuale indice della varaibailie (default -1) + long def) // @parm Valore default della varaibile (default 0L) + + // @comm Passando

= 0 viene appeso al nome variabile per + // implementare un array. + // Il paragrafo passato in

diventa quello attivo. + // + // @xref + // { const char* n = get(var,section,index); if (*n) @@ -168,13 +228,51 @@ long TConfig::get_long(const char* var, const char* section, int index, long def return def; } -int TConfig::get_int(const char* var, const char* section, int index, int def) +// @mfunc Ritorna il valore della variabile nella sezione corrente o in +// quella specificata +// +// @rdesc Ritorna l'intero contenuto nella variabile, se questa esiste, altrimenti +// il valore di default che dovrebbe assumere determinato dal parametro +//

+int TConfig::get_int( + const char* var, // @parm Variabile della quale ritornare il valore + const char* section, // @parm Sezione della varaibile (default NULL) + int index, // @parm Eventuale indice della varaibailie (default -1) + int def) // @parm Valore default della varaibile (default 0) + + // @comm Chiama la funzione e ne ritorna un intero. + // Passando

= 0 viene appeso al nome variabile per + // implementare un array. + // Il paragrafo passato in

diventa quello attivo. + // + // @xref + // { return (int)get_long(var, section, index, def); } -bool TConfig::get_bool(const char* var, const char* section, int index, bool def) +// @mfunc Ritorna il valore della variabile nella sezione corrente o in +// quella specificata +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se la varabile e' settata con X +// @flag FALSE | Se la varabile nen e' settata con X +// @flag

| Se la varabile non esiste +bool TConfig::get_bool( + const char* var, // @parm Variabile della quale ritornare il valore + const char* section, // @parm Sezione della varaibile (default NULL) + int index, // @parm Eventuale indice della varaibailie (default -1) + bool def) // @parm Valore default della varaibile (default FALSE) + + // @comm Viene chiamata la funzione . + // Passando

= 0 viene appeso al nome variabile per + // implementare un array. + // Il paragrafo passato in

diventa quello attivo. + // + // @xref + // { if (def) strcpy(__tmp_string, "X"); else *__tmp_string = '\0'; @@ -191,7 +289,20 @@ HIDDEN void RGB_COLOR(COLOR c, int& r, int& g, int& b) b = int(c) & 0xFF; } -COLOR TConfig::get_color(const char* var, const char* section, int index, COLOR def) +// @mfunc Ritorna il valore del colore settato nella variabile nella +// sezione corrente o in quella specificata +COLOR TConfig::get_color( + const char* var, // @parm Variabile della quale ritornare il valore + const char* section, // @parm Sezione della varaibile (default NULL) + int index, // @parm Eventuale indice della varaibailie (default -1) + COLOR def) // @parm Valore default della varaibile (default 0) + + // @comm Passando

= 0 viene appeso al nome variabile per + // implementare un array. + // Il paragrafo passato in

diventa quello attivo. + // + // @xref + // { const char* c = get(var, section, index); if (*c) @@ -210,12 +321,28 @@ COLOR TConfig::get_color(const char* var, const char* section, int index, COLOR return def; } -bool TConfig::set(const char* var, const char* value, const char* section, - bool force, int index) +// @mfunc Setta la variabile nella sezione corrente o specificata +// +// @rdesc Ritorna i seguenti valori: +// +// @flag TRUE | Se la variabile era gia' esistente +// @flag FALSE | Se la variabile non era gia' esistente +bool TConfig::set( + const char* var, // @parm Nome della variabile da settare + const char* value, // @parm Stringa da assegnare alla variabile + const char* section, // @parm Nome del paragrafo a cui appartiene la variabile + bool force, // @parm Per la creazione di una variabile inesistente + int index) // @parm Eventuale indice della variabile + // @parm long | value | Valore da assegnare alla variabile { - // setta variabile nella sezione corrente o specificata - // se force == TRUE crea la variabile se non esiste; altrimenti - // da' errore; ritorna TRUE se la variabile c'era, FALSE diversamente + // @syntax set(const char* var, const char* value, const char* section, bool force, int index); + // @syntax set(const char* var, long value, const char* section, bool force, int index); + // + // @comm Se

== TRUE crea il paragrafo e la variabile se non esistono; + // altrimenti da' errore. + // Passando

= 0 viene appeso al nome variabile per + // implementare un array. + // Il paragrafo passato in

diventa quello attivo. set_paragraph(section); TString vvar(var); if (index != -1) vvar << '(' << index << ')'; @@ -239,7 +366,14 @@ bool TConfig::set(const char* var, long value, const char* section, return set(var,t,section,force,index); } -word TConfig::items(const char* var, const char* section) +// @mfunc Ritorna quanti elementi dell'array nominato sono presenti nella +// sezione indicata. +word TConfig::items( + const char* var, // @parm Nome dell'array + const char* section) // @parm Sezione indicata + + // @comm Il paragrafo passato in

diventa quello attivo. + // Possono esserci dei "buchi" causati da set() errate { set_paragraph(section); TString vvar(16); @@ -252,7 +386,15 @@ word TConfig::items(const char* var, const char* section) return cnt; } -void TConfig::init(const char *fn, const char* pa) +// @doc INTERNAL + +// @mfunc Inizializza il paragrafo leggendo dal file i dati +void TConfig::init( + const char *fn, // @parm Nome del file da leggere + const char* pa) // @parm Nome del paragrafo da utilizzare + + // @comm Apre il file

e cerca il paragrafo

. Se il file non esiste + // viene creato con il paragrafo passato. { _file = fn; _paragraph = pa; @@ -274,6 +416,8 @@ void TConfig::init(const char *fn, const char* pa) } +// @doc EXTERNAL + TConfig::TConfig(int which_config, const char* paragraph) { switch (which_config) diff --git a/include/config.h b/include/config.h index 7bad3b63e..37f131de1 100755 --- a/include/config.h +++ b/include/config.h @@ -9,6 +9,8 @@ #include #endif +// @doc EXTERNAL + class ofstream; // questo sara' il principale, per ora non c'e' @@ -26,65 +28,99 @@ class ofstream; // file parametri golem #define CONFIG_GOLEM 6 +// @class TConfig | Classe per la gestione dei file di configurazione in formato +// Windows +// +// @base public | TObject class TConfig : public TObject { - TAssoc_array _data; - TFilename _file; - bool _dirty, _ispresent; - TString _paragraph; + // @comm Sono definite alcune costanti per l'individuazione immediata di + // alcuni file particolari e di frequente uso. Tali file sono: + // + // @flag CONFIG_GENERAL | Questo sara' il principale, per ora non c'e' + // @flag CONFIG_STUDIO | File parametri studio (uno per studio, per ora e' + // il principale) + // @flag CONFIG_DITTA | File parametri ditta (uno per ditta) + // @flag CONFIG_FCONV | File conversioni archivi + // @flag CONFIG_USER | File parametri utente + // @flag CONFIG_STAMPE | File parametri stampe + // @flag CONFIG_GOLEM | File parametri golem + + // @access Private Member + + // @cmember Contenuto del paragrafo + TAssoc_array _data; + // @cmember Nome del file di configurazione + TFilename _file; + // @cmember Indica se il file??? e' presente (TRUE se esiste) + bool _dirty; + // @cmember Indica se il paragrafo e' presente (TRUE se esiste) + bool _ispresent; + // @cmember Nome del paragrafo attivo + TString _paragraph; + + // @access Protected Member protected: + // @cmember Legge i dati del paragrafo bool _read_paragraph(); + // @cmember Scrive i dati del paragrafo void _write_paragraph(ofstream&); + // @cmember Scrive il file di configurazione void _write_file(); + // @cmember Inizializza il paragrafo leggendo dal file i dati void init(const char *fn, const char* pa); + // @access Public Memeber public: - // ritorna valore di variabile nella sezione corrente o in - // quella specificata; se non c'e' ritorna "" - // passando index >=0 viene appeso al nome variabile per - // implementare un mezzo cazzo di array + // @cmember Ritorna il valore della variabile nella sezione corrente o in + // quella specificata TString& get(const char* var, const char* section = NULL, int index = -1, const char* def = ""); - // questa ritorna 0 se non c'e', il che e' un po' sfigotto + // @cmember Ritorna il valore della variabile nella sezione corrente o in + // quella specificata (se la variabile contiene un long) long get_long(const char* var, const char* section = NULL, int index = -1, long def = 0L); + // @cmember Ritorna il valore della variabile nella sezione corrente o in + // quella specificata (se la variabile contiene un int) int get_int(const char* var, const char* section = NULL, int index = -1, int def = 0); - // questa ritorna FALSE se non c'e', il che e' ancora piu' sfigotto + // @cmember Ritorna il valore della variabile nella sezione corrente o in + // quella specificata (se la variabile contiene un bool) bool get_bool(const char* var, const char* section = NULL, int index = -1, bool def = FALSE); + // @cmember Ritorna il valore del colore settato nella variabile nella + // sezione corrente o in quella specificata COLOR get_color(const char* var, const char* section = NULL, int index = -1, COLOR def = 0); - // setta variabile nella sezione corrente o specificata - // se force == TRUE crea la sezione/variabile se non esiste; altrimenti - // da' errore; ritorna TRUE se la sezione/var c'era, FALSE diversamente - // index come per get() - bool set(const char* var, const char* value, const char* section = NULL, - bool force = TRUE, int index = -1); - bool set(const char* var, long value, const char* section = NULL, - bool force = TRUE, int index = -1); + // @cmember Setta la variabile nella sezione corrente o specificata + bool set(const char* var, const char* value, const char* section = NULL, bool force = TRUE, int index = -1); + // @cmember Setta la variabile nella sezione corrente o specificata + bool set(const char* var, long value, const char* section = NULL, bool force = TRUE, int index = -1); + // @cmember Controlla se esite una variabile nel paragrafo attivo bool exist(const char* var, int index = -1); - // TRUE se il paragrafo corrente e' nuovo - bool new_paragraph() { return !_ispresent; } + // @cmember Controlla se il paragrafo corrente e' nuovo (TRUE se nuovo) + bool new_paragraph() + { return !_ispresent; } - // items ritorna quanti elementi dell'array nominato sono - // presenti nella sezione indicata - // non si risponde di eventuali "buchi" causati da set() errate + // @cmember Ritorna quanti elementi dell'array nominato sono presenti nella + // sezione indicata. word items(const char* var, const char* section); - - // Setta il paragrafo corrente + // @cmember Setta il paragrafo passato come quello attivo void set_paragraph(const char* par); - // il paragrafo iniziale e' il modulo corrente salvo diversa indicazione + // @cmember Costruttore (il paragrafo iniziale e' il modulo corrente + // salvo diversa indicazione) TConfig(int which_config = CONFIG_GENERAL, const char* paragraph = NULL); + // @cmember Costruttore (il paragrafo iniziale e' il modulo corrente + // salvo diversa indicazione) TConfig(const char* file, const char* paragraph = NULL); - // il distruttore riscrive il file con le modifiche se necessrio, + // @ cmember Distruttore. Riscrive il file con le modifiche se necessrio, virtual ~TConfig(); }; diff --git a/include/date.h b/include/date.h index c20e16208..8e36c1a91 100755 --- a/include/date.h +++ b/include/date.h @@ -56,8 +56,7 @@ protected: // @access Public Member public: // @cmember Ritorna la data in formato di stringa (anche in formato ANSI) - char* string(TDate_mgafmt year = full, char sep = '-', TDate_mgafmt day = full, - TDate_mgafmt month = full, TDate_order ord = gma_date) const ; + char* string(TDate_mgafmt year = full, char sep = '-', TDate_mgafmt day = full, TDate_mgafmt month = full, TDate_order ord = gma_date) const ; // @cmember Ritorna il giorno int day() const ; diff --git a/include/execp.cpp b/include/execp.cpp index c925f918a..2bb87a4dc 100755 --- a/include/execp.cpp +++ b/include/execp.cpp @@ -1,5 +1,3 @@ -// fv 6/10/93 - #include #include @@ -19,7 +17,18 @@ #include #include +// @doc EXTERNAL + +// @mfunc Controlla se il processo puo' essere eseguito +// +// @rdesc Ritorna i seguenti valori: +// +// @flag TRUE | Se l'applicazione puo' essere eseguita +// @flag FALSE | Se l'applicazione non puo' essere eseguita bool TExternal_app::can_run() const + +// @comm Se si opera sotto Windows si controlla se vi sono risorse necessarie +// per l'esecuzione del processo, altrimenti viene tornato sempre TRUE. { #if XVT_OS == XVT_OS_WIN const TFixed_string p(_path); @@ -32,8 +41,14 @@ bool TExternal_app::can_run() const #endif } +// @mfunc Esegue il processo +int TExternal_app::run( + bool async, // @parm Per eseguire il processo in parallelo (default FALSE) + bool utente) // @parm Permette di inserire il nome dell'utente nella riga + // di comando(default FALSE) + + // @comm Se

e' FALSE aspetta che termini il processo in esecuzione prima di iniziare il nuovo -int TExternal_app::run(bool async, bool utente) { TString256 path(_path); diff --git a/include/execp.h b/include/execp.h index 0bb829719..91b63d62a 100755 --- a/include/execp.h +++ b/include/execp.h @@ -1,6 +1,3 @@ -// execp.h; trattasi di -*-c++-*- -// fv 6/10/93 - #ifndef __EXECP_H #define __EXECP_H @@ -8,26 +5,46 @@ #include #endif -// Class for external object execution with optional background -// exec under UNIX and swap on EMS under DOS -// Manages restoring the XVT status -// No command line is implemented; user is supposed to use the -// mailbox for this +// @doc EXTERNAL +// @class TExternal_app | Classe per l'esecuzione di oggetti esterni +// +// @base public | TObject class TExternal_app : public TObject + +// @comm Gli oggetti eseguiti dalla presente classe possono essere eseguiti +// in background in tutti gli ambienti, oppure in modo sincrono. +// Non sono implementate linee di comando; si suppone che l'utente +// utilizzi la mailbox per questo. { - const char* _path; // app name (must be allocated by user) - int _error; // last error (errno code) - int _exitcode; // last exit code - int _count; // count of calls + // @access Private Member + // @cmember Nome dell'applicazione (deve essere allocata dall'utente) + const char* _path; + // @cmember Ultimo errore (codice dell'errore) + int _error; + // @cmember Ultimo exit code + int _exitcode; + // @cmember Numero di chiamate + int _count; + + // @access Public Member public: + // @cmember Controlla se il processo puo' essere eseguito bool can_run() const; + // @cmember Esegue il processo int run(bool async = FALSE, bool user = TRUE); - int error() { return _error;}; - int exitcode() { return _exitcode;}; - int count() { return _count; }; + // @cmember Ritorna il codice dell'ultimo errore + int error() + { return _error;}; + // @cmember Ritorna il l'ultimo codice di uscita + int exitcode() + { return _exitcode;}; + // @cmember Ritorna il numero di chiamate effettuate + int count() + { return _count; }; + // @cmember Costruttore TExternal_app(const char* p); }; diff --git a/include/expr.h b/include/expr.h index f454b45b8..10d92e648 100755 --- a/include/expr.h +++ b/include/expr.h @@ -9,48 +9,101 @@ #include #endif -// @T -// @DES I simboli/istruzioni possibili -// @T +// @doc INTERNAL -enum TCodesym { _invalid, _endsym, _comma, _lpar, _rpar, _variable, - _number, _string, _plus, _minus, _multiply, _divide, - _chgs, _and, _or, _not, _equal, _match, _noteq, _lt, _gt, - _lteq, _gteq, _sqrt, _sqr, _exp10, _exp, _log10, _log, - _sin, _cos, _tan, _left, _right, _pow, _min, _max, _mid, - _upper, _round } ; +// @enum TCodesym | Lista di simboli/istruzioni possibili +enum TCodesym { + _invalid, // @emem Simbolo non riconosciuto + _endsym, // @emem Segnaposto per simbolo finale + _comma, // @emem Simbolo virgola "," + _lpar, // @emem Simbolo aperta parentesi "(" + _rpar, // @emem Simbolo chiusa parentesi ")" + _variable, // @emem Nome di una variabile + _number, // @emem Numero + _string, // @emem Stringa + _plus, // @emem Simbolo piu' "+" + _minus, // @emem Simbolo meno "-" + _multiply, // @emem Simbolo per "*" + _divide, // @emem Simbolo diviso "/" + _chgs, // @emem MENO unario + _and, // @emem AND logico + _or, // @emem OR logico + _not, // @emem NOT logico + _equal, // @emem Simbolo uguale "=" + _match, // @emem Confronto tra stringhe con wildcards + _noteq, // @emem Simbolo diverso "!=" + _lt, // @emem Simbolo minore "" + _gt, // @emem Simbolo maggiore "" + _lteq, // @emem Simbolo minore o uguale "=" + _gteq, // @emem Simbolo maggiore o uguale "=" + _sqrt, // @emem Radice quadrata + _sqr, // @emem Elevamento al quadrato + _exp10, // @emem Funzione 10 a potenza + _exp, // @emem Funzione e (nepero) elevato a + _log10, // @emem Logaritmo in base 10 + _log, // @emem Logaritmo naturale + _sin, // @emem Funzione seno + _cos, // @emem Funzione coseno + _tan, // @emem Funzione tangente + _left, // @emem Primi caratteri di una stringa + _right, // @emem Ultimi caratteri di una stringa + _pow, // @emem Elevamento a potenza + _min, // @emem Minimo tra piu' elementi + _max, // @emem Massimo tra piu' elementi + _mid, // @emem Media degli elementi + _upper, // @emem Trasformazione in maiuscolo + _round } ; // @emem Arrotondamento - // @DES I tipi di espressioni definiti - // @T - enum TTypeexp { _numexpr, _strexpr } ; - // @END + // @enum TTypeesp | Tipi di espressioni definiti + enum TTypeexp { + _numexpr, // @emem Espressione numerica + _strexpr } ; // @emem Espressione in lettere - // @C - // Classe TValue : public TObject - // @END - - class TValue : public TObject + // @class TValue | Classe per la definizione dei valori che possono essere assunti + // dai termini di una espressione o il valore dell'espressione stessa + // + // @base public | TObject + class TValue : public TObject { - // @DPRIV - real _r; // Valore real - TString _s; // Valore in formato stringa + // @access Private Member + // @cmember Valore real + real _r; + // @cmember Valore in formato stringa + TString _s; + + // @access Public Member public: - // @FPUB + // @cmember Assegnamento tra oggetti TValue + TValue& operator =(const TValue& val) + { _s = val._s; _r = val._r; return *this;} + // @cmember Ritorna il valore numerico + const real& number() const + { return _r;} + // @cmember Ritorna il valore come stringa + const char* string() const + { return (const char*) _s;} + // @cmember Setta il valore passato come real + void set(const real& val) + { _r = val; _s = val.string();} + // @cmember Setta il valore passato come stringa + void set(const char* val) + { _s = val; _r = real(val);} - TValue& operator =(const TValue& val) { _s = val._s; _r = val._r; return *this;} // Operatore = tra oggetti TValue - const real& number() const { return _r;} // Ritorna il valore numerico - const char* string() const { return (const char*) _s;} // Ritorna il valore come stringa - void set(const real& val) { _r = val; _s = val.string();} // Real - void set(const char* val) { _s = val; _r = real(val);} // Stringa - - // @DES Costruttori. Inizializzano TValue con vari oggetti - // @FPUB - TValue(const real& val) { _r = val; _s = val.string();} // Real - TValue(const char* val) { _s = val; _r = real(val);} // Stringa - TValue(const TValue& val) { *this = val; } // Altro TValue - TValue() { _r = 0.00; _s = ""; } // 0,0 e "" - virtual ~TValue() {} + // @cmember Costruttore. Inizializza TValue con un reale + TValue(const real& val) + { _r = val; _s = val.string();} + // @cmember Costruttore. Inizializza TValue con una stringa + TValue(const char* val) + { _s = val; _r = real(val);} + // @cmember Costruttore. Inizializza TValue con un altro TValue + TValue(const TValue& val) + { *this = val; } + // @cmember Costruttore. Inizializza TValue a 0,0 e "" + TValue() { _r = 0.00; _s = ""; } + // @cmember Distruttore + virtual ~TValue() + {} }; @@ -58,187 +111,302 @@ public: #define extern #endif -// @DPUB extern TValue nulltvalue; -// @END #undef extern -// @C -// Classe TCode : public TObject -// @END - +// @class TCode | Classe per la ridefinizione di una espressione in +// notazione polacca inversa (RPN) +// +// @base public | TObject class TCode : public TObject { - // @DPRIV - TCodesym _sym; // Simbolo-istruzione-codice - TValue _val; // Valore + // @access Private Member + // @cmember Simbolo-istruzione-codice + TCodesym _sym; + // @cmember Valore + TValue _val; + + // @access Public Member public: - // @FPUB + // @cmember Assegnamento tra oggetti TCode TCode& operator =(const TCode& b); - void set(TCodesym sym, const TValue& val = nulltvalue) { _sym = sym; _val = val; } // Inizializza simbolo = sym e valore = val - TCodesym getsym() const { return _sym;} // Ritorna il simbolo _sym - const real& number() const { return _val.number();} // Ritorna il valore _val come real - const char* string() const { return _val.string();} // Ritorna il valore _val come stringa + // @cmember Inizializza simbolo e valore + void set(TCodesym sym, const TValue& val = nulltvalue) + { _sym = sym; _val = val; } + // @cmember Ritorna il simbolo + TCodesym getsym() const + { return _sym;} + // @cmember Ritorna il valore come real + const real& number() const + { return _val.number();} + // @cmember Ritorna il valore come stringa + const char* string() const + { return _val.string();} - TCode() {set(_invalid);} // Costruttore, inizializza simbolo con "invalid", valore a nullvalue - TCode(TCodesym sym, const TValue& val = nulltvalue) { set(sym, val);} // Costruttore, inizializza simbolo con sym e valore con val - virtual ~TCode() {} + // @cmember Costruttore, inizializza simbolo con "invalid", valore a nullvalue + TCode() + {set(_invalid);} + TCode(TCodesym sym, const TValue& val = nulltvalue) + // @cmember Costruttore, inizializza simbolo con

e valore con

+ { set(sym, val);} + // @cmember Distruttore + virtual ~TCode() + {} }; -// @C -// Classe TCodearray : public TObject -// -// L'array di istruzioni +// @class TCodearray | Classe per la definizione di un array di istruzioni da valutare +// passo per passo in una espressione // -// @END - +// @base public | TObject class TCodearray : public TObject { - // @DPRIV - int _last; // Numero di istruzioni - int _ip; // Puntatore all'istruzione corrente (Istruction pointer) - TArray _rpn; // Array - // @END + // @access Private Member + // @cmember Numero di istruzioni + int _last; + // @cmember Puntatore all'istruzione corrente (Istruction pointer) + int _ip; + // @cmember Array + TArray _rpn; + + // @access Public Member public: - // @FPUB - void clear(); // Cancella contenuto array - void add(TCodesym sym, const TValue& val = nulltvalue); // Aggiunge un'istruzione all'array - void begin() { _ip = 0;} // Mette all'inizio il puntatore all'istruzione corrente - TCode& step() { return (TCode&) _rpn[end() ? _ip : _ip++];} // Incrementa istruction pointer - bool end() const { return ((TCode&) _rpn[_ip]).getsym() == _endsym;} // Ritorna vero se _ip ha raggiunto il simbolo di fine codice - void backtrace(int step = 1) { if (_ip > step) _ip -= step; else begin(); } - TCodearray(int size = 50); // Il costruttore crea un array di 10 elementi - virtual ~TCodearray() {} + // @cmember Cancella contenuto array + void clear(); + // @cmember Aggiunge un'istruzione all'array + void add(TCodesym sym, const TValue& val = nulltvalue); + // @cmember Posiziona all'inizio il puntatore all'istruzione corrente + void begin() + { _ip = 0;} + // @cmember Incrementa l'istruction pointer + TCode& step() + { return (TCode&) _rpn[end() ? _ip : _ip++];} + // @cmember Ritorna TRUE se l'istruction pointer ha raggiunto il simbolo di fine codice + bool end() const + { return ((TCode&) _rpn[_ip]).getsym() == _endsym;} + // @cmember Sposta indietro l'istruction pointer di

passi (si ferma + // quando trova l'inizio del puntatore) + void backtrace(int step = 1) + { if (_ip > step) _ip -= step; else begin(); } + // @cmember Costruttore. Crea un array di 10 elementi + TCodearray(int size = 50); + // @cmember Distruttore + virtual ~TCodearray() + {} }; -// @C -// Classe TVar : public TObject -// @END - +// @class TVar | Classe per la definizione delle variabile delle espressioni +// +// @base public | TObject class TVar : public TObject { - // @DPRIV - TString _name; // Nome variabile - TValue _val; // Valore + // @access Private Member + // @cmember Nome della variabile + TString _name; + // @cmember Valore assegnato alla variabile + TValue _val; + + // @access Public Member public: - // @DES Operatore = tra vari oggetti - // @FPUB - const char* operator =(const char* val) { _val.set(val); return val;} - const real& operator =(const real& val) { _val.set(val); return val;} - TVar& operator =(const TValue& val) { _val = val; return *this;} - TVar& operator =(const TVar& var) { _name = var._name ; _val = var._val; return *this;} - void set(const char* name, const TValue& val = nulltvalue) { _name = name ; _val = val;} - void setname(const char* name) { _name = name;} // Setta a name il nome della variabile - const char* getname() const { return _name;} // Ritorna il nome della variabile + // #DES Operatore = tra vari oggetti + // #FPUB + // @cmember Assegnamento di una stringa all'oggetto Tval + const char* operator =(const char* val) + { _val.set(val); return val;} + // @cmember Assegnamento di un numero all'oggetto TVal + const real& operator =(const real& val) + { _val.set(val); return val;} + // @cmember Assegamento di un oggetto + TVar& operator =(const TValue& val) + { _val = val; return *this;} + // @cmember Assegnamento tra oggetti TVal + TVar& operator =(const TVar& var) + { _name = var._name ; _val = var._val; return *this;} + // @cmember Setta l'oggetto TVal con il nome e il valore passati + void set(const char* name, const TValue& val = nulltvalue) + { _name = name ; _val = val;} + // @cmember Setta a name il nome della variabile + void setname(const char* name) + { _name = name;} + // @cmember Ritorna il nome della variabile + const char* getname() const + { return _name;} - operator TValue&() { return _val;} // Ritorna _val (un TValue) - const real& number() const { return _val.number();} // Ritorna il valore real della variabile - const char* string() const { return _val.string();} // Ritorna il valore stringa della variabile + // @cmember Ritorna _val (un TValue) + operator TValue&() + { return _val;} + // @cmember Ritorna il valore real della variabile + const real& number() const + { return _val.number();} + // @cmember Ritorna il valore stringa della variabile + const char* string() const + { return _val.string();} - // @DES Costruttori - // @FPUB - TVar() { _name = ""; _val = nulltvalue;} - TVar(const char* name, const TValue& val = nulltvalue) { _name = name; _val = val;} - TVar(TVar& v) { _name = v._name; _val = v._val;} - virtual ~TVar() {} + // @cmember Costruttore (assegna "" ed il valore nulltvalue) + TVar() + { _name = ""; _val = nulltvalue;} + // @cmember Costruttore (assegna nome e valore passato) + TVar(const char* name, const TValue& val = nulltvalue) + { _name = name; _val = val;} + // @cmember Costruttore (assegna l'oggetto TVal passato) + TVar(TVar& v) + { _name = v._name; _val = v._val;} + // @cmember Distruttore + virtual ~TVar() + {} }; -// @C -// class TVararray : public TObject -// @END - +// @class TVararray | Classe per la definizione di un array di variabili da +// valutare nell'esspressione +// +// @base public | TObject class TVararray : public TObject { - // @DPRIV - int _last; // Numero di variabili - TArray _array; // Array - // @END + // @access Private Member + // @cmember Numero di variabili + int _last; + // @cmember Array + TArray _array; + + // @access Public Member public: - // @FPUB - void clear() { _last = 0; } // Cancella contenuto array - void add(const TVar& var); // Aggiunge un oggetto TVar - void add(const char* name, const TValue& val = nulltvalue); // Aggiunge un nome di variabile e il suo valore - const char* varname(int varnum) const { return varnum < _array.items() ? ((TVar&) _array[varnum]).getname() : "";} // Ritorna il nome della variabile di posto varnum + // @cmember Cancella il contenuto dell'array + void clear() + { _last = 0; } + // @cmember Aggiunge un oggetto TVar + void add(const TVar& var); + // @cmember Aggiunge un nome di variabile e il suo valore + void add(const char* name, const TValue& val = nulltvalue); + // @cmember Ritorna il nome della variabile di posto varnum + const char* varname(int varnum) const + { return varnum < _array.items() ? ((TVar&) _array[varnum]).getname() : "";} - // @DES Metodi di inizializzazione - // @FPUB + // @cmember Setta l'oggetto TVararray con il nome e il valore della variabile void set(const char* varname, const real& val); + // @cmember Setta l'oggetto TVararray con il nome e il valore della variabile + // (passato come stringa) void set(const char* varname, const char* val); - void set(int varnum, const real& val) { if (varnum < _array.items()) ((TVar&) _array[varnum]) = val;} - void set(int varnum, const char* val) { if (varnum < _array.items()) ((TVar&) _array[varnum]) = val;} + // @cmember Setta l'elemnto dell varaibile

-esima al valore passato + void set(int varnum, const real& val) + { if (varnum < _array.items()) ((TVar&) _array[varnum]) = val;} + // @cmember Setta l'elemnto dell varaibile

-esima al valore passato + // come stringa + void set(int varnum, const char* val) + { if (varnum < _array.items()) ((TVar&) _array[varnum]) = val;} - // @DES Metodi di interrogazione - // @FPUB + // @cmember Ritorna il valore della variabile con nome

const real& getnum(const char* varname); + // @cmember Ritorna il valore della variabile di posto

-esimo const real& getnum(int varnum); + // @cmember Ritorna il nome della variabile con nome

const char* getstring(const char* varname); + // @cmember Ritorna il nome della variabile di posto

-esimo const char* getstring(int varnum); - int numvar() const { return _last;} // Ritorna il numero di variabili utilizzate + // @cmember Ritorna il numero di variabili utilizzate + int numvar() const + { return _last;} - TVararray(int size = 10); - virtual ~TVararray() {} + // @cmember Costruttore + TVararray(int size = 10); + // @cmember Distruttore + virtual ~TVararray() + {} }; -// @C -// class TExpression : public TObject -// @END +// @doc EXTERNAL +// @class TExpression | Classe per la interpretazione e valutazione di espressioni +// numerica e di stringhe +// +// @base public | TObject class TExpression : public TObject { - // @DPRIV - TCodearray _code; // Array di codice - TVararray _var; // Array di variabili - TValue _val; // Valore dell'espressione - bool _dirty; // Vero se l'espressione e' stata modificata - TTypeexp _type; // Tipo dell'espressione - TString _original; // stringa originale + // @access Provate Member - // @END + // @cmember Array di codice + TCodearray _code; + // @cmember Array di variabili + TVararray _var; + // @cmember Valore dell'espressione + TValue _val; + // @cmember TRUE se l'espressione e' stata modificata + bool _dirty; + // @cmember Tipo dell'espressione + TTypeexp _type; + // @cmember Stringa originale + TString _original; - // @FPROT + // @access Protected Member protected: - void eval(); // Valuta l'espressione + // @cmember Valuta (calcola) l'espressione + void eval(); + // @cmember Ritorna il prossimo token dell'espressione (se

e' TRUE interpreta + // la virgola come un token) TCodesym __gettoken(bool reduct = FALSE); + // @cmember Ritorna il prossimo fattore TCodesym __factor(TCodesym startsym); + // @cmember Ritorna il prossimo termine TCodesym __term(TCodesym startsym); + // @cmember Ritorna la prossima espressione TCodesym __expression(TCodesym startsym); + // @cmember Compila l'espressione + bool compile(const char* expression, TTypeexp type); + +protected: // TObject + // @cmember Stampa l'espressione su

(serve per implementare l'insertore) virtual void print_on(ostream& out) const ; - bool compile(const char* expression, TTypeexp type); // Compila l'espressione + // @access Protected Member public: - // @FPUB - operator const real&(); // Ritorna il valore real dell'espressione - operator const char*(); // Ritorna il valore come stringa - operator bool(); // Ritorna il valore come booleano - // @DES Metodi di interrogazione - // @FPUB - // Ritorna il nome della variabile di posto varnum - const char* varname(int varnum) const { return _var.varname(varnum); } - // Ritorna il numero di variabili nell'espressione - int numvar() const { return _var.numvar(); } - const TTypeexp type() const { return _type; } - TCodearray& code() const { return (TCodearray&)_code; } - const TVararray& vars() const { return _var; } + // @cmember operator const | real& | | Ritorna il valore real dell'espressione + operator const real&(); + // @cmember operator const | char* | | Ritorna il valore dell'espressione come stringa + operator const char*(); + // @cmember Ritorna il valore dell'espressione come booleano + operator bool(); + // @cmember Ritorna il nome della variabile di posto

+ const char* varname(int varnum) const + { return _var.varname(varnum); } + // @cmember Ritorna il numero di variabili nell'espressione + int numvar() const + { return _var.numvar(); } + // @cmember Ritorna il tipo dell'espressione + const TTypeexp type() const + { return _type; } + TCodearray& code() const + // @cmember Ritorna l'array del codice + { return (TCodearray&)_code; } + // @cmember Ritorna l'array di variabili + const TVararray& vars() const + { return _var; } - // @DES Metodi di inizializzazione - // @FPUB + // @cmember Setta la variabile con nome e numero void setvar(const char* varname, const real& val); + // @cmember Setta la variabile con poszione e numero void setvar(int varnum, const real& val); + // @cmember Setta la variabile con nome e valore passato come stringa void setvar(const char* varname, const char* val); + // @cmember Setta la variabile passato co poszione e numero passato come stringa void setvar(int varnum, const char* val); - void set_type(const TTypeexp type) { _type = type; } - + // @cmember Setta il tipo dell'espressione + void set_type(const TTypeexp type) + { _type = type; } + // @cmember Setta l'espressione e la compila (ritorna il risultato della compilazione) bool set(const char* expression, TTypeexp type = _numexpr); + + // @cmember Costruttore (assegna l'estressione e il suo tipo) TExpression(const char* expression, TTypeexp type = _numexpr); + // @cmember Costruttore (assegna il tipo dell'istruzione) TExpression(TTypeexp type = _numexpr); - virtual ~TExpression() {} + // @cmember Distruttore + virtual ~TExpression() + {} }; #endif // __EXPR_H diff --git a/include/real.cpp b/include/real.cpp index cd66788a6..68a7c13db 100755 --- a/include/real.cpp +++ b/include/real.cpp @@ -14,6 +14,8 @@ HIDDEN real __tmp_real; HIDDEN char __string[80]; const real ZERO (0.0); +// @doc EXTERNAL + real::real () { dzero (ptr ()); @@ -90,11 +92,11 @@ bool real::is_natural (const char *s) if (*s) { while (isdigit(*s)) - s++; + s++; ok = *s == '\0'; } else ok = FALSE; - + } return ok; } @@ -173,7 +175,15 @@ bool real::is_zero () const return diszero (ptr ()); } +// @mfunc Ritorna il segno del reale +// +// @rdesc Ritorna i seguenti valori: +// +// @flag 0 | Se il numero e' minore di 0 +// @flag = 0 | Se il numero e' uguale a 0 +// @flag 0 | Se il numero e' maggiore di 0 int real::sign () const + { return dsign (ptr ()); } @@ -191,7 +201,25 @@ long real::integer () const } // Certified 91% -char *real::string (int len, int dec, char pad) const +// @mfunc Trasforma un reale in stringa +// +// @rdesc Ritorna la stringa nella lunghezza richiesta +char *real::string ( + int len, // @parm Lunghezza della stringa (compreso decimali) + int dec, // @parm Numero di decimali (default UNDEFINED) + char pad) const // @parm Carattere di riempimento (default ' ') + // @parm char * | picture | Formato della stringa + + // @syntax string (int len, int dec, char pad); + // @syntax string (const char *picture); + // + // @comm Nel primo caso ritorna una stringa lunga

con

decimali e + // inserisce nella stringa stessa il carattere

nel caso la + // lunghezza richiesta sia maggiore di quella che risulterebbe per la + // completa rappresentazione del reale. + // Nel secondo caso ritorna la stringa con il formato stabilito in + //

. + { __tmp_real = *this; if (dec != UNDEFINED) @@ -283,8 +311,8 @@ char *real ::literals () const centinaia << decine[d]; v -= d * 10; } - - if (v > 0) + + if (v > 0) { if (v > 1) { @@ -299,7 +327,7 @@ char *real ::literals () const else centinaia = uni[migliaia]; } - + risultato.insert(centinaia, 0); } @@ -388,18 +416,18 @@ char *real ::string (const char *picture) j--; if (z == '~') c = ' '; - else + else { if (c == '@') c = (z == '@') ? '0' : ' '; else - if (c == '-' && f[i+1] == '.') + if (c == '-' && f[i+1] == '.') { f[i+1] = '-'; c = ' '; } - } - + } + z = c; } } @@ -421,13 +449,26 @@ char *real ::string (const char *picture) } -ostream & operator << (ostream & out, const real & a) +// @func ostream& | operator | Permette di reindirizzare il numero +// reale per la stampa +// +// @rdesc Ritorna l'utput sul quale e' stata reindirizzata la stampa +ostream & operator << ( + ostream & out, // @parm Indica l'output sul quale stampare il numero + const real & a) // @parm Numero da stampare + { return out << a.string (); } -istream & operator >> (istream & in, real & a) +// @func istream& | operator | Permette di leggere un numero reale +// +// @rdesc Ritorna l'output sul quale e' stato letto il numero +istream & operator >> ( + istream & in, // @parm Input da cui leggere il numero + real & a) // @parm Indirizzo in cui posizionare il numero + { in >> __string; atod (a.ptr (), __string); @@ -441,7 +482,15 @@ int real ::precision () } -real & real ::round (int prec) +// @mfunc real& | real | round | Arrotonda al numero di decimali passati +real & real ::round ( + int prec) // @parm Numero di decimali a cui arrotondare il numero (default 0) + + // @comm Nel caso

sia: + // + // @flag 0 | Arrotonda al decimale + // @flag = 0 | Arrotonda all'intero + // @flag 0 | Arrotonda al valore passato (es. -3 arrotonda alle mille) { if (prec < 0) { @@ -484,7 +533,16 @@ real & real ::trunc (int prec) return *this; } -real operator + (const real & a, const real & b) +// @func real | operator + | Somma due numeri reali +// +// @rdesc Ritorna il valore della somma +real operator + ( + const real & a, // @parm Primo addendo da sommare + const real & b) // @parm Secondo addendo da sommare + + // @syntax operator +(const real &a, const real &b); + // @syntax operator +(double a, const real &b); + // @syntax operator +(const real &a, double b); { dadd (__tmp_real.ptr (), a.ptr (), b.ptr ()); @@ -505,8 +563,16 @@ real operator + (const real & a, double b) return __tmp_real += b; } -real operator - (const real & a, const real & b) +// @func real | operator - | Sottrae due numeri reali +// +// @rdesc Ritorna il valore della sottrazione +real operator - ( + const real & a, // @parm Primo addendo da sottrarre + const real & b) // @parm Secondo addendo da sottrarre + // @syntax operator -(const real &a, const real &b); + // @syntax operator -(double a, const real &b); + // @syntax operator -(const real &a, double b); { dsub (__tmp_real.ptr (), a.ptr (), b.ptr ()); return __tmp_real; @@ -527,7 +593,16 @@ real operator - (const real & a, double b) return __tmp_real -= a; } -real operator *(const real & a, const real & b) +// @func real | operator * | Moltiplica due numeri reali +// +// @rdesc Ritorna il valore della moltiplicazione +real operator *( + const real & a, // @parm Primo numero da moltiplicare + const real & b) // @parm Secondo numero da moltiplicare + + // @syntax operator *(const real &a, const real &b); + // @syntax operator *(double a, const real &b); + // @syntax operator *(const real &a, double b); { dmul (__tmp_real.ptr (), a.ptr (), b.ptr ()); @@ -548,8 +623,17 @@ real operator *(const real & a, double b) return __tmp_real; } -real operator / (const real & a, const real & b) +// @func real | operator / | Divide due numeri reali +// +// @rdesc Ritorna il valore della divisione +real operator / ( + const real & a, // @parm Primo numero da dividere + const real & b) // @parm Secondo numero da dividere + + // @syntax operator /(const real &a, const real &b); + // @syntax operator /(double a, const real &b); + // @syntax operator /(const real &a, double b); { ddiv (__tmp_real.ptr (), a.ptr (), b.ptr ()); return __tmp_real; @@ -571,7 +655,19 @@ real operator / (const real & a, double b) return __tmp_real; } -bool operator > (const real & a, const real & b) + +// @func bool | operator | Controlla se un reale e' maggiore di un altro +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se

e' maggiore di

+// @flag FALSE | Se

e' non maggiore di

+bool operator > ( + const real & a, // @parm Primo numero da conforntare + const real & b) // @parm Secondo numero da confrontare + + // @syntax operator (const real &a, const real &b); + // @syntax operator (double a, const real &b); { return disgt (a.ptr (), b.ptr ()); } @@ -584,7 +680,18 @@ bool operator > (double a, const real & b) return a > n; } -bool operator < (const real & a, const real & b) +// @func bool | operator | Controlla se un reale e' minore di un altro +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se

e' minore di

+// @flag FALSE | Se

e' non minore di

+bool operator < ( + const real & a, // @parm Primo numero da conforntare + const real & b) // @parm Secondo numero da confrontare + + // @syntax operator (const real &a, const real &b); + // @syntax operator (double a, const real &b); { return dislt (a.ptr (), b.ptr ()); @@ -599,7 +706,19 @@ bool operator < (double a, const real & b) return a < n; } -bool operator >= (const real & a, const real & b) +// @func bool | operator = | Controlla se un reale e' maggiore o uguale ad +// un altro +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se

e' maggiore o uguale a

+// @flag FALSE | Se

e' minore di

+bool operator >= ( + const real & a, // @parm Primo numero da conforntare + const real & b) // @parm Secondo numero da confrontare + + // @syntax operator = (const real &a, const real &b); + // @syntax operator = (double a, const real &b); { return disge (a.ptr (), b.ptr ()); @@ -614,8 +733,19 @@ bool operator >= (double a, const real & b) return a >= n; } -bool operator <= (const real & a, const real & b) +// @func bool | operator = | Controlla se un reale e' minore o uguale ad +// un altro +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se

e' minore o uguale a

+// @flag FALSE | Se

e' maggiore di

+bool operator <= ( + const real & a, // @parm Primo numero da conforntare + const real & b) // @parm Secondo numero da confrontare + // @syntax operator = (const real &a, const real &b); + // @syntax operator = (double a, const real &b); { return disle (a.ptr (), b.ptr ()); } @@ -629,7 +759,19 @@ bool operator <= (double a, const real & b) return a <= n; } -bool operator == (const real & a, const real & b) + +// @func bool | operator == | Controlla se un reale e' uguale ad un altro +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se

e' uguale a

+// @flag FALSE | Se

non e' uguale a

+bool operator == ( + const real & a, // @parm Primo numero da conforntare + const real & b) // @parm Secondo numero da confrontare + + // @syntax operator == (const real &a, const real &b); + // @syntax operator == (double a, const real &b); { return diseq (a.ptr (), b.ptr ()); } @@ -640,8 +782,18 @@ bool operator == (double a, const real & b) return a == n; } -bool operator != (const real & a, const real & b) +// @func bool | operator != | Controlla se 2 reali dono diversi +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se

e' diverso da

+// @flag FALSE | Se

e' uguale a

+bool operator != ( + const real & a, // @parm Primo numero da conforntare + const real & b) // @parm Secondo numero da confrontare + // @syntax operator != (const real &a, const real &b); + // @syntax operator != (double a, const real &b); { return !diseq (a.ptr (), b.ptr ()); } @@ -653,47 +805,67 @@ bool operator != (double a, const real & b) return a != n; } -real operator % (const real & a, const long b) +// @func real | operator % | Ritorna il modulo di due numeri +// +// @rdesc Ritorna il resto della divisione tra due numeri +real operator % ( + const real & a, // @parm Primo membro della divisione + const long b) // @parm Secondo membro della divisione { dmodl (__tmp_real.ptr (), a.ptr (), b); return __tmp_real; } -void swap (real & a, real & b) +// @func Scambia il numero reale

con il numero real

+void swap ( + real & a, // @parm Primo numero da scambiare + real & b) // @parm Secondo numero da scambiare { SwapDecimal (a.ptr (), b.ptr ()); } -real fnc_min (const real & a, const real & b) +// @func Ritorna il numero reale piu' piccolo tra

e

+real fnc_min ( + const real & a, // @parm Primo numero da confrontare + const real & b) // @parm Secondo numero da confrontare { dmin (__tmp_real.ptr (), a.ptr (), b.ptr ()); return __tmp_real; } -real fnc_max (const real & a, const real & b) + +// @func Ritorna il numero reale piu' grande tra

e

+real fnc_max ( + const real & a, // @parm Primo numero da confrontare + const real & b) // @parm Secondo numero da confrontare { dmax (__tmp_real.ptr (), a.ptr (), b.ptr ()); return __tmp_real; } -real sqrt (const real & a) +// @func Ritorna la radice quadrata del numero +real sqrt ( + const real & a) // @parm Numero del quale calcolare la radice { dsqrt (__tmp_real.ptr (), a.ptr ()); return __tmp_real; } -real sqr (const real & a) +// @func Ritorna il quadarato del numero +real sqr ( + const real & a) // @parm Numero del quale calcolare il quadrato { dmul (__tmp_real.ptr (), a.ptr (), a.ptr ()); return __tmp_real; } +// @func Calcola 10 a potenza

real exp10 (const real & a) { @@ -701,6 +873,7 @@ real exp10 (const real & a) return __tmp_real; } +// @func Calcola l'elevamento a potenza

del numero

real pow (const real & a, const real & b) { @@ -708,6 +881,7 @@ real pow (const real & a, const real & b) return __tmp_real; } +// @func Calcola e (nepero) elevato ad

real exp (const real & a) { @@ -715,42 +889,55 @@ real exp (const real & a) return __tmp_real; } -real log10 (const real & a) +// @func Calcola il logaritmo in base 10 del numero +real log10 ( + const real & a) // @parm Numero del quale calcolare il logaritmo { dlog (__tmp_real.ptr (), a.ptr ()); return __tmp_real; } -real log (const real & a) +// @func Calcoa il logaritmo naturale (base e) del numero +real log ( + const real & a) // @parm Numero del quale calcolare il logaritmo { dln (__tmp_real.ptr (), a.ptr ()); return __tmp_real; } -real sin (const real & a) +// @func Calcola il seno dell'angolo +real sin ( + const real & a) // @parm Angolo passato in radianti { dsin (__tmp_real.ptr (), a.ptr ()); return __tmp_real; } -real cos (const real & a) +// @func Calcola il coseno dell'angolo +real cos ( + const real & a) // @parm Angolo passato in radianti { dcos (__tmp_real.ptr (), a.ptr ()); return __tmp_real; } -real tan (const real & a) +// @func Calcola la tangente dell'angolo +real tan ( + const real & a) // @parm Angolo passato in radianti { dtan (__tmp_real.ptr (), a.ptr ()); return __tmp_real; } -real abs (const real & a) +// @func Ritorna il valore assoluto di un numero +real abs ( + const real & a) // @parm Numero del quale si vuole conoscere il valore + // assoluto { dabs (__tmp_real.ptr (), a.ptr ()); @@ -786,10 +973,17 @@ real TDistrib::get () return r; } -void TDistrib::init (const real & r, bool zap) +// @mfunc Inizializza l'oggetto +void TDistrib::init ( + const real & r, // @parm Importo da dividere + bool zap) // @parm Permette di cancellare le percenutali immesse + // (default FALSE) + + // @comm Se

e' vero cancella tutte le percentuali immesse, altrimenti + // cambia solo il totale { _current = 0; _prog = 0; - _tot = r; _ready = FALSE; + _tot = r; _ready = FALSE; if (zap) _slices.destroy(); } @@ -798,7 +992,7 @@ void TDistrib::init (const real & r, bool zap) /////////////////////////////////////////////////////////// const TImporto& TImporto::add_to(TToken_string& s) const -{ +{ const bool dare = sezione() == 'D'; const char* v = valore().string(); s.add(dare ? v : "", 0); @@ -807,7 +1001,6 @@ const TImporto& TImporto::add_to(TToken_string& s) const } // Cerified 99% -// Ambigous section for ZERO const TImporto& TImporto::operator =(TToken_string& sv) { _valore = real(sv.get(0)); @@ -815,7 +1008,7 @@ const TImporto& TImporto::operator =(TToken_string& sv) { _valore = real(sv.get()); _sezione = 'A'; - } + } else _sezione = 'D'; return *this; @@ -831,7 +1024,7 @@ const TImporto& TImporto::set(char s, const real& v) const TImporto& TImporto::operator += (const TImporto& i) -{ +{ if (_valore.is_zero()) _sezione = i._sezione; @@ -839,7 +1032,7 @@ const TImporto& TImporto::operator += (const TImporto& i) _valore += i._valore; else _valore -= i._valore; - return *this; + return *this; } @@ -852,7 +1045,7 @@ const TImporto& TImporto::operator -= (const TImporto& i) _valore -= i._valore; else _valore += i._valore; - return *this; + return *this; } @@ -865,11 +1058,11 @@ const TImporto& TImporto::swap_section() const TImporto& TImporto::normalize() { - if (_valore.sign() < 0) + if (_valore.sign() < 0) { _valore = -_valore; swap_section(); - } + } return *this; } @@ -879,7 +1072,7 @@ int TImporto::compare(const TSortable& s) const const TImporto& i = (const TImporto&)s; const real d = valore() - i.valore(); int res = d.sign(); - if (res == 0) + if (res == 0) res = sezione() != i.sezione(); return res; -} \ No newline at end of file +} diff --git a/include/real.h b/include/real.h index 4743f38fc..a03fcce76 100755 --- a/include/real.h +++ b/include/real.h @@ -17,55 +17,101 @@ #ifndef __STRINGS_H #include #endif -// @C + +// @doc EXTERNAL + +// @class real | Classe per la gestione dei numeri reali +// +// @base public | TObject class real : public TObject { - // @DPRIV - DEC _dec; - // @END + // @access Private Member + // @cmember Numero reale + DEC _dec; + + // @access Protected Member protected: + // @cmember Duplica il numero reale (vedi classe ) virtual TObject* dup() const; + // @cmember Traduce in lettere il numero reale char* literals() const; + // @cmember Inserisce i punti separatori delle migliaia e riempe i decimali + // alla lunghezza passata (es: 3.000,20) char* points(int decimals = 0) const; + // @access Public Member public: + // @cmember Trasforma un numero dal formato inglese (decimali con punto) in + // formato italiano (decimali con virgola) static char* eng2ita(char* s); + // @cmember Trasforma un numero dal formato italiano (decimali con virgola) in + // formato inglese (decimali con punto) static char* ita2eng(const char* s); + // @cmember Controlla se si tratta di un numero reale (TRUE se vero) static bool is_real(const char* n); + // @cmember Controlla se si tratta di un numero naturale intero (TRUE se vero) static bool is_natural(const char* n); - // @FPUB - DEC* ptr() const { return (DEC*)&_dec; } + // @cmember Ritorna l'indirizzo del numero reale + DEC* ptr() const + { return (DEC*)&_dec; } + // @cmember Trasforma un reale in stringa char* string(int len = 0, int dec = UNDEFINED, char pad = ' ') const; + // @cmember Trasforma un reale in stringa (chiama ), ma + // ritorna il formato italiano char* stringa(int len = 0, int dec = UNDEFINED, char pad = ' ') const; + // @cmember Ritorna la stringa con il formato passato char* string(const char* picture) const; + // @cmember Ritorna la precisione del reale (numero di decimali) int precision() ; + // @cmember Controlla se si tratta di un reale uguale 0 (TRUE se 0) bool is_zero() const; + // @cmember Ritorna il segno del reale int sign() const; - long integer() const; // operator int is too dangerous + // @cmember Trasforma il reale in intero (operator int era troppo pericoloso) + long integer() const; + // @cmember Arrotonda al numero di decimali passati real& round(int prec = 0) ; + // @cmember Tronca al numero di decimali passati (default 0) real& trunc(int prec = 0) ; + // @cmember Arrotonda al numero successivo (della precisione passata) real& ceil(int prec = 0); + // @cmember Assegna un reale real& operator =(double a); + // @cmember Assegna un reale (passato per indirizzo) real& operator =(const real& b); + // @cmember Aggiunge ad un reale il valore passato (passato per indirizzo) real& operator +=(const real& b); + // @cmember Aggiunge ad un reale il valore passato real& operator +=(double a); + // @cmember Sottrae ad un reale il valore passato (passato per indirizzo) real& operator -=(const real& b); + // @cmember Moltiplica un reale per il valore passato (passato per indirizzo) real& operator *=(const real& b); + // @cmember Divide un reale per il valore passato (passato per indirizzo) real& operator /=(const real& b); - bool operator !() const { return is_zero(); } + // @cmember Ritorna la negazione di un reale (TRUE se 0, altrimenti FALSE) + bool operator !() const + { return is_zero(); } + // @cmember Ritorna il risultato della differenza tra due reali real operator -() const; + // @cmember Costruttore real(); + // @cmember Costruttore real(const real& b); + // @cmember Costruttore real(double a); + // @cmember Costruttore real(const char* s); - virtual ~real() {} + // @cmember Distruttore + virtual ~real() + {} }; /////////////////////////////////////////////////////////// @@ -125,64 +171,115 @@ real tan(const real& a) ; real abs(const real& a) ; extern const real ZERO; +// @class TDistrib | Classe per dividere un real in varie sue percentuali +// in modo che la loro somma dia sempre il real di partenza +// +// @base public | TObject class TDistrib : public TObject { - real _tot; - real _prog; - bool _ready; - TArray _slices; - int _current; - int _decs; + // @access Private Member + + // @cmember Totale da ripartire + real _tot; + // @cmember Progressivo gia' distribuito + real _prog; + // @cmember Pronto per essere usato (tutti gli add() fatti) + bool _ready; + // @cmember Percentuali da distribuire + TArray _slices; + // @cmember Indice delle percentuali aggiunte o estratte + int _current; + // @cmember Precisione + int _decs; + + // @access Public Member public: + // @cmember Aggiunge una percentuale per la ripartizione void add(real slice); + // @cmember Ritorna il successivo degli importi suddivisi real get(); - - // se zap e' vero scancella tutte le percentuali immesse - // altrimenti cambia solo il totale + + // @cmember Inizializza l'oggetto void init(const real& r, bool zap = FALSE); - void operator =(const real& r) { init(r); } + // @cmember Assegnamento di un importo + void operator =(const real& r) + { init(r); } + // @cmember Ritorna l'ultima percentuale aggiunta const real& last_slice() const { CHECK(_current,"TDistrib: slices not set"); return (const real&)_slices[_current-1]; } - - TDistrib(const real& r, int round = UNDEFINED) : - _prog(0.0), _tot(r), _ready(FALSE), - _current(0), _decs(round), _slices(4) + + // @cmember Costruttore + TDistrib(const real& r,int round=UNDEFINED) : _prog(0.0),_tot(r),_ready(FALSE),_current(0),_decs(round),_slices(4) + {} + // @cmember Distruttore + virtual ~TDistrib() {} - virtual ~TDistrib() {} }; - +// @class TImporto | Classe per la definizione di oggetti con sezione e importo +// +// @base public | TSortable class TImporto : public TSortable { + + // @access Private Member + + // @cmember Sezione alla quale apprtiene l'importo char _sezione; + // @cmember Valore dell'importo real _valore; - -protected: + + // @access Protected Member +protected: + // @cmember Permette la comparazione degli importi (0 se uguali in valore + // ed importo) virtual int compare(const TSortable& s) const; + // @access Public Member public: - char sezione() const { return _sezione; } - const real& valore() const { return _valore; } - - bool is_zero() const { return _valore.is_zero(); } - - const TImporto& operator=(const TImporto& i) { return set(i.sezione(), i.valore()); } + // @cmember Ritorna la sezione dell'importo + char sezione() const + { return _sezione; } + // @cmember Ritorna il valore dell'importo + const real& valore() const + { return _valore; } + + // @cmember Controlla se l'importo e' 0 (in qualsiasi sezione, TRUE se 0) + bool is_zero() const + { return _valore.is_zero(); } + + // @cmember Assegna l'importo passato + const TImporto& operator=(const TImporto& i) + { return set(i.sezione(), i.valore()); } + // @cmember Assegna l'importo da una (sezione ambigua se + // ZERO) const TImporto& operator=(TToken_string& sv); + // @cmember Aggiunge all'importo l'oggetto passato const TImporto& operator+=(const TImporto& i); + // @cmember Sottrae all'importo l'oggetto passato const TImporto& operator-=(const TImporto& i); + // @cmember Inverte la sezione se il valore e' minore di 0 const TImporto& normalize(); + // @cmember Inverte la sezione dell'importo const TImporto& swap_section(); + // @cmember Assegna sezione ed importo all'oggetto const TImporto& set(char s, const real& v); + // @cmember Setta i primi due elementi della + // al valore dell'importo, lasciando bianco il dare (0) o l'avere(1) const TImporto& add_to(TToken_string& s) const; - - TImporto(char s = 'D', const real& v = ZERO) { set(s, v); } - TImporto(const TImporto& i) : _sezione(i._sezione), _valore(i._valore) {} + + // @cmember Costruttore + TImporto(char s = 'D', const real& v = ZERO) + { set(s, v); } + // @cmember Costruttore (copia l'oggetto) + TImporto(const TImporto& i) : _sezione(i._sezione), _valore(i._valore) + {} }; #endif // __REAL_H