Cosa fa:

Questo interprete di linguaggio permette di eseguire un programma scritto in Basic (con un set minimo di istruzioni). Includendolo in altre applicazioni, permette di sviluppare software con le fuzionalità analoghe a quelli che implementano gli script, macro o VBA Visual Basic for Application.

Parti di questo progetto:

• ULCompil.cpp
• ULParser
• ULScan
• CondMgr
• ULTkntpl
• ULToken
• ULJUMPB
• ULMgr
• ULTypDef
• ULEXETKN
• TplClass
• basstr.h
• Altre funzioni necessarie sono presenti nella sezione funzioni c/c++.

Il materiale accessibile da queste pagine fanno parte di una serie di progetti per i quali non è previsto ulteriore sviluppo, ma mantengono la propria validità per studio o base per implementarle in altri progetti.
Il loro impiego in altri software e' libero.
La loro riproduzione su siti e/o stampa deve avvenire nel rispetto della normativa del diritto d'autore.
Per qualunque domanda, mandare una email utilizzando la sezione Contatti di questo sito.

Modulo:

Listato/Codice sorgente: /* ------------------------------------------------------------------------ HISTORY 18/LUG/95 Inizio stesura codice 29/lug/95 Completato Parser matematico 29/nov/95 completato parser con gestione And/Or/Not e operatori relazionali 20/dic/95 takeNumValue() visualizza un errore se la stringa e' vuota 21/dic/95 gestione del segno piu' e meno che aprono un'espressione per gestire: -1-2 */ // ------------------------------------------------------------------------ //#define DBG_DSP_EXEC // esegue display del modo in sui lavora il parser //#define DBG_DSP_WARN // display di warning del parser per casi dubbi // ------------------------------------------------------------------------ #include <stdlib.h> #include <iostream.h> #include <string.h> #include <ctype.h> #include <math.h> #include <assert.h> #include <basstr.h> #include <ulcondit.hpp> // ------------------------------------------------------------------------ enum { // #define OP_START 0 #define OP_END 1 #define LOGICALOPERATOR 4 // (int ) 00000100 #define LOGICALOP_AND (LOGICALOPERATOR + 1) // (int ) 00000100 #define LOGICALOP_OR (LOGICALOPERATOR + 2) // (int ) 00000101 #define LOGICALOP_NOT (LOGICALOPERATOR + 3) // (int ) 00000110 #define RELOPERATOR 16 // (int ) 00100000 #define RELOP_LESSEQUAL (RELOPERATOR + 1) // (int ) 00100000 #define RELOP_GREATEREQUAL (RELOPERATOR + 2) // (int ) 00100001 #define RELOP_NOTEQUAL (RELOPERATOR + 3) // (int ) 00100010 #define RELOP_EQUAL (RELOPERATOR + 4) // (int ) 00100011 #define RELOP_LESS (RELOPERATOR + 5) // (int ) 00100100 #define RELOP_GREATER (RELOPERATOR + 6) // (int ) 00100101 #define MATHOPERATOR 64 // (int ) 01000000 #define MATHOP_SUM (MATHOPERATOR + 1) // (int ) 01000000 #define MATHOP_SUBTRACT (MATHOPERATOR + 2) // (int ) 01000001 #define MATHOP_DIVIDE (MATHOPERATOR + 5) // (int ) 01000100 #define MATHOP_MULTIPLY (MATHOPERATOR + 6) // (int ) 01000101 #define MATHOP_MODULUS (MATHOPERATOR + 9) // (int ) 10000000 #define MATHOP_POWER (MATHOPERATOR + 10) // (int ) 10000001 #define OP_START 128 } ; enum { #define BRACKETOPEN (-1) #define BRACKETCLOSE (-2) } ; enum { #define CHAR_STRING ((char ) '\"') #define CHAR_BRACKETCLOSE (char ) ')' #define CHAR_BRACKETOPEN (char ) '(' } ; enum { #define VALNONE 0 #define VALNUMBER 1 #define VALSTRING 2 #define STRNUMBER_MAX 64 #define DECIMALPOINT ((char ) '.' ) } ; // ------------------------------------------------------------------------ // ----------------------------------- Local Function Prototypes ---------- void takeNumValue( USERLANG_VAL & dx , char * & statement ) ; int takeMathOp( char * & istr ) ; int takeNumSign( char * & istr ) ; void conditionMgrExec_Start( int limit , USERLANG_VAL & sx , char * & statement ) ; void conditionMgrExec2( int limit , USERLANG_VAL & sx , int & sxOp , char * & statement ) ; int takeRelationalOp( char * & i ) ; int takeLogicalAndOr( char * & statement ) ; int checkTypeCoerence( USERLANG_VAL & v , int type ) ; int takeOp( char * & statement ) ; void numExprCompute_Compute( int & sx , int sxOp , int dx ) ; #if defined (DBG_DSP_EXEC) int conditionMgrDisplay_Deep = 0 ; void conditionMgrDisplay( char * , USERLANG_VAL sx , int sxOp , USERLANG_VAL dx , int dxOp , char * ) ; void conditionMgrDisplayOp( int op ) ; void conditionMgrDisplay_Start( char * statement ) ; #endif // ------------------------------------------------------------------------ // USARE per calcolare un espressione USERLANG_VAL computeExpression( char * statement ) { USERLANG_VAL sx ; char * temp_statement = statement ; int sxOp = OP_START ; sx.val.vint = 0 ; sx.type = VALNUMBER ; // esegue il calcolo dell'espressione conditionMgrExec_Start( OP_END , sx , statement ) ; //conditionMgrExec2( OP_END , sx , sxOp , temp_statement ) ; return sx ; } // ------------------------------------------------------------------------ // USARE per calcolare una condizione int conditionMgr( char * statement ) { USERLANG_VAL sx ; char * temp_statement = statement ; // int limit = OP_END ; // int sxOp = OP_START ; sx.val.vint = 0 ; sx.type = 0 ; // calcola il valore dell'espressione conditionMgrExec_Start( OP_END , sx , temp_statement ) ; //conditionMgrExec2( limit , sx , sxOp , temp_statement ) ; assert( * temp_statement == NULL ) ; return sx.val.vint ; } // ---------------------------------------------------------- // Viene richiamato a parentesi aperta // oppure all-inizio void conditionMgrExec_Start( int limit , USERLANG_VAL & sx , char * & statement ) { int dxOp ; int sign ; //USERLANG_VAL dx ; // prende il primo + o - sign = takeNumSign( statement ) ; // prende il primo valore (NOT incluso) takeNumValue( sx , statement ) ; // se e' stato trovato il segno meno allora ribalta il segno if ( sign == MATHOP_SUBTRACT ) { USERLANG_VAL useful ; useful.val.vint = (-1) ; useful.type = VALNUMBER ; numExprCompute_Compute( sx.val.vint , MATHOP_MULTIPLY , useful.val.vint ) ; } // prende operatore dxOp = takeOp( statement ) ; while ( dxOp !=OP_END && dxOp != limit ) //while ( dxOp != OP_END ) { conditionMgrExec2( OP_START , sx , dxOp , statement ) ; } } // ---------------------------------------------------------- void conditionMgrExec2( int limit , USERLANG_VAL & sx , int & sxOp , char * & statement ) { USERLANG_VAL dx ; int dxOp ; dx.type = 0 ; limit = (limit >> 2) ; #if defined (DBG_DSP_EXEC) conditionMgrDisplay_Deep ++ ; #endif do { // prende il primo valore takeNumValue( dx , statement ) ; // prende operatore dxOp = takeOp( statement ) ; if ( (sxOp>>2) < (dxOp>>2) ) { #if defined (DBG_DSP_EXEC) conditionMgrDisplay( "RECU" , sx , sxOp , dx , dxOp , statement ) ; #endif // ricorsione perche l'operarore dxOp ha priorita' conditionMgrExec2( sxOp , dx , dxOp , statement ) ; } #if defined (DBG_DSP_EXEC) conditionMgrDisplay( "EXEC" , sx , sxOp , dx , dxOp , statement ) ; #endif numExprCompute_Compute( sx.val.vint , sxOp , dx.val.vint ) ; sxOp = dxOp ; } while ( dxOp != OP_END && (dxOp>>2) > limit && * statement ) ; sxOp = dxOp ; #if defined (DBG_DSP_EXEC) conditionMgrDisplay_Deep -- ; #endif } // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ void numExprCompute_Compute( int & sx , int sxOp , int dx ) { switch ( sxOp ) { case ( MATHOP_SUM ) : sx += dx ; break ; case ( MATHOP_SUBTRACT ) : sx -= dx ; break ; case ( MATHOP_DIVIDE ) : sx /= dx ; break ; case ( MATHOP_MULTIPLY ) : sx *= dx ; break ; case ( MATHOP_MODULUS ) : sx %= dx ; break ; case ( MATHOP_POWER ) : sx = pow( sx , dx ); break ; case ( LOGICALOP_AND ) : sx = ( sx && dx ) ? 1 : 0 ; break ; case ( LOGICALOP_OR ) : sx = ( sx || dx ) ? 1 : 0 ; break ; case ( LOGICALOP_NOT ) : sx = ~ sx ; break ; case ( RELOP_LESSEQUAL ) : { sx = sx <= dx ? 1 : 0 ; } break ; case ( RELOP_GREATEREQUAL ) : { sx = (sx >= dx ? 1 : 0 ); } break ; case ( RELOP_NOTEQUAL ) : { sx = (sx != dx ? 1 : 0 ) ; } break ; case ( RELOP_EQUAL ) : { sx = ( sx == dx ? 1 : 0 ) ; } break ; case ( RELOP_LESS ) : { sx = (sx < dx ? 1 : 0 ) ; } break ; case ( RELOP_GREATER ) : { sx = ( sx > dx ? 1 : 0 ) ; } break ; case ( OP_START ) : { sx = dx ; } break ; default : cout << "ERRORE : Operatore sconosciuto" << endl ; assert(0) ; } } // ------------------------------------------------------------------------ int takeOp( char * & statement ) { int sxOp = 0 ; // scavalca gli eventuali spazi statement = strskipisspace(statement) ; if ( ! ( sxOp = takeMathOp(statement) ) ) //if ( * statement == CHAR_BRACKETOPEN ) if ( * statement == CHAR_BRACKETCLOSE ) { //statement ++ ; // NO ! sxOp = OP_END ; } else if ( ! ( sxOp = takeRelationalOp( statement ) ) ) if ( ! ( sxOp = takeLogicalAndOr( statement ) ) ) if ( ! * statement ) { sxOp = OP_END ; } return sxOp ; } // ------------------------------------------------------------------------ // NOTA : il puntatore deve essere posizionato sul primo carattere valido int takeMathOp( char * & istr ) { int sxOp = 0 ; switch( * istr ) { case ( '+' ) : sxOp = MATHOP_SUM ; break ; case ( '-' ) : sxOp = MATHOP_SUBTRACT ; break ; case ( '*' ) : sxOp = MATHOP_MULTIPLY ; break ; case ( '/' ) : sxOp = MATHOP_DIVIDE ; break ; case ( '%' ) : sxOp = MATHOP_MODULUS ; break ; case ( '^' ) : sxOp = MATHOP_POWER ; break ; } if ( sxOp != 0 ) { istr ++ ; // scavalca 'op' } return sxOp ; } //------------------------------------------------------------------------ // NOTA : il puntatore deve essere posizionato sul primo carattere valido int takeRelationalOp( char * & i ) { int retval ; if ( (*i == '<') || (*i == '>') || (*i == '=') ) { retval = *i ++ ; if ( (*i == '<') || (*i == '>') || (*i == '=') ) { switch (*i) { case ( '=' ) : if ( retval == '<' ) { retval = RELOP_LESSEQUAL ; } else if ( retval == '>' ) { retval = RELOP_GREATEREQUAL ; } else if ( retval == '=' ) { retval = 0 ; } break ; case ( '>' ) : if ( retval == '<' ) { retval = RELOP_NOTEQUAL ; } else { retval = 0 ; } break ; default : retval = 0 ; } // endswitch // il secondo carattere era corretto ? if ( retval ) { i ++ ; } } else // composto da un solo carattere { switch (retval) { case ( '=' ) : retval = RELOP_EQUAL ; break ; case ( '<' ) : retval = RELOP_LESS ; break ; case ( '>' ) : retval = RELOP_GREATER ; break ; } } } return retval ; } // ------------------------------------------------------------------------ // NOTA : il puntatore deve essere posizionato sul primo carattere valido int takeNumSign( char * & istr ) { int sign = MATHOP_SUM ; if ( * istr == '-' ) { sign = MATHOP_SUBTRACT ; istr ++ ; } else { if ( *istr == '+' ) { istr ++ ; } } return sign ; } // ------------------------------------------------------------------------ int takeValueId( char * statement ) { int retval = VALNONE ; if ( ( isdigit(* statement ) ) || ( (*statement == '+' || *statement == '-' ) ) && ( isdigit(*strskipisspace(statement) ) ) ) { retval = VALNUMBER ; } else if ( * statement == CHAR_STRING ) { // nessun token riconosciuto retval = VALSTRING ; } return retval ; } // ------------------------------------------------------------------------ int takeLogicalAndOr( char * & statement ) { int op = 0 ; statement = strskipisspace( statement ) ; if ( ( toupper( statement[0] ) == 'A' ) && ( toupper( statement[1] ) == 'N' ) && ( toupper( statement[2] ) == 'D' ) ) { statement += 3 ; op = LOGICALOP_AND ; } else if ( ( toupper( statement[0] ) == 'O' ) && ( toupper( statement[1] ) == 'R' ) ) { op = LOGICALOP_OR ; statement += 2 ; } return op ; } // ---------------------------------------------------------------------- int takeLogicalNot( char * & statement ) { int notOp = 0 ; statement = strskipisspace( statement ) ; if ( ( toupper( statement[0] ) == 'N' ) && ( toupper( statement[1] ) == 'O' ) && ( toupper( statement[2] ) == 'T' ) ) { statement += 3 ; notOp = LOGICALOP_NOT ; } return notOp ; } // ---------------------------------------------------------- void valueValReset( USERLANG_VAL v ) { v.type = 0 ; } // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ void takeNumValue( USERLANG_VAL & dx , char * & statement ) { int notOp = takeLogicalNot( statement ) ; if ( * ( statement = strskipisspace( statement ) ) == CHAR_BRACKETOPEN ) { // ---- trovata parentesi aperta: inizio ricorsione USERLANG_VAL appo ; int dxOp = OP_START; appo.type = 0 ; appo.val.vint = 0 ; statement ++ ; // scavalca parentesi aperta #if defined (DBG_DSP_EXEC) conditionMgrDisplay_Start( statement ) ; #endif conditionMgrExec_Start( BRACKETCLOSE , appo , statement ) ; //conditionMgrExec2( OP_END , appo , dxOp , statement ) ; // la funzione deve essere chiusa da parentesi o fine riga if ( * ( statement = strskipisspace( statement ) ) == CHAR_BRACKETCLOSE ) { statement ++ ; // parentesi chiusa dx = appo ; } else { cout << "ERRORE parentesi non combacianti " << endl ; } //assert( dxOp == OP_END ) ; } else { if ( ! * statement ) // controllo che non statement non sia vuoto { cout << "ERRORE: fine prematura dell'espressione" << endl ; dx.val.vint = 0 ; } else { // --- estrazione del valore numerico char strNum[ STRNUMBER_MAX + 1 ] ; int decimale = 0 ; int p = 0 ; int c ; while( 1 ) { c = * statement ; if ( p < STRNUMBER_MAX ) { if ( isdigit(c) ) { strNum[p++] = c ; statement ++ ; } else if ( c == DECIMALPOINT && ! decimale ) { decimale = 1 ; strNum[p++] = c ; statement ++ ; } else { break ; } } } strNum[p] = NULL ; // chiusura dx.val.vint = atoi( strNum ) ; dx.type = VALNUMBER ; if ( p == 0 ) { cout << "ERRORE:Atteso valore numerico; trovato " << "\"" << statement << "\"" << endl ; } #if defined(DBG_DSP_WARN) if ( notOp ) { cout << "Attenzione: operatore NOT opera solo su " << strNum << endl ; } #endif } } // NOT if ( notOp ) { dx.val.vint = ( dx.val.vint ) ? 0 : 1 ; } } // ------------------------------------------------------------------------ // controllo coerenza tipi int checkTypeCoerence( USERLANG_VAL & val , int type ) { int retval = type ; if ( val.type == type || ! val.type ) { val.type = type ; } else { retval = 0 ; cout << "ERROR mismatch" << endl ; } return retval ; } // ---------------------------------------------------------------------- #if defined (DBG_DSP_EXEC) void conditionMgrDisplay_Start( char * statement ) { for ( int x = 1 ; x < conditionMgrDisplay_Deep ; x ++ ) cout << " " ; cout << "RECU " << statement << endl ; } // ---------------------------------------------------------------------- void conditionMgrDisplay( char * desc , USERLANG_VAL sx , int sxOp , USERLANG_VAL dx , int dxOp , char * statement ) { for ( int x = 1 ; x < conditionMgrDisplay_Deep ; x ++ ) cout << " " ; cout << desc << " " ; cout << sx.val.vint ; conditionMgrDisplayOp( sxOp ) ; cout << dx.val.vint ; conditionMgrDisplayOp( dxOp ) ; cout << " -> " ; numExprCompute_Compute( sx.val.vint , sxOp , dx.val.vint ) ; cout << sx.val.vint ; cout << " statmnt: " << statement << endl ; } //------------------------------------------------------------------- void conditionMgrDisplayOp( int op ) { switch ( op ) { case ( MATHOP_SUM ) : cout << "+" ; break ; case ( MATHOP_SUBTRACT ) : cout << "-" ; break ; case ( MATHOP_DIVIDE ) : cout << "/" ; break ; case ( MATHOP_MULTIPLY ) : cout << "*" ; break ; case ( MATHOP_MODULUS ) : cout << "%" ; break ; case ( MATHOP_POWER ) : cout << "^" ; break ; case ( LOGICALOP_AND ) : cout << " and " ; break ; case ( LOGICALOP_OR ) : cout << "or" ; break ; case ( LOGICALOP_NOT ) : cout << ( char ) 7 << "NOT (ma che ci fa qui?)" ; assert( op != LOGICALOP_NOT ) ; break ; case ( RELOP_LESSEQUAL ) : { cout << "<=" ; } break ; case ( RELOP_GREATEREQUAL ) : { cout << ">=" ; } break ; case ( RELOP_NOTEQUAL ) : { cout << "<>" ; } break ; case ( RELOP_EQUAL ) : { cout << "=" ; } break ; case ( RELOP_LESS ) : { cout << "<" ; } break ; case ( RELOP_GREATER ) : { cout << ">" ; } break ; case ( OP_START ) : { cout << " start " ; } break ; } } // ---------------------------------------------------------- #endif

File header/include: