root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Aggiunta documentazione in line

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@1398 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
andrea 1995-05-26 10:16:03 +00:00
parent 6f35d24c4e
commit 03aac38221
11 changed files with 1102 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/assoc.h
View File

@ -12,6 +12,7 @@
// @base public | TObject // @base public | TObject
class THash_object : public TObject class THash_object : public TObject
{ {
// @cfriend TAssoc_array
friend class TAssoc_array; friend class TAssoc_array;
// @access Private Member // @access Private Member

107
include/checks.cpp
View File

@ -24,7 +24,18 @@
#ifndef FOXPRO #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(); 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(); 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(); 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(); buildmsg();
@ -101,7 +130,14 @@ int message_box(const char* fmt, ...)
return 0; 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(); buildmsg();
@ -115,7 +151,21 @@ int sorry_box(const char* fmt, ...)
return 0; 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 <m yesnocancel_box> <m yesnofatal_box>
{ {
buildmsg(); 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.
// <nl>A differenza della <m yesno_box> 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 <m yesno_box> <m yesnofatal_box>
{ {
buildmsg(); 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 <m yesno_box> <m yesnofatal_box>
{ {
buildmsg(); buildmsg();
@ -168,7 +248,16 @@ int yesnocancel_box(const char* fmt, ...)
#endif #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(); buildmsg();
FILE* f = fopen("trace.log", "a"); FILE* f = fopen("trace.log", "a");

45
include/checks.h
View File

@ -4,7 +4,6 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* @FPUB */
int message_box(const char* fmt, ...); int message_box(const char* fmt, ...);
int warning_box(const char* fmt, ...); int warning_box(const char* fmt, ...);
int sorry_box(const char* fmt, ...); int sorry_box(const char* fmt, ...);
@ -14,28 +13,55 @@ extern "C" {
int yesnocancel_box(const char* fmt, ...); int yesnocancel_box(const char* fmt, ...);
int yesnofatal_box(const char* fmt, ...); int yesnofatal_box(const char* fmt, ...);
int __trace(const char* fmt, ...); int __trace(const char* fmt, ...);
/* @END */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #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 #ifdef DBG
// @msg CHECK | Macro che richiama una <m fatal_box> per stampare messaggi a video
#define CHECK(p, m) ( (p) ? (void)0 : (void) fatal_box( \ #define CHECK(p, m) ( (p) ? (void)0 : (void) fatal_box( \
"Check failed in %s, line %d:\n\r%s", \ "Check failed in %s, line %d:\n\r%s", \
__FILE__, __LINE__, m) ) __FILE__, __LINE__, m) )
// @parm | p | Condizione per la stampa del messaggio (stampa se FALSE)
// @parm | m | Messaggio da stampare
//
// @comm Viene richiamata se <p p> e' FALSE.
// <nl>Utilizzata in fase di debug (definire il simbolo DBG in compilazione).
//
// @xref <m CHECKS> <m CHECKD>
// @msg CHECKS | Macro che richiama una <m fatal_box> per stampare messaggi a video
#define CHECKS(p, m, s0) ( (p) ? (void)0 : (void) fatal_box( \ #define CHECKS(p, m, s0) ( (p) ? (void)0 : (void) fatal_box( \
"Check failed in %s, line %d:\n\r%s%s", \ "Check failed in %s, line %d:\n\r%s%s", \
__FILE__, __LINE__, m, s0) ) __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 <p p> e' FALSE. Oltre al messaggio passato im <p m>
// stampa anche una strina aggiuntiva passata in <p s0>.
// <nl>Utilizzata in fase di debug (definire il simbolo DBG in compilazione).
//
// @xref <m CHECK> <m CHECKD>
// @msg CHECKD | Macro che richiama una <m fatal_box> per stampare messaggi a video
#define CHECKD(p, m, d0) ( (p) ? (void)0 : (void) fatal_box( \ #define CHECKD(p, m, d0) ( (p) ? (void)0 : (void) fatal_box( \
"Check failed in %s, line %d:\n\r%s%d", \ "Check failed in %s, line %d:\n\r%s%d", \
__FILE__, __LINE__, m, d0) ) __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 <p p> e' FALSE. Oltre al messaggio passato im <p m>
// stampa anche un numero passato in <p d0>.
// <nl>Utilizzata in fase di debug (definire il simbolo DBG in compilazione).
//
// @xref <m CHECKS> <m CHECK>
#else #else
#define CHECK(p, m) #define CHECK(p, m)
@ -43,17 +69,14 @@ extern "C" {
#define CHECKD(p, m, d) #define CHECKD(p, m, d)
#endif #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 #ifdef TRC
// @msg TRACE | Macro che richiama la funzione <m __trace>
#define TRACE __trace #define TRACE __trace
#else #else
#define TRACE 1 ? 0 : __trace #define TRACE 1 ? 0 : __trace
#endif #endif
/* @END */
#endif // __CHECKS_H #endif // __CHECKS_H

178
include/config.cpp
View File

@ -13,8 +13,17 @@ extern "C"
int rename(const char*, const char*); 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() 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; bool itwas = FALSE;
_data.destroy(); _data.destroy();
@ -53,7 +62,12 @@ bool TConfig::_read_paragraph()
return itwas; 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(); _data.restart();
out << '[' << _paragraph << ']' << endl; out << '[' << _paragraph << ']' << endl;
@ -66,6 +80,7 @@ void TConfig::_write_paragraph(ofstream& out)
} }
void TConfig::_write_file() void TConfig::_write_file()
{ {
ifstream in(_file); ifstream in(_file);
TFilename temp; TFilename temp;
@ -108,6 +123,7 @@ void TConfig::_write_file()
remove(temp); // Cancella file temporaneo remove(temp); // Cancella file temporaneo
} }
// @doc EXTERNAL
void TConfig::set_paragraph(const char* section) 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 <p index> e' <gt>= 0 viene costruito il nome dell'elemento
// dell'array da cercare, diversamente viene cercata la variabile
// normale passata in <p var>.
{ {
if (index >= 0) if (index >= 0)
{ {
@ -131,10 +159,25 @@ bool TConfig::exist(const char* var, int index)
return _data.is_key(var); 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
{
// ritorna valore di variabile nella sezione corrente o in
// quella specificata // quella specificata
//
// @rdesc Ritorna la stringa contenuta nella variabile, se questa esiste, altrimenti
// il valore di default che dovrebbe assumere determinato dal parametro
// <p def>
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 <p index> <gt>= 0 viene appeso al nome della variabile per
// implementare un array.
// <nl>Il paragrafo passato in <p section> diventa quello attivo.
//
// @xref <mf TConfig::get_long> <mf TConfig::get_int> <mf TConfig::get_bool>
// <mf TConfig::get_color>
{
HIDDEN TString256 s; HIDDEN TString256 s;
const char* v = var; const char* v = var;
@ -158,7 +201,24 @@ TString& TConfig::get(const char* var, const char* section, int index, const cha
return s; 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
// <p def>
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 <p index> <gt>= 0 viene appeso al nome variabile per
// implementare un array.
// <nl>Il paragrafo passato in <p section> diventa quello attivo.
//
// @xref <mf TConfig::get> <mf TConfig::get_int> <mf TConfig::get_bool>
// <mf TConfig::get_color>
{ {
const char* n = get(var,section,index); const char* n = get(var,section,index);
if (*n) if (*n)
@ -168,13 +228,51 @@ long TConfig::get_long(const char* var, const char* section, int index, long def
return 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
// <p def>
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 <mf TConfig::get_long> e ne ritorna un intero.
// <nl>Passando <p index> <gt>= 0 viene appeso al nome variabile per
// implementare un array.
// <nl>Il paragrafo passato in <p section> diventa quello attivo.
//
// @xref <mf TConfig::get> <mf TConfig::get_long> <mf TConfig::get_bool>
// <mf TConfig::get_color>
{ {
return (int)get_long(var, section, index, def); 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 <p def> | 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 <mf TConfig::get>.
// <nl>Passando <p index> <gt>= 0 viene appeso al nome variabile per
// implementare un array.
// <nl>Il paragrafo passato in <p section> diventa quello attivo.
//
// @xref <mf TConfig::get> <mf TConfig::get_long> <mf TConfig::get_int>
// <mf TConfig::get_color>
{ {
if (def) strcpy(__tmp_string, "X"); if (def) strcpy(__tmp_string, "X");
else *__tmp_string = '\0'; else *__tmp_string = '\0';
@ -191,7 +289,20 @@ HIDDEN void RGB_COLOR(COLOR c, int& r, int& g, int& b)
b = int(c) & 0xFF; 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 <p index> <gt>= 0 viene appeso al nome variabile per
// implementare un array.
// <nl>Il paragrafo passato in <p section> diventa quello attivo.
//
// @xref <mf TConfig::get> <mf TConfig::get_long> <mf TConfig::get_int>
// <mf TConfig::get_bool>
{ {
const char* c = get(var, section, index); const char* c = get(var, section, index);
if (*c) if (*c)
@ -210,12 +321,28 @@ COLOR TConfig::get_color(const char* var, const char* section, int index, COLOR
return def; return def;
} }
bool TConfig::set(const char* var, const char* value, const char* section, // @mfunc Setta la variabile nella sezione corrente o specificata
bool force, int index) //
// @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 // @syntax set(const char* var, const char* value, const char* section, bool force, int index);
// se force == TRUE crea la variabile se non esiste; altrimenti // @syntax set(const char* var, long value, const char* section, bool force, int index);
// da' errore; ritorna TRUE se la variabile c'era, FALSE diversamente //
// @comm Se <p force> == TRUE crea il paragrafo e la variabile se non esistono;
// altrimenti da' errore.
// <nl>Passando <p index> <gt>= 0 viene appeso al nome variabile per
// implementare un array.
// <nl>Il paragrafo passato in <p section> diventa quello attivo.
set_paragraph(section); set_paragraph(section);
TString vvar(var); if (index != -1) vvar << '(' << index << ')'; 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); 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 <p section> diventa quello attivo.
// <nl>Possono esserci dei "buchi" causati da set() errate
{ {
set_paragraph(section); set_paragraph(section);
TString vvar(16); TString vvar(16);
@ -252,7 +386,15 @@ word TConfig::items(const char* var, const char* section)
return cnt; 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 <p fn> e cerca il paragrafo <p pa>. Se il file non esiste
// viene creato con il paragrafo passato.
{ {
_file = fn; _file = fn;
_paragraph = pa; _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) TConfig::TConfig(int which_config, const char* paragraph)
{ {
switch (which_config) switch (which_config)

84
include/config.h
View File

@ -9,6 +9,8 @@
#include <assoc.h> #include <assoc.h>
#endif #endif
// @doc EXTERNAL
class ofstream; class ofstream;
// questo sara' il principale, per ora non c'e' // questo sara' il principale, per ora non c'e'
@ -26,65 +28,99 @@ class ofstream;
// file parametri golem // file parametri golem
#define CONFIG_GOLEM 6 #define CONFIG_GOLEM 6
// @class TConfig | Classe per la gestione dei file di configurazione in formato
// Windows
//
// @base public | TObject
class TConfig : public TObject class TConfig : public TObject
{ {
// @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; TAssoc_array _data;
// @cmember Nome del file di configurazione
TFilename _file; TFilename _file;
bool _dirty, _ispresent; // @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; TString _paragraph;
// @access Protected Member
protected: protected:
// @cmember Legge i dati del paragrafo
bool _read_paragraph(); bool _read_paragraph();
// @cmember Scrive i dati del paragrafo
void _write_paragraph(ofstream&); void _write_paragraph(ofstream&);
// @cmember Scrive il file di configurazione
void _write_file(); void _write_file();
// @cmember Inizializza il paragrafo leggendo dal file i dati
void init(const char *fn, const char* pa); void init(const char *fn, const char* pa);
// @access Public Memeber
public: public:
// ritorna valore di variabile nella sezione corrente o in // @cmember Ritorna il valore della variabile nella sezione corrente o in
// quella specificata; se non c'e' ritorna "" // quella specificata
// passando index >=0 viene appeso al nome variabile per
// implementare un mezzo cazzo di array
TString& get(const char* var, const char* section = NULL, int index = -1, const char* def = ""); 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); 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); 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); 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); COLOR get_color(const char* var, const char* section = NULL, int index = -1, COLOR def = 0);
// setta variabile nella sezione corrente o specificata // @cmember Setta la variabile nella sezione corrente o specificata
// se force == TRUE crea la sezione/variabile se non esiste; altrimenti bool set(const char* var, const char* value, const char* section = NULL, bool force = TRUE, int index = -1);
// da' errore; ritorna TRUE se la sezione/var c'era, FALSE diversamente // @cmember Setta la variabile nella sezione corrente o specificata
// index come per get() bool set(const char* var, long value, const char* section = NULL, bool force = TRUE, int index = -1);
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 Controlla se esite una variabile nel paragrafo attivo
bool exist(const char* var, int index = -1); bool exist(const char* var, int index = -1);
// TRUE se il paragrafo corrente e' nuovo // @cmember Controlla se il paragrafo corrente e' nuovo (TRUE se nuovo)
bool new_paragraph() { return !_ispresent; } bool new_paragraph()
{ return !_ispresent; }
// items ritorna quanti elementi dell'array nominato sono // @cmember Ritorna quanti elementi dell'array nominato sono presenti nella
// presenti nella sezione indicata // sezione indicata.
// non si risponde di eventuali "buchi" causati da set() errate
word items(const char* var, const char* section); word items(const char* var, const char* section);
// @cmember Setta il paragrafo passato come quello attivo
// Setta il paragrafo corrente
void set_paragraph(const char* par); 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); 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); 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(); virtual ~TConfig();
}; };

3
include/date.h
View File

@ -56,8 +56,7 @@ protected:
// @access Public Member // @access Public Member
public: public:
// @cmember Ritorna la data in formato di stringa (anche in formato ANSI) // @cmember Ritorna la data in formato di stringa (anche in formato ANSI)
char* string(TDate_mgafmt year = full, char sep = '-', TDate_mgafmt day = full, char* string(TDate_mgafmt year = full, char sep = '-', TDate_mgafmt day = full, TDate_mgafmt month = full, TDate_order ord = gma_date) const ;
TDate_mgafmt month = full, TDate_order ord = gma_date) const ;
// @cmember Ritorna il giorno // @cmember Ritorna il giorno
int day() const ; int day() const ;

21
include/execp.cpp
View File

@ -1,5 +1,3 @@
// fv 6/10/93
#include <stdio.h> #include <stdio.h>
#include <xvt.h> #include <xvt.h>
@ -19,7 +17,18 @@
#include <prefix.h> #include <prefix.h>
#include <window.h> #include <window.h>
// @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 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 #if XVT_OS == XVT_OS_WIN
const TFixed_string p(_path); const TFixed_string p(_path);
@ -32,8 +41,14 @@ bool TExternal_app::can_run() const
#endif #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 <p asyn> 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); TString256 path(_path);

47
include/execp.h
View File

@ -1,6 +1,3 @@
// execp.h; trattasi di -*-c++-*-
// fv 6/10/93
#ifndef __EXECP_H #ifndef __EXECP_H
#define __EXECP_H #define __EXECP_H
@ -8,26 +5,46 @@
#include <object.h> #include <object.h>
#endif #endif
// Class for external object execution with optional background // @doc EXTERNAL
// 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
// @class TExternal_app | Classe per l'esecuzione di oggetti esterni
//
// @base public | TObject
class TExternal_app : 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.
// <nl>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) // @access Private Member
int _error; // last error (errno code)
int _exitcode; // last exit code
int _count; // count of calls
// @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: public:
// @cmember Controlla se il processo puo' essere eseguito
bool can_run() const; bool can_run() const;
// @cmember Esegue il processo
int run(bool async = FALSE, bool user = TRUE); int run(bool async = FALSE, bool user = TRUE);
int error() { return _error;}; // @cmember Ritorna il codice dell'ultimo errore
int exitcode() { return _exitcode;}; int error()
int count() { return _count; }; { 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); TExternal_app(const char* p);
}; };

466
include/expr.h
View File

@ -9,48 +9,101 @@
#include <real.h> #include <real.h>
#endif #endif
// @T // @doc INTERNAL
// @DES I simboli/istruzioni possibili
// @T
enum TCodesym { _invalid, _endsym, _comma, _lpar, _rpar, _variable, // @enum TCodesym | Lista di simboli/istruzioni possibili
_number, _string, _plus, _minus, _multiply, _divide, enum TCodesym {
_chgs, _and, _or, _not, _equal, _match, _noteq, _lt, _gt, _invalid, // @emem Simbolo non riconosciuto
_lteq, _gteq, _sqrt, _sqr, _exp10, _exp, _log10, _log, _endsym, // @emem Segnaposto per simbolo finale
_sin, _cos, _tan, _left, _right, _pow, _min, _max, _mid, _comma, // @emem Simbolo virgola ","
_upper, _round } ; _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 "<lt>"
_gt, // @emem Simbolo maggiore "<gt>"
_lteq, // @emem Simbolo minore o uguale "<lt>="
_gteq, // @emem Simbolo maggiore o uguale "<gt>="
_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 // @enum TTypeesp | Tipi di espressioni definiti
// @T enum TTypeexp {
enum TTypeexp { _numexpr, _strexpr } ; _numexpr, // @emem Espressione numerica
// @END _strexpr } ; // @emem Espressione in lettere
// @C
// Classe TValue : public TObject
// @END
// @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 class TValue : public TObject
{ {
// @DPRIV // @access Private Member
real _r; // Valore real
TString _s; // Valore in formato stringa
// @cmember Valore real
real _r;
// @cmember Valore in formato stringa
TString _s;
// @access Public Member
public: 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 // @cmember Costruttore. Inizializza TValue con un reale
const real& number() const { return _r;} // Ritorna il valore numerico TValue(const real& val)
const char* string() const { return (const char*) _s;} // Ritorna il valore come stringa { _r = val; _s = val.string();}
void set(const real& val) { _r = val; _s = val.string();} // Real // @cmember Costruttore. Inizializza TValue con una stringa
void set(const char* val) { _s = val; _r = real(val);} // Stringa TValue(const char* val)
{ _s = val; _r = real(val);}
// @DES Costruttori. Inizializzano TValue con vari oggetti // @cmember Costruttore. Inizializza TValue con un altro TValue
// @FPUB TValue(const TValue& val)
TValue(const real& val) { _r = val; _s = val.string();} // Real { *this = val; }
TValue(const char* val) { _s = val; _r = real(val);} // Stringa // @cmember Costruttore. Inizializza TValue a 0,0 e ""
TValue(const TValue& val) { *this = val; } // Altro TValue TValue() { _r = 0.00; _s = ""; }
TValue() { _r = 0.00; _s = ""; } // 0,0 e "" // @cmember Distruttore
virtual ~TValue() {} virtual ~TValue()
{}
}; };
@ -58,187 +111,302 @@ public:
#define extern #define extern
#endif #endif
// @DPUB
extern TValue nulltvalue; extern TValue nulltvalue;
// @END
#undef extern #undef extern
// @C // @class TCode | Classe per la ridefinizione di una espressione in
// Classe TCode : public TObject // notazione polacca inversa (RPN)
// @END //
// @base public | TObject
class TCode : public TObject class TCode : public TObject
{ {
// @DPRIV // @access Private Member
TCodesym _sym; // Simbolo-istruzione-codice
TValue _val; // Valore
// @cmember Simbolo-istruzione-codice
TCodesym _sym;
// @cmember Valore
TValue _val;
// @access Public Member
public: public:
// @FPUB // @cmember Assegnamento tra oggetti TCode
TCode& operator =(const TCode& b); TCode& operator =(const TCode& b);
void set(TCodesym sym, const TValue& val = nulltvalue) { _sym = sym; _val = val; } // Inizializza simbolo = sym e valore = val // @cmember Inizializza simbolo e valore
TCodesym getsym() const { return _sym;} // Ritorna il simbolo _sym void set(TCodesym sym, const TValue& val = nulltvalue)
const real& number() const { return _val.number();} // Ritorna il valore _val come real { _sym = sym; _val = val; }
const char* string() const { return _val.string();} // Ritorna il valore _val come stringa // @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 // @cmember 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 TCode()
virtual ~TCode() {} {set(_invalid);}
TCode(TCodesym sym, const TValue& val = nulltvalue)
// @cmember Costruttore, inizializza simbolo con <p sym> e valore con <p val>
{ set(sym, val);}
// @cmember Distruttore
virtual ~TCode()
{}
}; };
// @C // @class TCodearray | Classe per la definizione di un array di istruzioni da valutare
// Classe TCodearray : public TObject // passo per passo in una espressione
// //
// L'array di istruzioni // @base public | TObject
//
// @END
class TCodearray : public TObject class TCodearray : public TObject
{ {
// @DPRIV // @access Private Member
int _last; // Numero di istruzioni
int _ip; // Puntatore all'istruzione corrente (Istruction pointer)
TArray _rpn; // Array
// @END
// @cmember Numero di istruzioni
int _last;
// @cmember Puntatore all'istruzione corrente (Istruction pointer)
int _ip;
// @cmember Array
TArray _rpn;
// @access Public Member
public: public:
// @FPUB // @cmember Cancella contenuto array
void clear(); // Cancella contenuto array void clear();
void add(TCodesym sym, const TValue& val = nulltvalue); // Aggiunge un'istruzione all'array // @cmember Aggiunge un'istruzione all'array
void begin() { _ip = 0;} // Mette all'inizio il puntatore all'istruzione corrente void add(TCodesym sym, const TValue& val = nulltvalue);
TCode& step() { return (TCode&) _rpn[end() ? _ip : _ip++];} // Incrementa istruction pointer // @cmember Posiziona all'inizio il puntatore all'istruzione corrente
bool end() const { return ((TCode&) _rpn[_ip]).getsym() == _endsym;} // Ritorna vero se _ip ha raggiunto il simbolo di fine codice void begin()
void backtrace(int step = 1) { if (_ip > step) _ip -= step; else begin(); } { _ip = 0;}
TCodearray(int size = 50); // Il costruttore crea un array di 10 elementi // @cmember Incrementa l'istruction pointer
virtual ~TCodearray() {} 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 <p step> 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 // @class TVar | Classe per la definizione delle variabile delle espressioni
// Classe TVar : public TObject //
// @END // @base public | TObject
class TVar : public TObject class TVar : public TObject
{ {
// @DPRIV // @access Private Member
TString _name; // Nome variabile
TValue _val; // Valore
// @cmember Nome della variabile
TString _name;
// @cmember Valore assegnato alla variabile
TValue _val;
// @access Public Member
public: public:
// @DES Operatore = tra vari oggetti // #DES Operatore = tra vari oggetti
// @FPUB // #FPUB
const char* operator =(const char* val) { _val.set(val); return val;} // @cmember Assegnamento di una stringa all'oggetto Tval
const real& operator =(const real& val) { _val.set(val); return val;} const char* operator =(const char* val)
TVar& operator =(const TValue& val) { _val = val; return *this;} { _val.set(val); return val;}
TVar& operator =(const TVar& var) { _name = var._name ; _val = var._val; return *this;} // @cmember Assegnamento di un numero all'oggetto TVal
void set(const char* name, const TValue& val = nulltvalue) { _name = name ; _val = val;} const real& operator =(const real& val)
void setname(const char* name) { _name = name;} // Setta a name il nome della variabile { _val.set(val); return val;}
const char* getname() const { return _name;} // Ritorna il nome della variabile // @cmember Assegamento di un oggetto <c TValue>
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) // @cmember Ritorna _val (un TValue)
const real& number() const { return _val.number();} // Ritorna il valore real della variabile operator TValue&()
const char* string() const { return _val.string();} // Ritorna il valore stringa della variabile { 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 // @cmember Costruttore (assegna "" ed il valore nulltvalue)
// @FPUB TVar()
TVar() { _name = ""; _val = nulltvalue;} { _name = ""; _val = nulltvalue;}
TVar(const char* name, const TValue& val = nulltvalue) { _name = name; _val = val;} // @cmember Costruttore (assegna nome e valore passato)
TVar(TVar& v) { _name = v._name; _val = v._val;} TVar(const char* name, const TValue& val = nulltvalue)
virtual ~TVar() {} { _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 | Classe per la definizione di un array di variabili da
// class TVararray : public TObject // valutare nell'esspressione
// @END //
// @base public | TObject
class TVararray : public TObject class TVararray : public TObject
{ {
// @DPRIV // @access Private Member
int _last; // Numero di variabili
TArray _array; // Array
// @END
// @cmember Numero di variabili
int _last;
// @cmember Array
TArray _array;
// @access Public Member
public: public:
// @FPUB // @cmember Cancella il contenuto dell'array
void clear() { _last = 0; } // Cancella contenuto array void clear()
void add(const TVar& var); // Aggiunge un oggetto TVar { _last = 0; }
void add(const char* name, const TValue& val = nulltvalue); // Aggiunge un nome di variabile e il suo valore // @cmember Aggiunge un oggetto TVar
const char* varname(int varnum) const { return varnum < _array.items() ? ((TVar&) _array[varnum]).getname() : "";} // Ritorna il nome della variabile di posto varnum 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 // @cmember Setta l'oggetto TVararray con il nome e il valore della variabile
// @FPUB
void set(const char* varname, const real& val); 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(const char* varname, const char* val);
void set(int varnum, const real& val) { if (varnum < _array.items()) ((TVar&) _array[varnum]) = val;} // @cmember Setta l'elemnto dell varaibile <p varnum>-esima al valore passato
void set(int varnum, const char* val) { if (varnum < _array.items()) ((TVar&) _array[varnum]) = val;} void set(int varnum, const real& val)
{ if (varnum < _array.items()) ((TVar&) _array[varnum]) = val;}
// @cmember Setta l'elemnto dell varaibile <p varnum>-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 // @cmember Ritorna il valore della variabile con nome <p varname>
// @FPUB
const real& getnum(const char* varname); const real& getnum(const char* varname);
// @cmember Ritorna il valore della variabile di posto <p varnum>-esimo
const real& getnum(int varnum); const real& getnum(int varnum);
// @cmember Ritorna il nome della variabile con nome <p varname>
const char* getstring(const char* varname); const char* getstring(const char* varname);
// @cmember Ritorna il nome della variabile di posto <p varnum>-esimo
const char* getstring(int varnum); 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;}
// @cmember Costruttore
TVararray(int size = 10); TVararray(int size = 10);
virtual ~TVararray() {} // @cmember Distruttore
virtual ~TVararray()
{}
}; };
// @C // @doc EXTERNAL
// class TExpression : public TObject
// @END
// @class TExpression | Classe per la interpretazione e valutazione di espressioni
// numerica e di stringhe
//
// @base public | TObject
class TExpression : public TObject class TExpression : public TObject
{ {
// @DPRIV // @access Provate Member
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
// @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: protected:
void eval(); // Valuta l'espressione // @cmember Valuta (calcola) l'espressione
void eval();
// @cmember Ritorna il prossimo token dell'espressione (se <p reduct> e' TRUE interpreta
// la virgola come un token)
TCodesym __gettoken(bool reduct = FALSE); TCodesym __gettoken(bool reduct = FALSE);
// @cmember Ritorna il prossimo fattore
TCodesym __factor(TCodesym startsym); TCodesym __factor(TCodesym startsym);
// @cmember Ritorna il prossimo termine
TCodesym __term(TCodesym startsym); TCodesym __term(TCodesym startsym);
// @cmember Ritorna la prossima espressione
TCodesym __expression(TCodesym startsym); TCodesym __expression(TCodesym startsym);
// @cmember Compila l'espressione
bool compile(const char* expression, TTypeexp type);
protected: // TObject
// @cmember Stampa l'espressione su <p out> (serve per implementare l'insertore)
virtual void print_on(ostream& out) const ; virtual void print_on(ostream& out) const ;
bool compile(const char* expression, TTypeexp type); // Compila l'espressione
// @access Protected Member
public: public:
// @FPUB // @cmember operator const | real& | | Ritorna il valore real dell'espressione
operator const real&(); // Ritorna il valore real dell'espressione operator const real&();
operator const char*(); // Ritorna il valore come stringa // @cmember operator const | char* | | Ritorna il valore dell'espressione come stringa
operator bool(); // Ritorna il valore come booleano operator const char*();
// @DES Metodi di interrogazione // @cmember Ritorna il valore dell'espressione come booleano
// @FPUB operator bool();
// Ritorna il nome della variabile di posto varnum // @cmember Ritorna il nome della variabile di posto <p varnum>
const char* varname(int varnum) const { return _var.varname(varnum); } const char* varname(int varnum) const
// Ritorna il numero di variabili nell'espressione { return _var.varname(varnum); }
int numvar() const { return _var.numvar(); } // @cmember Ritorna il numero di variabili nell'espressione
const TTypeexp type() const { return _type; } int numvar() const
TCodearray& code() const { return (TCodearray&)_code; } { return _var.numvar(); }
const TVararray& vars() const { return _var; } // @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 // @cmember Setta la variabile con nome e numero
// @FPUB
void setvar(const char* varname, const real& val); void setvar(const char* varname, const real& val);
// @cmember Setta la variabile con poszione e numero
void setvar(int varnum, const real& val); 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); 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 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); bool set(const char* expression, TTypeexp type = _numexpr);
// @cmember Costruttore (assegna l'estressione e il suo tipo)
TExpression(const char* expression, TTypeexp type = _numexpr); TExpression(const char* expression, TTypeexp type = _numexpr);
// @cmember Costruttore (assegna il tipo dell'istruzione)
TExpression(TTypeexp type = _numexpr); TExpression(TTypeexp type = _numexpr);
virtual ~TExpression() {} // @cmember Distruttore
virtual ~TExpression()
{}
}; };
#endif // __EXPR_H #endif // __EXPR_H

249
include/real.cpp
View File

@ -14,6 +14,8 @@ HIDDEN real __tmp_real;
HIDDEN char __string[80]; HIDDEN char __string[80];
const real ZERO (0.0); const real ZERO (0.0);
// @doc EXTERNAL
real::real () real::real ()
{ {
dzero (ptr ()); dzero (ptr ());
@ -173,7 +175,15 @@ bool real::is_zero () const
return diszero (ptr ()); return diszero (ptr ());
} }
// @mfunc Ritorna il segno del reale
//
// @rdesc Ritorna i seguenti valori:
//
// @flag <lt> 0 | Se il numero e' minore di 0
// @flag = 0 | Se il numero e' uguale a 0
// @flag <gt> 0 | Se il numero e' maggiore di 0
int real::sign () const int real::sign () const
{ {
return dsign (ptr ()); return dsign (ptr ());
} }
@ -191,7 +201,25 @@ long real::integer () const
} }
// Certified 91% // 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 <p len> con <p dec> decimali e
// inserisce nella stringa stessa il carattere <p pad> nel caso la
// lunghezza richiesta sia maggiore di quella che risulterebbe per la
// completa rappresentazione del reale.
// <nl>Nel secondo caso ritorna la stringa con il formato stabilito in
// <p picture>.
{ {
__tmp_real = *this; __tmp_real = *this;
if (dec != UNDEFINED) if (dec != UNDEFINED)
@ -421,13 +449,26 @@ char *real ::string (const char *picture)
} }
ostream & operator << (ostream & out, const real & a) // @func ostream& | operator <lt><lt> | 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 (); return out << a.string ();
} }
istream & operator >> (istream & in, real & a) // @func istream& | operator <gt><gt> | 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; in >> __string;
atod (a.ptr (), __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 <p prec> sia:
//
// @flag <gt> 0 | Arrotonda al decimale
// @flag = 0 | Arrotonda all'intero
// @flag <lt> 0 | Arrotonda al valore passato (es. -3 arrotonda alle mille)
{ {
if (prec < 0) if (prec < 0)
{ {
@ -484,7 +533,16 @@ real & real ::trunc (int prec)
return *this; 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 ()); dadd (__tmp_real.ptr (), a.ptr (), b.ptr ());
@ -505,8 +563,16 @@ real operator + (const real & a, double b)
return __tmp_real += 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 ()); dsub (__tmp_real.ptr (), a.ptr (), b.ptr ());
return __tmp_real; return __tmp_real;
@ -527,7 +593,16 @@ real operator - (const real & a, double b)
return __tmp_real -= a; 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 ()); dmul (__tmp_real.ptr (), a.ptr (), b.ptr ());
@ -548,8 +623,17 @@ real operator *(const real & a, double b)
return __tmp_real; 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 ()); ddiv (__tmp_real.ptr (), a.ptr (), b.ptr ());
return __tmp_real; return __tmp_real;
@ -571,7 +655,19 @@ real operator / (const real & a, double b)
return __tmp_real; return __tmp_real;
} }
bool operator > (const real & a, const real & b)
// @func bool | operator <gt> | Controlla se un reale e' maggiore di un altro
//
// @rdesc Ritorna i seguenti valori
//
// @flag TRUE | Se <p a> e' maggiore di <p b>
// @flag FALSE | Se <p a> e' non maggiore di <p b>
bool operator > (
const real & a, // @parm Primo numero da conforntare
const real & b) // @parm Secondo numero da confrontare
// @syntax operator <gt> (const real &a, const real &b);
// @syntax operator <gt> (double a, const real &b);
{ {
return disgt (a.ptr (), b.ptr ()); return disgt (a.ptr (), b.ptr ());
} }
@ -584,7 +680,18 @@ bool operator > (double a, const real & b)
return a > n; return a > n;
} }
bool operator < (const real & a, const real & b) // @func bool | operator <lt> | Controlla se un reale e' minore di un altro
//
// @rdesc Ritorna i seguenti valori
//
// @flag TRUE | Se <p a> e' minore di <p b>
// @flag FALSE | Se <p a> e' non minore di <p b>
bool operator < (
const real & a, // @parm Primo numero da conforntare
const real & b) // @parm Secondo numero da confrontare
// @syntax operator <lt> (const real &a, const real &b);
// @syntax operator <lt> (double a, const real &b);
{ {
return dislt (a.ptr (), b.ptr ()); return dislt (a.ptr (), b.ptr ());
@ -599,7 +706,19 @@ bool operator < (double a, const real & b)
return a < n; return a < n;
} }
bool operator >= (const real & a, const real & b) // @func bool | operator <gt>= | Controlla se un reale e' maggiore o uguale ad
// un altro
//
// @rdesc Ritorna i seguenti valori
//
// @flag TRUE | Se <p a> e' maggiore o uguale a <p b>
// @flag FALSE | Se <p a> e' minore di <p b>
bool operator >= (
const real & a, // @parm Primo numero da conforntare
const real & b) // @parm Secondo numero da confrontare
// @syntax operator <gt>= (const real &a, const real &b);
// @syntax operator <gt>= (double a, const real &b);
{ {
return disge (a.ptr (), b.ptr ()); return disge (a.ptr (), b.ptr ());
@ -614,8 +733,19 @@ bool operator >= (double a, const real & b)
return a >= n; return a >= n;
} }
bool operator <= (const real & a, const real & b) // @func bool | operator <lt>= | Controlla se un reale e' minore o uguale ad
// un altro
//
// @rdesc Ritorna i seguenti valori
//
// @flag TRUE | Se <p a> e' minore o uguale a <p b>
// @flag FALSE | Se <p a> e' maggiore di <p b>
bool operator <= (
const real & a, // @parm Primo numero da conforntare
const real & b) // @parm Secondo numero da confrontare
// @syntax operator <lt>= (const real &a, const real &b);
// @syntax operator <lt>= (double a, const real &b);
{ {
return disle (a.ptr (), b.ptr ()); return disle (a.ptr (), b.ptr ());
} }
@ -629,7 +759,19 @@ bool operator <= (double a, const real & b)
return a <= n; 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 <p a> e' uguale a <p b>
// @flag FALSE | Se <p a> non e' uguale a <p b>
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 ()); return diseq (a.ptr (), b.ptr ());
} }
@ -640,8 +782,18 @@ bool operator == (double a, const real & b)
return a == n; 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 <p a> e' diverso da <p b>
// @flag FALSE | Se <p a> e' uguale a <p b>
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 ()); return !diseq (a.ptr (), b.ptr ());
} }
@ -653,47 +805,67 @@ bool operator != (double a, const real & b)
return a != n; 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); dmodl (__tmp_real.ptr (), a.ptr (), b);
return __tmp_real; return __tmp_real;
} }
void swap (real & a, real & b) // @func Scambia il numero reale <p a> con il numero real <p b>
void swap (
real & a, // @parm Primo numero da scambiare
real & b) // @parm Secondo numero da scambiare
{ {
SwapDecimal (a.ptr (), b.ptr ()); SwapDecimal (a.ptr (), b.ptr ());
} }
real fnc_min (const real & a, const real & b) // @func Ritorna il numero reale piu' piccolo tra <p a> e <p b>
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 ()); dmin (__tmp_real.ptr (), a.ptr (), b.ptr ());
return __tmp_real; return __tmp_real;
} }
real fnc_max (const real & a, const real & b)
// @func Ritorna il numero reale piu' grande tra <p a> e <p b>
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 ()); dmax (__tmp_real.ptr (), a.ptr (), b.ptr ());
return __tmp_real; 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 ()); dsqrt (__tmp_real.ptr (), a.ptr ());
return __tmp_real; 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 ()); dmul (__tmp_real.ptr (), a.ptr (), a.ptr ());
return __tmp_real; return __tmp_real;
} }
// @func Calcola 10 a potenza <p a>
real exp10 (const real & a) real exp10 (const real & a)
{ {
@ -701,6 +873,7 @@ real exp10 (const real & a)
return __tmp_real; return __tmp_real;
} }
// @func Calcola l'elevamento a potenza <p b> del numero <p a>
real pow (const real & a, const real & b) real pow (const real & a, const real & b)
{ {
@ -708,6 +881,7 @@ real pow (const real & a, const real & b)
return __tmp_real; return __tmp_real;
} }
// @func Calcola e (nepero) elevato ad <p a>
real exp (const real & a) real exp (const real & a)
{ {
@ -715,42 +889,55 @@ real exp (const real & a)
return __tmp_real; 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 ()); dlog (__tmp_real.ptr (), a.ptr ());
return __tmp_real; 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 ()); dln (__tmp_real.ptr (), a.ptr ());
return __tmp_real; 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 ()); dsin (__tmp_real.ptr (), a.ptr ());
return __tmp_real; 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 ()); dcos (__tmp_real.ptr (), a.ptr ());
return __tmp_real; 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 ()); dtan (__tmp_real.ptr (), a.ptr ());
return __tmp_real; 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 ()); dabs (__tmp_real.ptr (), a.ptr ());
@ -786,7 +973,14 @@ real TDistrib::get ()
return r; 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 <p zap> e' vero cancella tutte le percentuali immesse, altrimenti
// cambia solo il totale
{ {
_current = 0; _prog = 0; _current = 0; _prog = 0;
_tot = r; _ready = FALSE; _tot = r; _ready = FALSE;
@ -807,7 +1001,6 @@ const TImporto& TImporto::add_to(TToken_string& s) const
} }
// Cerified 99% // Cerified 99%
// Ambigous section for ZERO
const TImporto& TImporto::operator =(TToken_string& sv) const TImporto& TImporto::operator =(TToken_string& sv)
{ {
_valore = real(sv.get(0)); _valore = real(sv.get(0));

143
include/real.h
View File

@ -17,55 +17,101 @@
#ifndef __STRINGS_H #ifndef __STRINGS_H
#include <strings.h> #include <strings.h>
#endif #endif
// @C
// @doc EXTERNAL
// @class real | Classe per la gestione dei numeri reali
//
// @base public | TObject
class real : public TObject class real : public TObject
{ {
// @DPRIV // @access Private Member
DEC _dec;
// @END
// @cmember Numero reale
DEC _dec;
// @access Protected Member
protected: protected:
// @cmember Duplica il numero reale (vedi classe <c TObject>)
virtual TObject* dup() const; virtual TObject* dup() const;
// @cmember Traduce in lettere il numero reale
char* literals() const; 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; char* points(int decimals = 0) const;
// @access Public Member
public: public:
// @cmember Trasforma un numero dal formato inglese (decimali con punto) in
// formato italiano (decimali con virgola)
static char* eng2ita(char* s); 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); 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); 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); static bool is_natural(const char* n);
// @FPUB // @cmember Ritorna l'indirizzo del numero reale
DEC* ptr() const { return (DEC*)&_dec; } DEC* ptr() const
{ return (DEC*)&_dec; }
// @cmember Trasforma un reale in stringa
char* string(int len = 0, int dec = UNDEFINED, char pad = ' ') const; char* string(int len = 0, int dec = UNDEFINED, char pad = ' ') const;
// @cmember Trasforma un reale in stringa (chiama <mf real::string>), ma
// ritorna il formato italiano
char* stringa(int len = 0, int dec = UNDEFINED, char pad = ' ') const; 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; char* string(const char* picture) const;
// @cmember Ritorna la precisione del reale (numero di decimali)
int precision() ; int precision() ;
// @cmember Controlla se si tratta di un reale uguale 0 (TRUE se 0)
bool is_zero() const; bool is_zero() const;
// @cmember Ritorna il segno del reale
int sign() const; 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) ; real& round(int prec = 0) ;
// @cmember Tronca al numero di decimali passati (default 0)
real& trunc(int prec = 0) ; real& trunc(int prec = 0) ;
// @cmember Arrotonda al numero successivo (della precisione passata)
real& ceil(int prec = 0); real& ceil(int prec = 0);
// @cmember Assegna un reale
real& operator =(double a); real& operator =(double a);
// @cmember Assegna un reale (passato per indirizzo)
real& operator =(const real& b); real& operator =(const real& b);
// @cmember Aggiunge ad un reale il valore passato (passato per indirizzo)
real& operator +=(const real& b); real& operator +=(const real& b);
// @cmember Aggiunge ad un reale il valore passato
real& operator +=(double a); real& operator +=(double a);
// @cmember Sottrae ad un reale il valore passato (passato per indirizzo)
real& operator -=(const real& b); real& operator -=(const real& b);
// @cmember Moltiplica un reale per il valore passato (passato per indirizzo)
real& operator *=(const real& b); real& operator *=(const real& b);
// @cmember Divide un reale per il valore passato (passato per indirizzo)
real& operator /=(const real& b); 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; real operator -() const;
// @cmember Costruttore
real(); real();
// @cmember Costruttore
real(const real& b); real(const real& b);
// @cmember Costruttore
real(double a); real(double a);
// @cmember Costruttore
real(const char* s); real(const char* s);
virtual ~real() {} // @cmember Distruttore
virtual ~real()
{}
}; };
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
@ -125,64 +171,115 @@ real tan(const real& a) ;
real abs(const real& a) ; real abs(const real& a) ;
extern const real ZERO; 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 class TDistrib : public TObject
{ {
// @access Private Member
// @cmember Totale da ripartire
real _tot; real _tot;
// @cmember Progressivo gia' distribuito
real _prog; real _prog;
// @cmember Pronto per essere usato (tutti gli add() fatti)
bool _ready; bool _ready;
// @cmember Percentuali da distribuire
TArray _slices; TArray _slices;
// @cmember Indice delle percentuali aggiunte o estratte
int _current; int _current;
// @cmember Precisione
int _decs; int _decs;
// @access Public Member
public: public:
// @cmember Aggiunge una percentuale per la ripartizione
void add(real slice); void add(real slice);
// @cmember Ritorna il successivo degli importi suddivisi
real get(); real get();
// se zap e' vero scancella tutte le percentuali immesse // @cmember Inizializza l'oggetto
// altrimenti cambia solo il totale
void init(const real& r, bool zap = FALSE); 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 const real& last_slice() const
{ {
CHECK(_current,"TDistrib: slices not set"); CHECK(_current,"TDistrib: slices not set");
return (const real&)_slices[_current-1]; return (const real&)_slices[_current-1];
} }
TDistrib(const real& r, int round = UNDEFINED) : // @cmember Costruttore
_prog(0.0), _tot(r), _ready(FALSE), TDistrib(const real& r,int round=UNDEFINED) : _prog(0.0),_tot(r),_ready(FALSE),_current(0),_decs(round),_slices(4)
_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 class TImporto : public TSortable
{ {
// @access Private Member
// @cmember Sezione alla quale apprtiene l'importo
char _sezione; char _sezione;
// @cmember Valore dell'importo
real _valore; real _valore;
// @access Protected Member
protected: protected:
// @cmember Permette la comparazione degli importi (0 se uguali in valore
// ed importo)
virtual int compare(const TSortable& s) const; virtual int compare(const TSortable& s) const;
// @access Public Member
public: public:
char sezione() const { return _sezione; } // @cmember Ritorna la sezione dell'importo
const real& valore() const { return _valore; } char sezione() const
{ return _sezione; }
// @cmember Ritorna il valore dell'importo
const real& valore() const
{ return _valore; }
bool is_zero() const { return _valore.is_zero(); } // @cmember Controlla se l'importo e' 0 (in qualsiasi sezione, TRUE se 0)
bool is_zero() const
{ return _valore.is_zero(); }
const TImporto& operator=(const TImporto& i) { return set(i.sezione(), i.valore()); } // @cmember Assegna l'importo passato
const TImporto& operator=(const TImporto& i)
{ return set(i.sezione(), i.valore()); }
// @cmember Assegna l'importo da una <c TToken string> (sezione ambigua se
// ZERO)
const TImporto& operator=(TToken_string& sv); const TImporto& operator=(TToken_string& sv);
// @cmember Aggiunge all'importo l'oggetto passato
const TImporto& operator+=(const TImporto& i); const TImporto& operator+=(const TImporto& i);
// @cmember Sottrae all'importo l'oggetto passato
const TImporto& operator-=(const TImporto& i); const TImporto& operator-=(const TImporto& i);
// @cmember Inverte la sezione se il valore e' minore di 0
const TImporto& normalize(); const TImporto& normalize();
// @cmember Inverte la sezione dell'importo
const TImporto& swap_section(); const TImporto& swap_section();
// @cmember Assegna sezione ed importo all'oggetto
const TImporto& set(char s, const real& v); const TImporto& set(char s, const real& v);
// @cmember Setta i primi due elementi della <c TToken_string>
// al valore dell'importo, lasciando bianco il dare (0) o l'avere(1)
const TImporto& add_to(TToken_string& s) const; const TImporto& add_to(TToken_string& s) const;
TImporto(char s = 'D', const real& v = ZERO) { set(s, v); } // @cmember Costruttore
TImporto(const TImporto& i) : _sezione(i._sezione), _valore(i._valore) {} 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 #endif // __REAL_H