C/C++ - Caricare dati con etichetta - opinioni? consigli?

Forum - C/C++ - Caricare dati con etichetta - opinioni? consigli?

AldoBaldo (Member)
Guru

Messaggi: 700
Iscritto: 08/01/2015

Postato alle 14:36
Venerdì, 03/04/2020

Per avere rapidamente a disposizione un sistema per caricare file di impostazioni formattati testualmente (e quindi modificabili "a mano") per i miei programmini in C, ho messo insieme un meccanismo che usa tag etichettati in una forma simile a queste:

etichetta(dato) altra_etichetta(altro dato)

etichetta<|dato|> altra_etichetta<|altro dato|>

etichetta123dato456 altra_etichetta123altro dato456

... e così via.

In tutti e tre gli esempi i due dati sono "dato" e "altro dato".
In tutti e tre gli esempi il dato è "accompagnato" da un clausola di apertura e una di chiusura. La clausola di apertura è immediatamente preceduta da un'etichetta univoca, diciamo un ID, a sua volta preceduta da un carattere di spaziatura (a meno che sia subito "in testa" al file, nel qual caso può essere omesso).
L'etichetta e le clausole di apertura/chiusura possono essere qualsiasi stringa venga in mente (caratteri da 1 byte), purché si stia attenti a non generare ambiguità.
Il riconoscimento di etichette e clausole di apertura/chiusura distingue tra maiuscole e minuscole.

Il meccanismo è altamente inefficiente, e si presta solo all'uso con quantità di dati ridotte. In queste condizioni penso possa essere pratico per via della sua immediatezza.

Ecco il codice, per i curiosi.
I file tag_etichettati.h e tag_etichettati.c sono conformati in modo da poter essere compilati come libreria statica.
Il file main.c contiene un programmino che ho predisposto per testare le funzioni di lettura dei dati.

File tag_etichettati.h

Codice sorgente - presumibilmente C++

/* =============================================================================
     LIBRERIA TAG ETICHETTATI
     v 1.0.0, aprile 2020
============================================================================= */
 
#ifndef TAG_ETICHETTATI_H_INCLUDED
#define TAG_ETICHETTATI_H_INCLUDED
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
enum {
    kTEErr_NoErr,           // tutto bene!
    kTEErr_PtrNULL,         // puntatore NULL
    kTEErr_NoAlloc,         // allocazione di memoria fallita
    kTEErr_NomeFileVuoto,   // il nome del file e' una stringa vuota
    kTEErr_NoFile,          // il file non e' stato aperto
    kTEErr_NoLettura,       // non e' stato possibile leggere dal file
    kTEErr_FileEnorme,      // le dimensioni del file superano i 4GB
    kTEErr_StrVuota,        // stringa vuota
    kTEErr_NoFormato,       // formato non valido
    kTEErr_NoEtich,         // etichetta tag non trovata
    kTEErr_NoCont,          // non e' stato trovato alcun contenuto compreso
                            // tra i delimitatori di apertura e di chiusura
    kTEErr_NoInt,           // il contenuto del tag non e' un valore intero
    kTEErr_NoFloat,         // il contenuto del tag non e' un valore con virgola
    kTEErr_TotErrori        // la quantita' totale dei codici d'errore enumerati
};
 
/*==============================================================================
Carica il contenuto del file individuato tramite i dati passati in nomeFile.
I dati vengono caricati in un'area di memoria allocata dinamicamente tramite
malloc() l'indirizzo della quale viene inserito in *contFile. In coda ai dati
caricati viene inserito un terminatore '\0'. Le dimensioni dei dati caricati
(escluso il terminatore) vengono inserite in *lContFile, se il parametro passato
non e' NULL.
 
Spetta al chiamante liberare la memoria eventualmente allocata. In caso di
errori non viene allocata alcuna memoria e il contenuto di contFile e' NULL.
 
PARAMETRI
    contFile    (out) in *contFile viene inserito l'indirizzo dell'area di
                memoria dinamica allocata per copiarci i dati caricati
    lContFile   (out) in *lContFile viene inserito un valore che rappresenta le
                dimensioni dei dati caricati, escluso il terminatore aggiunto
                dalla funzione
    nomeFile    (in) gli estremi del file dal quale vengono caricati i dati
 
VALORE DI RITORNO
    Un codice di errore. In caso di errore, non viene allocata alcuna memoria e
    il contenuto di contFile e' NULL.
==============================================================================*/
 
