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
class THash_object : public TObject
{
// @cfriend TAssoc_array
friend class TAssoc_array;
// @access Private Member

107
include/checks.cpp
View File

@ -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 <m yesnocancel_box> <m yesnofatal_box>
{
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();
@ -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();
@ -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");

49
include/checks.h
View File

@ -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 <m fatal_box> 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 <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( \
"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 <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( \
"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 <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
#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 <m __trace>
#define TRACE __trace
#else
#define TRACE 1 ? 0 : __trace
#endif
/* @END */
#endif // __CHECKS_H

178
include/config.cpp
View File

@ -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 <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)
{
@ -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
// <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>
{
// 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
// <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);
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
// <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);
}
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");
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 <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);
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 <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);
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 <p section> diventa quello attivo.
// <nl>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 <p fn> e cerca il paragrafo <p pa>. 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)

90
include/config.h
View File

@ -9,6 +9,8 @@
#include <assoc.h>
#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();
};

3
include/date.h
View File

@ -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 ;

21
include/execp.cpp
View File

@ -1,5 +1,3 @@
// fv 6/10/93
#include <stdio.h>
#include <xvt.h>
@ -19,7 +17,18 @@
#include <prefix.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
// @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 <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);

47
include/execp.h
View File

@ -1,6 +1,3 @@
// execp.h; trattasi di -*-c++-*-
// fv 6/10/93
#ifndef __EXECP_H
#define __EXECP_H
@ -8,26 +5,46 @@
#include <object.h>
#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.
// <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)
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);
};

470
include/expr.h
View File

@ -9,48 +9,101 @@
#include <real.h>
#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 "<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
// @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 <p sym> e valore con <p val>
{ 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 <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
// 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 <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)
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 <p varnum>-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 <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
// @FPUB
// @cmember Ritorna il valore della variabile con nome <p varname>
const real& getnum(const char* varname);
// @cmember Ritorna il valore della variabile di posto <p varnum>-esimo
const real& getnum(int varnum);
// @cmember Ritorna il nome della variabile con nome <p varname>
const char* getstring(const char* varname);
// @cmember Ritorna il nome della variabile di posto <p varnum>-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 <p reduct> 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 <p out> (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 <p varnum>
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

287
include/real.cpp
View File

@ -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 <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
{
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 <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;
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 <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 ();
}
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;
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)
{
@ -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 <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 ());
}
@ -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 <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 ());
@ -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 <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 ());
@ -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 <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 ());
}
@ -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 <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 ());
}
@ -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 <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 ());
}
@ -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 <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 ());
}
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 ());
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 ());
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 <p a>
real exp10 (const real & a)
{
@ -701,6 +873,7 @@ real exp10 (const real & a)
return __tmp_real;
}
// @func Calcola l'elevamento a potenza <p b> del numero <p a>
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 <p a>
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 <p zap> 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;
}
}

169
include/real.h
View File

@ -17,55 +17,101 @@
#ifndef __STRINGS_H
#include <strings.h>
#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 <c TObject>)
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 <mf real::string>), 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 <c TToken string> (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 <c TToken_string>
// 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