int TE_carica_file( char **contFile, size_t *lContFile, const char *nomeFile );
 
/*==============================================================================
Individua nella stringa passata tramite il secondo parametro il tag con
l'etichetta specificata, il cui contenuto e' compreso tra i delimitatori
indicati. Il contenuto del tag trovato viene copiato in un'area di memoria
allocata dinamicamente per mezzo di malloc() e l'indirizzo dell'area di memoria
allocata viene restituito inserendolo nell'indirizzo specificato dal chiamante
tramite il primo parametro.
 
Spetta al chiamante liberare la memoria eventualmente allocata. In caso di
errori non viene allocata alcuna memoria e il contenuto di pEstratto e' NULL.
 
PARAMETRI
    pEstratto       (out) a questo indirizzo viene inserito l'indirizzo della
                    memoria allocata tramite malloc() nella quel è stato copiato
                    il contenuto del tag eventualmente trovato;
                    se si verificano errori, non viene inserito nulla
    lEstratto       (out) a questo indirizzo viene inserito un valore che
                    rappresenta la lunghezza della stringa del tag (terminatore
                    escluso);
                    se questo parametro e' NULL, la lunghezza non viene
                    comunicata al chiamante
    stringaDati     (in) la stringa nella quale viene cercato il tag
    etichettaTag    (in) una stringa che rappresenta il nome dell'etichetta del
                    tag da estrarre
    tagApertura     (in) una stringa che rappresenta la sequenza di caratteri
                    che costituisce il delimitatore di apertura del contenuto
                    del tag
    tagChiusura     (in) una stringa che rappresenta la sequenza di caratteri
                    che costituisce il delimitatore di chiusura del contenuto
                    del tag
 
VALORE DI RITORNO
    Un codice di errore. In caso di errore, non viene allocata alcuna memoria e
    il contenuto di pEstratto e' NULL.
==============================================================================*/
 
int TE_estrai_tag_stringa( char **pEstratto, size_t *lEstratto,
    const char *stringaDati, const char *etichettaTag,
    const char *tagApertura, const char *tagChiusura );
 
/*==============================================================================
Le tre funzioni che seguono individuano nella stringa passata tramite il secondo
parametro il tag con l'etichetta specificata, il cui contenuto e' compreso tra i
delimitatori indicati. Il contenuto del tag trovato viene convertito nel tipo di
dato specifico di ogni singola funzione e restituito inserendolo nell'indirizzo
specificato dal chiamante tramite il primo parametro.
 
PARAMETRI
    pEstratto       (out) a questo indirizzo viene inserito il valore letto;
                    se si verificano errori, non viene inserito nulla
    stringaDati     (in) la stringa nella quale viene cercato il tag
    etichettaTag    una stringa che rappresenta il nome dell'etichetta del tag
                    da estrarre
    tagApertura     (in) una stringa che rappresenta la sequenza di caratteri
                    che costituisce il delimitatore di apertura del contenuto
                    del tag
    tagChiusura     (in) una stringa che rappresenta la sequenza di caratteri
                    che costituisce il delimitatore di chiusura del contenuto
                    del tag
 
VALORE DI RITORNO
    Un codice di errore. In caso di errore, il contenuto di pEstratto non viene
    modificato.
==============================================================================*/
 
int TE_estrai_tag_intero( long long *pEstratto,
    const char *stringaDati, const char *etichettaTag,
    const char *tagApertura, const char *tagChiusura );
 
int TE_estrai_tag_virgola( long double *pEstratto,
    const char *stringaDati, const char *etichettaTag,
    const char *tagApertura, const char *tagChiusura );
 
int TE_estrai_tag_esadecimale( long long *pEstratto,
    const char *stringaDati, const char *etichettaTag,
    const char *tagApertura, const char *tagChiusura );
 
/*==============================================================================
Restituisce il puntatore a una stringa che descrive brevemente il tipo di errore
corrispondente al codice passato come parametro.
NON BISOGNA DEALLOCARE IL PUNTATORE RESTITUITO (punta a una costante stringa).
==============================================================================*/
 
const char *TE_descrizione_errore( int codice );
 
#ifdef __cplusplus
}
#endif
 
#endif // TAG_ETICHETTATI_H_INCLUDED

File tag_etichettati.c

Codice sorgente - presumibilmente Delphi

/* =============================================================================
     LIBRERIA TAG ETICHETTATI
     v 1.0.0, aprile 2020
============================================================================= */
 
#include "tag_etichettati.h"
 
static const char *TE_ErrStr[kTEErr_TotErrori] = {
    "ok",
    "puntatore NULL",
    "allocazione di memoria fallita",
    "nome del file vuoto",
    "impossibile aprire il file",
    "impossibile leggere dal file",
    "le dimensioni del file superano i 4GB",
    "stringa vuota",
    "formato non valido",
    "etichetta non valida",
    "contenuto non trovato",
    "valore non intero",
    "valore non in virgola mobile"
};
 
static int TE_trova_contenuto( const char **cont, size_t *lCont,
                               const char *s,
                               const char *a, size_t la,
                               const char *c, size_t lc );
 
int TE_carica_file( char **contFile, size_t *lContFile, const char *nomeFile ) {
    int err = kTEErr_NoErr;
 
    if( contFile ) *contFile = NULL;
 
    if( contFile && nomeFile ) {
        if( *nomeFile ) {
 
            FILE *f = fopen( nomeFile, "r" );
 
            if( f ) {
                size_t i, dimFile = 0;
                int c = fgetc(f);
 
                while( EOF!=c && dimFile!=((size_t)-1) )
                    { c = fgetc(f); ++dimFile; }
 
                if( dimFile != ((size_t)-1) ) {
                    char *cfTmp = malloc( dimFile+1 );
 
                    if( NULL != cfTmp ) {
                        for( rewind(f), i=0, c=fgetc(f); EOF!=c; ++i ) {
                            cfTmp[i] = c;
                            c = fgetc(f);
                        }
 
                        if( i==dimFile ) {
                            cfTmp[dimFile] = '\0';
                            *contFile = cfTmp;
                            if( NULL != lContFile )
                                *lContFile = dimFile;
                            err = kTEErr_NoErr;
                        }
                        else {
                            free( cfTmp );
                            err = kTEErr_NoLettura;
                        }
                    } else err = kTEErr_NoAlloc;
                } else err = kTEErr_FileEnorme;
 
                fclose( f );
            } else err = kTEErr_NoFile;
        } else err = kTEErr_NomeFileVuoto;
    } else err = kTEErr_PtrNULL;
 
    return err;
}
 
int TE_estrai_tag_stringa( char **pEstratto, size_t *lEstratto,
    const char *stringaDati, const char *etichettaTag,
    const char *tagApertura, const char *tagChiusura ) {
    int err = kTEErr_NoErr;
 
    if( pEstratto ) *pEstratto = NULL;
 
    if( pEstratto && stringaDati && etichettaTag && tagApertura && tagChiusura ) {
        size_t ls = strlen( stringaDati );
        size_t le = strlen( etichettaTag );
        size_t la = strlen( tagApertura );
        size_t lc = strlen( tagChiusura );
 
        if( ls && le && la && lc ) {
            const char *p = stringaDati;
            const char *cont;
            size_t lCont;
 
            do {
                err = TE_trova_contenuto( &cont, &lCont, p, tagApertura, la, tagChiusura, lc );
 
                if( kTEErr_NoErr == err ) {
                    // la corrispondenza dell'etichetta viene accettata come
                    // valida solo se e' la prima etichetta della stringa dei
                    // dati o se e' immediatamente preceduta da un carattere di
                    // spaziatura riconosciuto come tale da isspace()
                    const char *pe = cont-la-le; // pe: puntatore etichetta
                    int primo = (stringaDati==pe);
 
                    if( (primo||((!primo)&&isspace(*(pe-1)))) &&
                        0==strncmp(pe,etichettaTag,le) ) {
                        char *eTmp = malloc( lCont+1 );
 
                        if( NULL != eTmp ) {
                            memcpy( eTmp, cont, lCont );
                            eTmp[lCont] = '\0';
                            *pEstratto = eTmp;
                            if( NULL!=lEstratto )
                                *lEstratto = lCont;
                            return kTEErr_NoErr;
                        } else return kTEErr_NoAlloc;
                    }
 
                    // se arriva qui, ripete il ciclo per
                    // controllare il prossimo contenuto
                    p = cont+lCont+lc;
 
                } else return err;
            } while( *p && p-stringaDati<ls );
            err = kTEErr_NoEtich;
        } else err = kTEErr_StrVuota;
    } else err = kTEErr_PtrNULL;
 
    return err;
}
 
int TE_estrai_tag_intero(   long long *pEstratto,
    const char *stringaDati, const char *etichettaTag,
    const char *tagApertura, const char *tagChiusura ) {
    char *s = NULL;
 
    int err = TE_estrai_tag_stringa( &s, NULL, stringaDati,
                                     etichettaTag, tagApertura, tagChiusura );
 
    if( kTEErr_NoErr == err ) {
        char *fine;
        long long eTmp = strtoll( s, &fine, 10 );
 
        if( s!=fine && '\0'==*fine )
            *pEstratto = eTmp;
        else err = kTEErr_NoInt;
 
        free( s );
    }
 
    return err;
}
 
int TE_estrai_tag_virgola( long double *pEstratto,
    const char *stringaDati, const char *etichettaTag,
    const char *tagApertura, const char *tagChiusura ) {
    char *s = NULL;
 
    int err = TE_estrai_tag_stringa( &s, NULL, stringaDati,
                                     etichettaTag, tagApertura, tagChiusura );
 
    if( kTEErr_NoErr == err ) {
        char *fine;
        long double eTmp = strtold( s, &fine );
 
        if( s!=fine && '\0'==*fine )
            *pEstratto = eTmp;
        else err = kTEErr_NoFloat;
 
        free( s );
    }
 
    return err;
}
 
int TE_estrai_tag_esadecimale(   long long *pEstratto,
    const char *stringaDati, const char *etichettaTag,
    const char *tagApertura, const char *tagChiusura ) {
    char *s = NULL;
 
    int err = TE_estrai_tag_stringa( &s, NULL, stringaDati,
                                     etichettaTag, tagApertura, tagChiusura );
 
    if( kTEErr_NoErr == err ) {
        char *fine, *sAux = '0'==s[0] && 'x'==s[1] ? s+2 : s;
        long long eTmp = strtoll( sAux, &fine, 16 );
 
        if( sAux!=fine && '\0'==*fine )
            *pEstratto = eTmp;
        else err = kTEErr_NoInt;
 
        free( s );
    }
 
    return err;
}
 
const char *TE_descrizione_errore( int codice ) {
    if( codice>=0 && codice<kTEErr_TotErrori )
        return TE_ErrStr[codice];
    else return "Errore non previsto.";
}
 
 
/// ===> FUNZIONI STATICHE <====================================================
 
 
/*==============================================================================
PARAMETRI
    cont    (out) qui viene messo il puntatore alla sottostringa del contenuto
    lCont   (out) la lunghezza della sottostringa del contenuto trovato
    s       (in)  la stringa nella quale effettuare la ricerca
    a       (in)  la stringa della clausola di apertura
    la      (in)  la lunghezza della stringa della clausola di apertura
    c       (in)  la stringa della clausola di chiusura
    lc      (in)  la lunghezza della stringa della clausola di chiusura
 
N.B. NESSUN PARAMETRO VIENE VERIFICATO
 
VALORE DI RITORNO
    Un codice di errore.
==============================================================================*/
 
static int TE_trova_contenuto( const char **cont, size_t *lCont,
                               const char *s,
                               const char *a, size_t la,
                               const char *c, size_t lc ) {
    const char *contTmp = NULL;
    int aperto = 0;
 
    while( *s ) {
        if( *s == *a || *s == *c ) {
            int apertura, chiusura;
 
            if( (apertura=(0==strncmp(s,a,la))) ) {
                if( !aperto ) {
                    aperto = 1;
                    s += la;
                    contTmp = s;
                    continue;
                }
 
                return kTEErr_NoFormato;
            }
 
            if( (chiusura=(0==strncmp(s,c,lc))) ) {
                if( aperto ) {
                    *cont  = contTmp;
                    *lCont = s-contTmp;
                    return kTEErr_NoErr;
                }
 
                return kTEErr_NoFormato;
            }
        }
 
        ++s;
    }
 
    return kTEErr_NoCont;
}

File main.c

Codice sorgente - presumibilmente C++

#include "tag_etichettati.h"
 
#define LMAX_ETICHETTA 255U
#define LMAX_CLAUSOLE   31U
#define LMAX_TIPODATO   31U
#define Q_TIPIDATO       4U
 
const char *kNomeFileDati = "dati.txt";
const char *kTipiDato[Q_TIPIDATO]={"stringa","intero","virgola","esadecimale"};
 
char *gDati = NULL;
char gEtichetta[LMAX_ETICHETTA+1];
char gApertura[LMAX_CLAUSOLE+1];
char gChiusura[LMAX_CLAUSOLE+1];
unsigned int gTipoDato = -1;
 
void chiedi_dati( void );
void gestisci_estrazione_tag( void );
int continua( void );
 
int main() {
    int err = TE_carica_file( &gDati, NULL, kNomeFileDati );
 
    if( kTEErr_NoErr == err ) {
        do {
            chiedi_dati();
            gestisci_estrazione_tag();
        } while( continua() );
    }
 
    if( gDati ) { free( gDati ); gDati = NULL; }
 
    if( kTEErr_NoErr != err ) printf( "ERRORE: " );
    printf( "%s.\n\n", TE_descrizione_errore(err) );
 
    getchar();
    return 0;
}
 
void chiedi_stringa( char *buff, unsigned int lMax ) {
    unsigned int l;
 
    do {
        fgets( buff, lMax+1, stdin );
 
        l = strlen( buff );
 
        if( l>0 ) {
            if( '\n' == buff[l-1] ) {
                buff[--l] = '\0';
                break;
            }
            else {
                while( '\n' != getchar() );
                printf( "Max %u caratteri, riprova: ", lMax-1 );
                continue;
            }
        }
    } while(1);
}
 
int continua( void ) {
    char buff[4];
 
    chiedi_continua:
 
    printf( "Vuoi effettuare un altro test? (s/n) " );
    chiedi_stringa( buff, 2 );
 
    if( 's'==*buff || 'S'==*buff )
        return 1;
    else if( 'n'==*buff || 'N'==*buff )
        return 0;
 
    printf( "Non ho capito.\n" );
    goto chiedi_continua;
}
 
void chiedi_etichetta( void ) {
    printf( "Etichetta: " );
    chiedi_stringa( gEtichetta, LMAX_ETICHETTA );
}
 
void chiedi_clausola_apertura( void ) {
    printf( "Clausola d'apertura: " );
    chiedi_stringa( gApertura, LMAX_CLAUSOLE );
}
 
void chiedi_clausola_chiusura( void ) {
    printf( "Clausola di chiusura: " );
    chiedi_stringa( gChiusura, LMAX_CLAUSOLE );
}
 
void chiedi_tipo_dato( void ) {
    char strTipoDato[LMAX_TIPODATO+1];
    unsigned int i;
 
    printf( "Tipo di dato: " );
 
    richiesta:
    chiedi_stringa( strTipoDato, LMAX_TIPODATO );
 
    for( i=0; i<Q_TIPIDATO; ++i ) {
        if(0==strcmp(kTipiDato[i],strTipoDato) ) {
            gTipoDato = i;
            break;
        }
    }
 
    if( Q_TIPIDATO==i ) {
        printf( "Tipo di dato non valido, riprova: " );
        goto richiesta;
    }
}
 
void chiedi_dati( void ) {
    printf( "\n" );
    chiedi_etichetta();
    chiedi_clausola_apertura();
    chiedi_clausola_chiusura();
    chiedi_tipo_dato();
}
 
void mostra_dati_globali( void ) {
    printf( "\n" );
    printf( "Etichetta:            %s\n", gEtichetta );
    printf( "Clausola d'apertura:  %s\n", gApertura );
    printf( "Clausola di chiusura: %s\n", gChiusura );
}
 
void gestisci_estrazione_tag_stringa( void ) {
    char *str = NULL;
    size_t lStr = 0;
 
    int err = TE_estrai_tag_stringa( &str, &lStr, gDati,
                  gEtichetta, gApertura, gChiusura );
 
    mostra_dati_globali();
 
    if( kTEErr_NoErr == err )
        printf( "Contenuto del tag:    \"%s\"\n\n", str );
    else printf( "Errore: %s.\n\n", TE_descrizione_errore(err) );
}
 
void gestisci_estrazione_tag_intero( void ) {
    long long intero;
 
    int err = TE_estrai_tag_intero( &intero, gDati,
                  gEtichetta, gApertura, gChiusura );
 
    mostra_dati_globali();
 
    if( kTEErr_NoErr == err )
        printf( "Contenuto del tag:    %lld\n\n", intero );
    else printf( "Errore: %s.\n\n", TE_descrizione_errore(err) );
}
 
void gestisci_estrazione_tag_virgola( void ) {
    long double virgola;
 
    int err = TE_estrai_tag_virgola( &virgola, gDati,
                  gEtichetta, gApertura, gChiusura );
 
    mostra_dati_globali();
 
    if( kTEErr_NoErr == err )
        printf( "Contenuto del tag:    %llf\n\n", virgola );
    else printf( "Errore: %s.\n\n", TE_descrizione_errore(err) );
}
 
void gestisci_estrazione_tag_esadecimale( void ) {
    long long intero;
 
    int err = TE_estrai_tag_esadecimale( &intero, gDati,
                  gEtichetta, gApertura, gChiusura );
 
    mostra_dati_globali();
 
    if( kTEErr_NoErr == err )
        printf( "Contenuto del tag:    %llx\n\n", intero );
    else printf( "Errore: %s.\n\n", TE_descrizione_errore(err) );
}
 
void gestisci_estrazione_tag( void ) {
    switch( gTipoDato ) {
        case 0: gestisci_estrazione_tag_stringa();     break;
        case 1: gestisci_estrazione_tag_intero();      break;
        case 2: gestisci_estrazione_tag_virgola();     break;
        case 3: gestisci_estrazione_tag_esadecimale(); break;
        default: puts( "Errore: tipo dato non riconosciuto.\n" );
    }
}

Perché ho messo qui il codice? Boh. Magari a qualcuno scappa qualche commento o, meglio, qualche suggerimento. Tenete sempre presente che per me tutto questo è un passatempo, non un mestiere -- non sono neanche lontamente uno "specialista".

Ultima modifica effettuata da AldoBaldo il 03/04/2020 alle 14:39

ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.

Goblin (Member)
Expert

Messaggi: 375
Iscritto: 02/02/2011

Postato alle 21:58
Venerdì, 03/04/2020

Testo quotato

Postato originariamente da AldoBaldo:
Perché ho messo qui il codice? Boh. Magari a qualcuno scappa qualche commento o, meglio, qualche suggerimento. Tenete sempre presente che per me tutto questo è un passatempo, non un mestiere -- non sono neanche lontamente uno "specialista".

Su questo punto hai tutta la mia comprensione.
Cmq io sparo la cavolata dopo quasi 1 mese di clausura con moglie figli e cani, hai pensato a gestire oggetti JSON ???
In fondo il principo del formato JSON è CHIAVE:VALORE il che riconduce al tuo ETICHETTA

ATO.
In C puro non saprei come manipolarlo, ma sicuramente ci sarà in giro documentazione.
OK se ho detto una cavolata ... mi fustigo da solo ... tanto sono in clausura :blush:

PS: Maestro AldoBaldo... la forza scorre forte nei nostri Padawan, ricorda
G.

Ibis redibis non morieris in bello

AldoBaldo (Member)
Guru

Messaggi: 700
Iscritto: 08/01/2015

Postato alle 0:20
Sabato, 04/04/2020

Non ricordo più da parte di chi, ma un riferimento a questo JSON era già apparso in questi luoghi. Incuriosito, avevo cercato qualche informazione, ma ne avevo ricavato la sensazione di essere davanti a qualcosa di più articolato di quello che sarei stato in grado di "manipolare". Potrei provare a rivedere quelle informazioni oggi. Magari in questi anni ho assimiliato quanto serve per capirci di più. Sai che faccio? Cerco subito e torno a scrivere le mie impressioni.
Grazie per lo spunto.

===================

EDIT

Ho letto qualcosina.

Ora ricordo perché l'avevo scartato. Ci sono alcune cose che mi mettono "all'angolo". Cito testualmente dal testo che ho appena scorso:

1) "strutture possono essere annidate"
2) "raccolta di zero o più caratteri Unicode"
3) "sequenze di escape" (segue nutrito elenco)
4) esistono già svariate librerie e classi per gestire questo formato

1) leggere e interpretare strutture annidate mi mette in crisi, risolvere il problema richiede con ogni probabilità tecniche che uso a stento, che non padroneggio (ricorsione?)
2) non conosco i meccanismi per usare Unicode, che non ho mai usato
3) dovrei prendere in considerazione tutta una pletora di sequenze di escape, capirne il meccanismo
4) ...per poi ottenere qualcosa che è già stato fatto e rifatto infinite volte, cioè per "reinventare la ruota"

No, affrontare 'sto JSON non mi divertirebbe neppure oggi (e non so neppure se riuscirei ad arrivare all'obbiettivo che avevo in mente). Per i miei scopi (limitati) credo sia più semplice e diretta la strada che ho seguito. Ammesso che funzioni come ho in mente e non ci siano difetti che mandano tutto a rotoli.

Comunque, proprio in questo momento sto ancora leggendo altre pagine. Magari cambio idea, chissà.

P.S. La forza non so neppure più dove stia di casa. Più che a "Guerre stellari" sento di potermi rifare a questo:

https://it.wikipedia.org/wiki/Balle_spaziali

Ultima modifica effettuata da AldoBaldo il 04/04/2020 alle 0:41

Goblin (Member)
Expert

Messaggi: 375
Iscritto: 02/02/2011

Postato alle 1:05
Sabato, 04/04/2020

Testo quotato

Postato originariamente da AldoBaldo:

https://it.wikipedia.org/wiki/Balle_spaziali

Maestro AldoBaldo, vedo che hai anche tu l'anello, il tuo Sforzo è come mio, vediamo come lo maneggi..

Ultima modifica effettuata da Goblin il 04/04/2020 alle 1:06

Ibis redibis non morieris in bello

nessuno (Normal User)
Guru^2

Messaggi: 6404
Iscritto: 03/01/2010

Postato alle 8:46
Sabato, 04/04/2020

Potresti usare dei file .ini

Vecchia roba (sarebbe meglio un xml) ma ti potrebbe bastare per i tuoi scopi. E hai le api in windows. Come facevano tutti nei decenni passati prima che tu scoprissi questa necessita' e reinventassi la ruota

Vedi

WritePrivateProfileString
GetPrivateProfileString

Ultima modifica effettuata da nessuno il 04/04/2020 alle 8:47

Ricorda che nessuno è obbligato a risponderti e che nessuno è perfetto ...
---
Il grande studioso italiano Bruno de Finetti ( uno dei padri fondatori del moderno Calcolo delle probabilità ) chiamava il gioco del Lotto Tassa sulla stupidità.

AldoBaldo (Member)
Guru

Messaggi: 700
Iscritto: 08/01/2015

Postato alle 9:22
Sabato, 04/04/2020

Nei file .ini mi sono in effetti imbattututo più volte, sono tanti i programmi che ne spargono qua e là, però non ho mai approfondito. E' un bel suggerimento, questa sero leggerò senz'altro qualcosa e ti dirò com'è andata. Ora devo andare a piantare le cipolle, se no mi germogliano nel sacchetto e si indeboliscono.

AldoBaldo (Member)
Guru

Messaggi: 700
Iscritto: 08/01/2015

Postato alle 23:10
Domenica, 05/04/2020

Piantate le cipolle! Taaaaante cipolle. Domani sera, tempo permettendo, vado giù di scalogno.

Ho pure trovato il tempo di vedere qualche informazione sul formato .ini. Non ne sono rimasto esaltato. Per i miei scopi limitati, continuo a preferire il mio metodo "ruspante".