2021-01-13 17:28:27 +01:00
# include <hex/lang/evaluator.hpp>
2020-11-19 11:36:52 +01:00
2021-01-13 17:28:27 +01:00
# include <hex/lang/token.hpp>
# include <hex/helpers/utils.hpp>
# include <hex/api/content_registry.hpp>
2020-12-27 15:54:12 +01:00
2020-11-20 20:26:19 +01:00
# include <bit>
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
# include <algorithm>
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
# include <unistd.h>
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
namespace hex : : lang {
2020-12-06 21:40:57 +01:00
2021-01-06 16:28:41 +01:00
ASTNodeIntegerLiteral * Evaluator : : evaluateScopeResolution ( ASTNodeScopeResolution * node ) {
ASTNode * currScope = nullptr ;
for ( const auto & identifier : node - > getPath ( ) ) {
if ( currScope = = nullptr ) {
if ( ! this - > m_types . contains ( identifier ) )
break ;
currScope = this - > m_types [ identifier . data ( ) ] ;
} else if ( auto enumNode = dynamic_cast < ASTNodeEnum * > ( currScope ) ; enumNode ! = nullptr ) {
if ( ! enumNode - > getEntries ( ) . contains ( identifier ) )
break ;
else
return evaluateMathematicalExpression ( static_cast < ASTNodeNumericExpression * > ( enumNode - > getEntries ( ) . at ( identifier ) ) ) ;
}
}
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " failed to find identifier " ) ;
2021-01-06 16:28:41 +01:00
}
2021-04-12 20:49:37 +02:00
PatternData * Evaluator : : findPattern ( std : : vector < PatternData * > currMembers , const std : : vector < std : : string > & path ) {
PatternData * currPattern = nullptr ;
for ( const auto & identifier : path ) {
if ( identifier = = " parent " ) {
if ( currPattern = = nullptr ) {
if ( ! currMembers . empty ( ) )
currPattern = this - > m_currMemberScope . back ( ) ;
if ( currPattern = = nullptr )
this - > getConsole ( ) . abortEvaluation ( " attempted to get parent of global namespace " ) ;
}
auto parent = currPattern - > getParent ( ) ;
if ( parent = = nullptr ) {
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " no parent available for identifier '{0}' " , currPattern - > getVariableName ( ) ) ) ;
} else {
currPattern = parent ;
}
} else {
if ( currPattern ! = nullptr ) {
if ( auto structPattern = dynamic_cast < PatternDataStruct * > ( currPattern ) ; structPattern ! = nullptr )
currMembers = structPattern - > getMembers ( ) ;
else if ( auto unionPattern = dynamic_cast < PatternDataUnion * > ( currPattern ) ; unionPattern ! = nullptr )
currMembers = unionPattern - > getMembers ( ) ;
else
this - > getConsole ( ) . abortEvaluation ( " tried to access member of a non-struct/union type " ) ;
}
auto candidate = std : : find_if ( currMembers . begin ( ) , currMembers . end ( ) , [ & ] ( auto member ) {
return member - > getVariableName ( ) = = identifier ;
} ) ;
if ( candidate ! = currMembers . end ( ) )
currPattern = * candidate ;
else
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " no member found with identifier '{0}' " , identifier ) ) ;
}
if ( auto pointerPattern = dynamic_cast < PatternDataPointer * > ( currPattern ) ; pointerPattern ! = nullptr )
currPattern = pointerPattern - > getPointedAtPattern ( ) ;
}
return currPattern ;
}
2021-01-20 22:54:46 +01:00
PatternData * Evaluator : : patternFromName ( const std : : vector < std : : string > & path ) {
2021-04-12 20:49:37 +02:00
PatternData * currPattern = nullptr ;
// Local member access
2021-04-18 20:26:23 +02:00
if ( ! this - > m_currMembers . empty ( ) )
currPattern = this - > findPattern ( * this - > m_currMembers . back ( ) , path ) ;
2021-04-12 20:49:37 +02:00
// If no local member was found, try globally
if ( currPattern = = nullptr ) {
currPattern = this - > findPattern ( this - > m_globalMembers , path ) ;
}
// If still no pattern was found, the path is invalid
if ( currPattern = = nullptr )
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " no identifier with name '{}' was found " , hex : : combineStrings ( path , " . " ) ) ) ;
return currPattern ;
/*std::vector<PatternData*> currMembers;
2021-01-08 17:37:05 +01:00
if ( ! this - > m_currMembers . empty ( ) )
std : : copy ( this - > m_currMembers . back ( ) - > begin ( ) , this - > m_currMembers . back ( ) - > end ( ) , std : : back_inserter ( currMembers ) ) ;
if ( ! this - > m_globalMembers . empty ( ) )
std : : copy ( this - > m_globalMembers . begin ( ) , this - > m_globalMembers . end ( ) , std : : back_inserter ( currMembers ) ) ;
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * currPattern = nullptr ;
2021-01-20 22:54:46 +01:00
for ( u32 i = 0 ; i < path . size ( ) ; i + + ) {
const auto & identifier = path [ i ] ;
2021-01-08 20:12:16 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
if ( auto structPattern = dynamic_cast < PatternDataStruct * > ( currPattern ) ; structPattern ! = nullptr )
2021-01-08 17:37:05 +01:00
currMembers = structPattern - > getMembers ( ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
else if ( auto unionPattern = dynamic_cast < PatternDataUnion * > ( currPattern ) ; unionPattern ! = nullptr )
2021-01-08 17:37:05 +01:00
currMembers = unionPattern - > getMembers ( ) ;
2021-01-08 20:12:16 +01:00
else if ( auto pointerPattern = dynamic_cast < PatternDataPointer * > ( currPattern ) ; pointerPattern ! = nullptr ) {
currPattern = pointerPattern - > getPointedAtPattern ( ) ;
i - - ;
continue ;
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
else if ( currPattern ! = nullptr )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " tried to access member of a non-struct/union type " ) ;
2020-11-19 11:36:52 +01:00
2021-01-08 17:37:05 +01:00
auto candidate = std : : find_if ( currMembers . begin ( ) , currMembers . end ( ) , [ & ] ( auto member ) {
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
return member - > getVariableName ( ) = = identifier ;
} ) ;
2020-11-22 16:22:02 +01:00
2021-01-08 17:37:05 +01:00
if ( candidate ! = currMembers . end ( ) )
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
currPattern = * candidate ;
2020-11-21 23:00:09 +01:00
else
2021-03-03 19:58:22 +01:00
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " could not find identifier '{0}' " , identifier . c_str ( ) ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-19 11:36:52 +01:00
2021-01-08 20:12:16 +01:00
if ( auto pointerPattern = dynamic_cast < PatternDataPointer * > ( currPattern ) ; pointerPattern ! = nullptr )
currPattern = pointerPattern - > getPointedAtPattern ( ) ;
2021-04-12 20:49:37 +02:00
return currPattern ; */
2021-01-20 22:54:46 +01:00
}
ASTNodeIntegerLiteral * Evaluator : : evaluateRValue ( ASTNodeRValue * node ) {
if ( this - > m_currMembers . empty ( ) & & this - > m_globalMembers . empty ( ) )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " no variables available " ) ;
2021-01-20 22:54:46 +01:00
if ( node - > getPath ( ) . size ( ) = = 1 & & node - > getPath ( ) [ 0 ] = = " $ " )
return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned64Bit , this - > m_currOffset } ) ;
auto currPattern = this - > patternFromName ( node - > getPath ( ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
if ( auto unsignedPattern = dynamic_cast < PatternDataUnsigned * > ( currPattern ) ; unsignedPattern ! = nullptr ) {
2021-01-05 14:42:08 +01:00
u8 value [ unsignedPattern - > getSize ( ) ] ;
this - > m_provider - > read ( unsignedPattern - > getOffset ( ) , value , unsignedPattern - > getSize ( ) ) ;
switch ( unsignedPattern - > getSize ( ) ) {
2021-01-10 17:18:14 +01:00
case 1 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned8Bit , hex : : changeEndianess ( * reinterpret_cast < u8 * > ( value ) , 1 , unsignedPattern - > getEndian ( ) ) } ) ;
case 2 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned16Bit , hex : : changeEndianess ( * reinterpret_cast < u16 * > ( value ) , 2 , unsignedPattern - > getEndian ( ) ) } ) ;
case 4 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned32Bit , hex : : changeEndianess ( * reinterpret_cast < u32 * > ( value ) , 4 , unsignedPattern - > getEndian ( ) ) } ) ;
case 8 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned64Bit , hex : : changeEndianess ( * reinterpret_cast < u64 * > ( value ) , 8 , unsignedPattern - > getEndian ( ) ) } ) ;
case 16 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned128Bit , hex : : changeEndianess ( * reinterpret_cast < u128 * > ( value ) , 16 , unsignedPattern - > getEndian ( ) ) } ) ;
2021-01-21 11:36:58 +01:00
default : this - > getConsole ( ) . abortEvaluation ( " invalid rvalue size " ) ;
2021-01-05 14:42:08 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
} else if ( auto signedPattern = dynamic_cast < PatternDataSigned * > ( currPattern ) ; signedPattern ! = nullptr ) {
2021-02-17 21:04:59 +01:00
u8 value [ signedPattern - > getSize ( ) ] ;
2021-01-05 14:42:08 +01:00
this - > m_provider - > read ( signedPattern - > getOffset ( ) , value , signedPattern - > getSize ( ) ) ;
2021-02-17 21:04:59 +01:00
switch ( signedPattern - > getSize ( ) ) {
2021-01-10 17:18:14 +01:00
case 1 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Signed8Bit , hex : : changeEndianess ( * reinterpret_cast < s8 * > ( value ) , 1 , signedPattern - > getEndian ( ) ) } ) ;
case 2 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Signed16Bit , hex : : changeEndianess ( * reinterpret_cast < s16 * > ( value ) , 2 , signedPattern - > getEndian ( ) ) } ) ;
case 4 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Signed32Bit , hex : : changeEndianess ( * reinterpret_cast < s32 * > ( value ) , 4 , signedPattern - > getEndian ( ) ) } ) ;
case 8 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Signed64Bit , hex : : changeEndianess ( * reinterpret_cast < s64 * > ( value ) , 8 , signedPattern - > getEndian ( ) ) } ) ;
case 16 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Signed128Bit , hex : : changeEndianess ( * reinterpret_cast < s128 * > ( value ) , 16 , signedPattern - > getEndian ( ) ) } ) ;
2021-01-21 11:36:58 +01:00
default : this - > getConsole ( ) . abortEvaluation ( " invalid rvalue size " ) ;
2021-01-05 14:42:08 +01:00
}
2021-01-07 00:02:51 +01:00
} else if ( auto enumPattern = dynamic_cast < PatternDataEnum * > ( currPattern ) ; enumPattern ! = nullptr ) {
u8 value [ enumPattern - > getSize ( ) ] ;
this - > m_provider - > read ( enumPattern - > getOffset ( ) , value , enumPattern - > getSize ( ) ) ;
switch ( enumPattern - > getSize ( ) ) {
2021-01-10 17:18:14 +01:00
case 1 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned8Bit , hex : : changeEndianess ( * reinterpret_cast < u8 * > ( value ) , 1 , enumPattern - > getEndian ( ) ) } ) ;
case 2 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned16Bit , hex : : changeEndianess ( * reinterpret_cast < u16 * > ( value ) , 2 , enumPattern - > getEndian ( ) ) } ) ;
case 4 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned32Bit , hex : : changeEndianess ( * reinterpret_cast < u32 * > ( value ) , 4 , enumPattern - > getEndian ( ) ) } ) ;
case 8 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned64Bit , hex : : changeEndianess ( * reinterpret_cast < u64 * > ( value ) , 8 , enumPattern - > getEndian ( ) ) } ) ;
case 16 : return new ASTNodeIntegerLiteral ( { Token : : ValueType : : Unsigned128Bit , hex : : changeEndianess ( * reinterpret_cast < u128 * > ( value ) , 16 , enumPattern - > getEndian ( ) ) } ) ;
2021-01-21 11:36:58 +01:00
default : this - > getConsole ( ) . abortEvaluation ( " invalid rvalue size " ) ;
2021-01-07 00:02:51 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
} else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " tried to use non-integer value in numeric expression " ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-21 23:00:09 +01:00
2021-01-11 23:54:12 +01:00
ASTNode * Evaluator : : evaluateFunctionCall ( ASTNodeFunctionCall * node ) {
2021-01-09 21:47:11 +01:00
std : : vector < ASTNode * > evaluatedParams ;
2021-03-31 22:54:43 +02:00
ON_SCOPE_EXIT {
2021-01-07 15:37:37 +01:00
for ( auto & param : evaluatedParams )
delete param ;
2021-03-31 22:54:43 +02:00
} ;
2021-01-07 15:37:37 +01:00
2021-01-09 21:47:11 +01:00
for ( auto & param : node - > getParams ( ) ) {
if ( auto numericExpression = dynamic_cast < ASTNodeNumericExpression * > ( param ) ; numericExpression ! = nullptr )
evaluatedParams . push_back ( this - > evaluateMathematicalExpression ( numericExpression ) ) ;
else if ( auto stringLiteral = dynamic_cast < ASTNodeStringLiteral * > ( param ) ; stringLiteral ! = nullptr )
evaluatedParams . push_back ( stringLiteral - > clone ( ) ) ;
}
2021-01-07 15:37:37 +01:00
2021-01-11 23:54:12 +01:00
if ( ! ContentRegistry : : PatternLanguageFunctions : : getEntries ( ) . contains ( node - > getFunctionName ( ) . data ( ) ) )
2021-03-03 19:58:22 +01:00
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " no function named '{0}' found " , node - > getFunctionName ( ) . data ( ) ) ) ;
2021-01-07 15:37:37 +01:00
2021-01-11 23:54:12 +01:00
auto & function = ContentRegistry : : PatternLanguageFunctions : : getEntries ( ) [ node - > getFunctionName ( ) . data ( ) ] ;
2021-01-07 15:37:37 +01:00
2021-01-11 23:54:12 +01:00
if ( function . parameterCount = = ContentRegistry : : PatternLanguageFunctions : : UnlimitedParameters ) {
2021-01-07 15:37:37 +01:00
; // Don't check parameter count
}
2021-01-11 23:54:12 +01:00
else if ( function . parameterCount & ContentRegistry : : PatternLanguageFunctions : : LessParametersThan ) {
if ( evaluatedParams . size ( ) > = ( function . parameterCount & ~ ContentRegistry : : PatternLanguageFunctions : : LessParametersThan ) )
2021-03-03 19:58:22 +01:00
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " too many parameters for function '{0}'. Expected {1} " , node - > getFunctionName ( ) . data ( ) , function . parameterCount & ~ ContentRegistry : : PatternLanguageFunctions : : LessParametersThan ) ) ;
2021-01-11 23:54:12 +01:00
} else if ( function . parameterCount & ContentRegistry : : PatternLanguageFunctions : : MoreParametersThan ) {
if ( evaluatedParams . size ( ) < = ( function . parameterCount & ~ ContentRegistry : : PatternLanguageFunctions : : MoreParametersThan ) )
2021-03-03 19:58:22 +01:00
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " too few parameters for function '{0}'. Expected {1} " , node - > getFunctionName ( ) . data ( ) , function . parameterCount & ~ ContentRegistry : : PatternLanguageFunctions : : MoreParametersThan ) ) ;
2021-01-07 15:37:37 +01:00
} else if ( function . parameterCount ! = evaluatedParams . size ( ) ) {
2021-03-03 19:58:22 +01:00
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " invalid number of parameters for function '{0}'. Expected {1} " , node - > getFunctionName ( ) . data ( ) , function . parameterCount ) ) ;
2021-01-07 15:37:37 +01:00
}
2021-01-22 18:01:39 +01:00
return function . func ( * this , evaluatedParams ) ;
2021-01-07 15:37:37 +01:00
}
2021-01-05 14:42:08 +01:00
# define FLOAT_BIT_OPERATION(name) \
2021-01-07 20:06:28 +01:00
auto name ( hex : : floating_point auto left , auto right ) { throw std : : runtime_error ( " " ) ; return 0 ; } \
auto name ( auto left , hex : : floating_point auto right ) { throw std : : runtime_error ( " " ) ; return 0 ; } \
auto name ( hex : : floating_point auto left , hex : : floating_point auto right ) { throw std : : runtime_error ( " " ) ; return 0 ; } \
auto name ( hex : : integral auto left , hex : : integral auto right )
2020-11-19 11:36:52 +01:00
2021-01-05 14:42:08 +01:00
namespace {
FLOAT_BIT_OPERATION ( shiftLeft ) {
return left < < right ;
}
2020-11-21 20:19:33 +01:00
2021-01-05 14:42:08 +01:00
FLOAT_BIT_OPERATION ( shiftRight ) {
return left > > right ;
}
FLOAT_BIT_OPERATION ( bitAnd ) {
return left & right ;
}
FLOAT_BIT_OPERATION ( bitOr ) {
return left | right ;
}
FLOAT_BIT_OPERATION ( bitXor ) {
return left ^ right ;
}
2021-01-07 00:41:06 +01:00
FLOAT_BIT_OPERATION ( bitNot ) {
return ~ right ;
}
2021-01-20 22:55:57 +01:00
FLOAT_BIT_OPERATION ( modulus ) {
return left % right ;
}
2021-01-05 14:42:08 +01:00
}
ASTNodeIntegerLiteral * Evaluator : : evaluateOperator ( ASTNodeIntegerLiteral * left , ASTNodeIntegerLiteral * right , Token : : Operator op ) {
auto newType = [ & ] {
# define CHECK_TYPE(type) if (left->getType() == (type) || right->getType() == (type)) return (type)
# define DEFAULT_TYPE(type) return (type)
2021-01-10 00:40:57 +01:00
if ( left - > getType ( ) = = Token : : ValueType : : Any & & right - > getType ( ) ! = Token : : ValueType : : Any )
return right - > getType ( ) ;
if ( left - > getType ( ) ! = Token : : ValueType : : Any & & right - > getType ( ) = = Token : : ValueType : : Any )
return left - > getType ( ) ;
2021-01-05 14:42:08 +01:00
CHECK_TYPE ( Token : : ValueType : : Double ) ;
CHECK_TYPE ( Token : : ValueType : : Float ) ;
CHECK_TYPE ( Token : : ValueType : : Unsigned128Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Signed128Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Unsigned64Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Signed64Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Unsigned32Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Signed32Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Unsigned16Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Signed16Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Unsigned8Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Signed8Bit ) ;
CHECK_TYPE ( Token : : ValueType : : Character ) ;
2021-01-10 00:40:57 +01:00
CHECK_TYPE ( Token : : ValueType : : Boolean ) ;
2021-01-05 14:42:08 +01:00
DEFAULT_TYPE ( Token : : ValueType : : Signed32Bit ) ;
# undef CHECK_TYPE
# undef DEFAULT_TYPE
} ( ) ;
try {
return std : : visit ( [ & ] ( auto & & leftValue , auto & & rightValue ) - > ASTNodeIntegerLiteral * {
switch ( op ) {
case Token : : Operator : : Plus :
return new ASTNodeIntegerLiteral ( { newType , leftValue + rightValue } ) ;
case Token : : Operator : : Minus :
return new ASTNodeIntegerLiteral ( { newType , leftValue - rightValue } ) ;
case Token : : Operator : : Star :
return new ASTNodeIntegerLiteral ( { newType , leftValue * rightValue } ) ;
case Token : : Operator : : Slash :
2021-03-02 22:55:23 +01:00
if ( rightValue = = 0 )
this - > getConsole ( ) . abortEvaluation ( " Division by zero " ) ;
2021-01-05 14:42:08 +01:00
return new ASTNodeIntegerLiteral ( { newType , leftValue / rightValue } ) ;
2021-01-20 22:55:57 +01:00
case Token : : Operator : : Percent :
2021-03-02 22:55:23 +01:00
if ( rightValue = = 0 )
this - > getConsole ( ) . abortEvaluation ( " Division by zero " ) ;
2021-01-20 22:55:57 +01:00
return new ASTNodeIntegerLiteral ( { newType , modulus ( leftValue , rightValue ) } ) ;
2021-01-05 14:42:08 +01:00
case Token : : Operator : : ShiftLeft :
return new ASTNodeIntegerLiteral ( { newType , shiftLeft ( leftValue , rightValue ) } ) ;
case Token : : Operator : : ShiftRight :
return new ASTNodeIntegerLiteral ( { newType , shiftRight ( leftValue , rightValue ) } ) ;
case Token : : Operator : : BitAnd :
return new ASTNodeIntegerLiteral ( { newType , bitAnd ( leftValue , rightValue ) } ) ;
case Token : : Operator : : BitXor :
return new ASTNodeIntegerLiteral ( { newType , bitXor ( leftValue , rightValue ) } ) ;
case Token : : Operator : : BitOr :
return new ASTNodeIntegerLiteral ( { newType , bitOr ( leftValue , rightValue ) } ) ;
2021-01-07 00:41:06 +01:00
case Token : : Operator : : BitNot :
return new ASTNodeIntegerLiteral ( { newType , bitNot ( leftValue , rightValue ) } ) ;
2021-01-07 00:02:51 +01:00
case Token : : Operator : : BoolEquals :
return new ASTNodeIntegerLiteral ( { newType , leftValue = = rightValue } ) ;
case Token : : Operator : : BoolNotEquals :
return new ASTNodeIntegerLiteral ( { newType , leftValue ! = rightValue } ) ;
case Token : : Operator : : BoolGreaterThan :
return new ASTNodeIntegerLiteral ( { newType , leftValue > rightValue } ) ;
case Token : : Operator : : BoolLessThan :
return new ASTNodeIntegerLiteral ( { newType , leftValue < rightValue } ) ;
case Token : : Operator : : BoolGreaterThanOrEquals :
return new ASTNodeIntegerLiteral ( { newType , leftValue > = rightValue } ) ;
case Token : : Operator : : BoolLessThanOrEquals :
return new ASTNodeIntegerLiteral ( { newType , leftValue < = rightValue } ) ;
case Token : : Operator : : BoolAnd :
return new ASTNodeIntegerLiteral ( { newType , leftValue & & rightValue } ) ;
case Token : : Operator : : BoolXor :
return new ASTNodeIntegerLiteral ( { newType , leftValue & & ! rightValue | | ! leftValue & & rightValue } ) ;
case Token : : Operator : : BoolOr :
return new ASTNodeIntegerLiteral ( { newType , leftValue | | rightValue } ) ;
2021-01-07 00:41:06 +01:00
case Token : : Operator : : BoolNot :
return new ASTNodeIntegerLiteral ( { newType , ! rightValue } ) ;
2021-01-05 14:42:08 +01:00
default :
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " invalid operator used in mathematical expression " ) ;
2021-01-05 14:42:08 +01:00
}
} , left - > getValue ( ) , right - > getValue ( ) ) ;
} catch ( std : : runtime_error & e ) {
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " bitwise operations on floating point numbers are forbidden " ) ;
2021-01-05 14:42:08 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-21 20:19:33 +01:00
2021-01-07 01:19:54 +01:00
ASTNodeIntegerLiteral * Evaluator : : evaluateOperand ( ASTNode * node ) {
if ( auto exprLiteral = dynamic_cast < ASTNodeIntegerLiteral * > ( node ) ; exprLiteral ! = nullptr )
return exprLiteral ;
else if ( auto exprExpression = dynamic_cast < ASTNodeNumericExpression * > ( node ) ; exprExpression ! = nullptr )
return evaluateMathematicalExpression ( exprExpression ) ;
else if ( auto exprRvalue = dynamic_cast < ASTNodeRValue * > ( node ) ; exprRvalue ! = nullptr )
return evaluateRValue ( exprRvalue ) ;
else if ( auto exprScopeResolution = dynamic_cast < ASTNodeScopeResolution * > ( node ) ; exprScopeResolution ! = nullptr )
return evaluateScopeResolution ( exprScopeResolution ) ;
else if ( auto exprTernary = dynamic_cast < ASTNodeTernaryExpression * > ( node ) ; exprTernary ! = nullptr )
return evaluateTernaryExpression ( exprTernary ) ;
2021-01-09 21:47:11 +01:00
else if ( auto exprFunctionCall = dynamic_cast < ASTNodeFunctionCall * > ( node ) ; exprFunctionCall ! = nullptr ) {
auto returnValue = evaluateFunctionCall ( exprFunctionCall ) ;
if ( returnValue = = nullptr )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " function returning void used in expression " ) ;
2021-01-11 23:54:12 +01:00
else if ( auto integerNode = dynamic_cast < ASTNodeIntegerLiteral * > ( returnValue ) ; integerNode ! = nullptr )
return integerNode ;
2021-01-09 21:47:11 +01:00
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " function not returning a numeric value used in expression " ) ;
2021-01-09 21:47:11 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " invalid operand " ) ;
2021-01-07 01:19:54 +01:00
}
ASTNodeIntegerLiteral * Evaluator : : evaluateTernaryExpression ( ASTNodeTernaryExpression * node ) {
switch ( node - > getOperator ( ) ) {
case Token : : Operator : : TernaryConditional : {
auto condition = this - > evaluateOperand ( node - > getFirstOperand ( ) ) ;
2021-03-31 22:54:43 +02:00
ON_SCOPE_EXIT { delete condition ; } ;
2021-01-07 01:19:54 +01:00
if ( std : : visit ( [ ] ( auto & & value ) { return value ! = 0 ; } , condition - > getValue ( ) ) )
return this - > evaluateOperand ( node - > getSecondOperand ( ) ) ;
else
return this - > evaluateOperand ( node - > getThirdOperand ( ) ) ;
}
default :
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " invalid operator used in ternary expression " ) ;
2021-01-07 01:19:54 +01:00
}
}
ASTNodeIntegerLiteral * Evaluator : : evaluateMathematicalExpression ( ASTNodeNumericExpression * node ) {
auto leftInteger = this - > evaluateOperand ( node - > getLeftOperand ( ) ) ;
auto rightInteger = this - > evaluateOperand ( node - > getRightOperand ( ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
return evaluateOperator ( leftInteger , rightInteger , node - > getOperator ( ) ) ;
}
2020-12-06 22:52:15 +01:00
2021-01-21 17:49:30 +01:00
PatternData * Evaluator : : evaluateAttributes ( ASTNode * currNode , PatternData * currPattern ) {
auto attributableNode = dynamic_cast < Attributable * > ( currNode ) ;
if ( attributableNode = = nullptr )
this - > getConsole ( ) . abortEvaluation ( " attributes applied to invalid expression " ) ;
auto handleVariableAttributes = [ this , & currPattern ] ( auto attribute , auto value ) {
2021-01-21 20:55:10 +01:00
if ( attribute = = " color " & & value . has_value ( ) )
2021-02-25 12:08:46 +01:00
currPattern - > setColor ( hex : : changeEndianess ( u32 ( strtoul ( value - > data ( ) , nullptr , 16 ) ) < < 8 , std : : endian : : big ) ) ;
2021-01-21 20:55:10 +01:00
else if ( attribute = = " name " & & value . has_value ( ) )
currPattern - > setVariableName ( value - > data ( ) ) ;
else if ( attribute = = " comment " & & value . has_value ( ) )
currPattern - > setComment ( value - > data ( ) ) ;
2021-01-21 17:49:30 +01:00
else
this - > getConsole ( ) . abortEvaluation ( " unknown or invalid attribute " ) ;
} ;
auto & attributes = attributableNode - > getAttributes ( ) ;
2021-01-21 20:55:10 +01:00
if ( attributes . empty ( ) )
return currPattern ;
2021-01-21 17:49:30 +01:00
if ( auto variableDeclNode = dynamic_cast < ASTNodeVariableDecl * > ( currNode ) ; variableDeclNode ! = nullptr ) {
for ( auto & attribute : attributes )
handleVariableAttributes ( attribute - > getAttribute ( ) , attribute - > getValue ( ) ) ;
} else if ( auto arrayDeclNode = dynamic_cast < ASTNodeArrayVariableDecl * > ( currNode ) ; arrayDeclNode ! = nullptr ) {
for ( auto & attribute : attributes )
handleVariableAttributes ( attribute - > getAttribute ( ) , attribute - > getValue ( ) ) ;
} else if ( auto pointerDeclNode = dynamic_cast < ASTNodePointerVariableDecl * > ( currNode ) ; pointerDeclNode ! = nullptr ) {
for ( auto & attribute : attributes )
handleVariableAttributes ( attribute - > getAttribute ( ) , attribute - > getValue ( ) ) ;
} else if ( auto structNode = dynamic_cast < ASTNodeStruct * > ( currNode ) ; structNode ! = nullptr ) {
this - > getConsole ( ) . abortEvaluation ( " unknown or invalid attribute " ) ;
} else if ( auto unionNode = dynamic_cast < ASTNodeUnion * > ( currNode ) ; unionNode ! = nullptr ) {
this - > getConsole ( ) . abortEvaluation ( " unknown or invalid attribute " ) ;
} else if ( auto enumNode = dynamic_cast < ASTNodeEnum * > ( currNode ) ; enumNode ! = nullptr ) {
this - > getConsole ( ) . abortEvaluation ( " unknown or invalid attribute " ) ;
} else if ( auto bitfieldNode = dynamic_cast < ASTNodeBitfield * > ( currNode ) ; bitfieldNode ! = nullptr ) {
this - > getConsole ( ) . abortEvaluation ( " unknown or invalid attribute " ) ;
} else
this - > getConsole ( ) . abortEvaluation ( " attributes applied to invalid expression " ) ;
return currPattern ;
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluateBuiltinType ( ASTNodeBuiltinType * node ) {
auto & type = node - > getType ( ) ;
auto typeSize = Token : : getTypeSize ( type ) ;
2020-11-21 20:19:33 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * pattern ;
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
if ( type = = Token : : ValueType : : Character )
pattern = new PatternDataCharacter ( this - > m_currOffset ) ;
2021-01-07 17:34:50 +01:00
else if ( type = = Token : : ValueType : : Boolean )
pattern = new PatternDataBoolean ( this - > m_currOffset ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
else if ( Token : : isUnsigned ( type ) )
pattern = new PatternDataUnsigned ( this - > m_currOffset , typeSize ) ;
else if ( Token : : isSigned ( type ) )
pattern = new PatternDataSigned ( this - > m_currOffset , typeSize ) ;
else if ( Token : : isFloatingPoint ( type ) )
pattern = new PatternDataFloat ( this - > m_currOffset , typeSize ) ;
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " invalid builtin type " ) ;
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
this - > m_currOffset + = typeSize ;
2020-12-06 21:40:57 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
pattern - > setTypeName ( Token : : getTypeName ( type ) ) ;
2021-01-08 15:03:53 +01:00
pattern - > setEndian ( this - > getCurrentEndian ( ) ) ;
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
return pattern ;
2020-11-19 11:36:52 +01:00
}
2021-01-10 19:40:44 +01:00
void Evaluator : : evaluateMember ( ASTNode * node , std : : vector < PatternData * > & currMembers , bool increaseOffset ) {
auto startOffset = this - > m_currOffset ;
2021-01-07 00:02:51 +01:00
if ( auto memberVariableNode = dynamic_cast < ASTNodeVariableDecl * > ( node ) ; memberVariableNode ! = nullptr )
2021-01-10 19:40:44 +01:00
currMembers . push_back ( this - > evaluateVariable ( memberVariableNode ) ) ;
2021-01-07 00:02:51 +01:00
else if ( auto memberArrayNode = dynamic_cast < ASTNodeArrayVariableDecl * > ( node ) ; memberArrayNode ! = nullptr )
2021-01-10 19:40:44 +01:00
currMembers . push_back ( this - > evaluateArray ( memberArrayNode ) ) ;
2021-01-07 00:02:51 +01:00
else if ( auto memberPointerNode = dynamic_cast < ASTNodePointerVariableDecl * > ( node ) ; memberPointerNode ! = nullptr )
2021-01-10 19:40:44 +01:00
currMembers . push_back ( this - > evaluatePointer ( memberPointerNode ) ) ;
2021-01-07 00:02:51 +01:00
else if ( auto conditionalNode = dynamic_cast < ASTNodeConditionalStatement * > ( node ) ; conditionalNode ! = nullptr ) {
auto condition = this - > evaluateMathematicalExpression ( static_cast < ASTNodeNumericExpression * > ( conditionalNode - > getCondition ( ) ) ) ;
if ( std : : visit ( [ ] ( auto & & value ) { return value ! = 0 ; } , condition - > getValue ( ) ) ) {
for ( auto & statement : conditionalNode - > getTrueBody ( ) ) {
2021-01-10 19:40:44 +01:00
this - > evaluateMember ( statement , currMembers , increaseOffset ) ;
2021-01-07 00:02:51 +01:00
}
} else {
for ( auto & statement : conditionalNode - > getFalseBody ( ) ) {
2021-01-10 19:40:44 +01:00
this - > evaluateMember ( statement , currMembers , increaseOffset ) ;
2021-01-07 00:02:51 +01:00
}
}
delete condition ;
}
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " invalid struct member " ) ;
2021-01-10 19:40:44 +01:00
if ( ! increaseOffset )
this - > m_currOffset = startOffset ;
2021-01-07 00:02:51 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluateStruct ( ASTNodeStruct * node ) {
std : : vector < PatternData * > memberPatterns ;
2021-04-12 20:49:37 +02:00
auto structPattern = new PatternDataStruct ( this - > m_currOffset , 0 ) ;
structPattern - > setParent ( this - > m_currMemberScope . back ( ) ) ;
2021-01-04 16:13:03 +01:00
this - > m_currMembers . push_back ( & memberPatterns ) ;
2021-04-12 20:49:37 +02:00
this - > m_currMemberScope . push_back ( structPattern ) ;
ON_SCOPE_EXIT {
this - > m_currMembers . pop_back ( ) ;
this - > m_currMemberScope . pop_back ( ) ;
} ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
2021-03-15 08:11:19 +01:00
this - > m_currRecursionDepth + + ;
if ( this - > m_currRecursionDepth > this - > m_recursionLimit )
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " evaluation depth exceeds maximum of {0}. Use #pragma eval_depth <depth> to increase the maximum " , this - > m_recursionLimit ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
auto startOffset = this - > m_currOffset ;
for ( auto & member : node - > getMembers ( ) ) {
2021-01-10 19:40:44 +01:00
this - > evaluateMember ( member , memberPatterns , true ) ;
2021-04-12 20:49:37 +02:00
structPattern - > setMembers ( memberPatterns ) ;
2020-11-27 21:20:23 +01:00
}
2021-04-12 20:49:37 +02:00
structPattern - > setSize ( this - > m_currOffset - startOffset ) ;
2020-11-20 21:29:28 +01:00
2021-03-15 08:11:19 +01:00
this - > m_currRecursionDepth - - ;
2021-04-12 20:49:37 +02:00
return this - > evaluateAttributes ( node , structPattern ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-22 16:22:02 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluateUnion ( ASTNodeUnion * node ) {
std : : vector < PatternData * > memberPatterns ;
2021-04-12 20:49:37 +02:00
auto unionPattern = new PatternDataUnion ( this - > m_currOffset , 0 ) ;
unionPattern - > setParent ( this - > m_currMemberScope . back ( ) ) ;
2021-01-04 16:13:03 +01:00
this - > m_currMembers . push_back ( & memberPatterns ) ;
2021-04-12 20:49:37 +02:00
this - > m_currMemberScope . push_back ( unionPattern ) ;
ON_SCOPE_EXIT {
this - > m_currMembers . pop_back ( ) ;
this - > m_currMemberScope . pop_back ( ) ;
} ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
auto startOffset = this - > m_currOffset ;
2020-11-20 21:29:28 +01:00
2021-03-15 08:11:19 +01:00
this - > m_currRecursionDepth + + ;
if ( this - > m_currRecursionDepth > this - > m_recursionLimit )
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " evaluation depth exceeds maximum of {0}. Use #pragma eval_depth <depth> to increase the maximum " , this - > m_recursionLimit ) ) ;
2021-01-10 19:40:44 +01:00
for ( auto & member : node - > getMembers ( ) ) {
this - > evaluateMember ( member , memberPatterns , false ) ;
2021-04-12 20:49:37 +02:00
unionPattern - > setMembers ( memberPatterns ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-20 21:29:28 +01:00
2021-03-15 08:11:19 +01:00
this - > m_currRecursionDepth - - ;
2021-01-10 19:40:44 +01:00
size_t size = 0 ;
for ( const auto & pattern : memberPatterns )
size = std : : max ( size , pattern - > getSize ( ) ) ;
2021-04-12 20:49:37 +02:00
unionPattern - > setSize ( size ) ;
2021-01-10 19:40:44 +01:00
2021-01-10 22:57:04 +01:00
this - > m_currOffset + = size ;
2021-04-12 20:49:37 +02:00
return this - > evaluateAttributes ( node , unionPattern ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-20 21:29:28 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluateEnum ( ASTNodeEnum * node ) {
2021-01-05 14:42:08 +01:00
std : : vector < std : : pair < Token : : IntegerLiteral , std : : string > > entryPatterns ;
2020-11-20 21:29:28 +01:00
2021-03-31 22:10:06 +02:00
auto underlyingType = dynamic_cast < ASTNodeTypeDecl * > ( node - > getUnderlyingType ( ) ) ;
if ( underlyingType = = nullptr )
this - > getConsole ( ) . abortEvaluation ( " enum underlying type was not ASTNodeTypeDecl. This is a bug " ) ;
size_t size ;
auto builtinUnderlyingType = dynamic_cast < ASTNodeBuiltinType * > ( underlyingType - > getType ( ) ) ;
if ( builtinUnderlyingType ! = nullptr )
size = Token : : getTypeSize ( builtinUnderlyingType - > getType ( ) ) ;
else
this - > getConsole ( ) . abortEvaluation ( " invalid enum underlying type " ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
auto startOffset = this - > m_currOffset ;
for ( auto & [ name , value ] : node - > getEntries ( ) ) {
auto expression = dynamic_cast < ASTNodeNumericExpression * > ( value ) ;
if ( expression = = nullptr )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " invalid expression in enum value " ) ;
2020-11-21 23:00:09 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
auto valueNode = evaluateMathematicalExpression ( expression ) ;
2021-03-31 22:54:43 +02:00
ON_SCOPE_EXIT { delete valueNode ; } ;
2020-11-21 23:00:09 +01:00
2021-04-12 20:49:37 +02:00
entryPatterns . emplace_back ( Token : : castTo ( builtinUnderlyingType - > getType ( ) , valueNode - > getValue ( ) ) , name ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-22 16:22:02 +01:00
2021-01-10 18:24:58 +01:00
this - > m_currOffset + = size ;
2021-04-12 20:49:37 +02:00
auto enumPattern = new PatternDataEnum ( startOffset , size ) ;
enumPattern - > setSize ( size ) ;
enumPattern - > setEnumValues ( entryPatterns ) ;
return this - > evaluateAttributes ( node , enumPattern ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-20 21:29:28 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluateBitfield ( ASTNodeBitfield * node ) {
std : : vector < std : : pair < std : : string , size_t > > entryPatterns ;
2020-12-05 10:36:30 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
auto startOffset = this - > m_currOffset ;
size_t bits = 0 ;
for ( auto & [ name , value ] : node - > getEntries ( ) ) {
auto expression = dynamic_cast < ASTNodeNumericExpression * > ( value ) ;
if ( expression = = nullptr )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " invalid expression in bitfield field size " ) ;
2020-11-21 23:00:09 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
auto valueNode = evaluateMathematicalExpression ( expression ) ;
2021-03-31 22:54:43 +02:00
ON_SCOPE_EXIT { delete valueNode ; } ;
2020-11-20 21:29:28 +01:00
2021-01-21 11:36:58 +01:00
auto fieldBits = std : : visit ( [ this , node , type = valueNode - > getType ( ) ] ( auto & & value ) {
2021-01-05 14:42:08 +01:00
if ( Token : : isFloatingPoint ( type ) )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " bitfield entry size must be an integer value " ) ;
2021-01-05 14:42:08 +01:00
return static_cast < s128 > ( value ) ;
} , valueNode - > getValue ( ) ) ;
if ( fieldBits > 64 | | fieldBits < = 0 )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " bitfield entry must occupy between 1 and 64 bits " ) ;
2020-11-20 21:29:28 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
bits + = fieldBits ;
2020-12-06 21:40:57 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
entryPatterns . emplace_back ( name , fieldBits ) ;
2020-11-20 21:29:28 +01:00
}
2021-01-10 13:40:07 +01:00
size_t size = ( bits + 7 ) / 8 ;
this - > m_currOffset + = size ;
2021-04-12 20:49:37 +02:00
auto bitfieldPattern = new PatternDataBitfield ( startOffset , size ) ;
bitfieldPattern - > setFields ( entryPatterns ) ;
return this - > evaluateAttributes ( node , bitfieldPattern ) ;
2020-11-20 21:29:28 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluateType ( ASTNodeTypeDecl * node ) {
auto type = node - > getType ( ) ;
2021-04-13 20:40:21 +02:00
if ( type = = nullptr )
type = this - > m_types [ node - > getName ( ) . data ( ) ] ;
2021-01-08 15:03:53 +01:00
this - > m_endianStack . push_back ( node - > getEndian ( ) . value_or ( this - > m_defaultDataEndian ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * pattern ;
if ( auto builtinTypeNode = dynamic_cast < ASTNodeBuiltinType * > ( type ) ; builtinTypeNode ! = nullptr )
return this - > evaluateBuiltinType ( builtinTypeNode ) ;
else if ( auto typeDeclNode = dynamic_cast < ASTNodeTypeDecl * > ( type ) ; typeDeclNode ! = nullptr )
pattern = this - > evaluateType ( typeDeclNode ) ;
else if ( auto structNode = dynamic_cast < ASTNodeStruct * > ( type ) ; structNode ! = nullptr )
pattern = this - > evaluateStruct ( structNode ) ;
else if ( auto unionNode = dynamic_cast < ASTNodeUnion * > ( type ) ; unionNode ! = nullptr )
pattern = this - > evaluateUnion ( unionNode ) ;
else if ( auto enumNode = dynamic_cast < ASTNodeEnum * > ( type ) ; enumNode ! = nullptr )
pattern = this - > evaluateEnum ( enumNode ) ;
else if ( auto bitfieldNode = dynamic_cast < ASTNodeBitfield * > ( type ) ; bitfieldNode ! = nullptr )
pattern = this - > evaluateBitfield ( bitfieldNode ) ;
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " type could not be evaluated " ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
if ( ! node - > getName ( ) . empty ( ) )
pattern - > setTypeName ( node - > getName ( ) . data ( ) ) ;
2021-01-08 16:56:39 +01:00
pattern - > setEndian ( this - > getCurrentEndian ( ) ) ;
2021-01-08 15:03:53 +01:00
this - > m_endianStack . pop_back ( ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
return pattern ;
2020-11-19 11:36:52 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluateVariable ( ASTNodeVariableDecl * node ) {
2020-11-20 20:26:19 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
if ( auto offset = dynamic_cast < ASTNodeNumericExpression * > ( node - > getPlacementOffset ( ) ) ; offset ! = nullptr ) {
auto valueNode = evaluateMathematicalExpression ( offset ) ;
2021-03-31 22:54:43 +02:00
ON_SCOPE_EXIT { delete valueNode ; } ;
2020-11-20 20:26:19 +01:00
2021-01-21 11:36:58 +01:00
this - > m_currOffset = std : : visit ( [ this , node , type = valueNode - > getType ( ) ] ( auto & & value ) {
2021-01-05 14:42:08 +01:00
if ( Token : : isFloatingPoint ( type ) )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " placement offset must be an integer value " ) ;
2021-01-05 14:42:08 +01:00
return static_cast < u64 > ( value ) ;
} , valueNode - > getValue ( ) ) ;
2020-11-27 21:20:23 +01:00
}
2021-04-13 21:50:24 +02:00
if ( this - > m_currOffset < this - > m_provider - > getBaseAddress ( ) | | this - > m_currOffset > = this - > m_provider - > getActualSize ( ) + this - > m_provider - > getBaseAddress ( ) ) {
if ( node - > getPlacementOffset ( ) ! = nullptr )
this - > getConsole ( ) . abortEvaluation ( " variable placed out of range " ) ;
else
return nullptr ;
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * pattern ;
if ( auto typeDecl = dynamic_cast < ASTNodeTypeDecl * > ( node - > getType ( ) ) ; typeDecl ! = nullptr )
pattern = this - > evaluateType ( typeDecl ) ;
else if ( auto builtinTypeDecl = dynamic_cast < ASTNodeBuiltinType * > ( node - > getType ( ) ) ; builtinTypeDecl ! = nullptr )
pattern = this - > evaluateBuiltinType ( builtinTypeDecl ) ;
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " ASTNodeVariableDecl had an invalid type. This is a bug! " ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
pattern - > setVariableName ( node - > getName ( ) . data ( ) ) ;
2021-01-21 17:49:30 +01:00
return this - > evaluateAttributes ( node , pattern ) ;
2020-11-20 20:26:19 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluateArray ( ASTNodeArrayVariableDecl * node ) {
2020-11-21 20:19:33 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
if ( auto offset = dynamic_cast < ASTNodeNumericExpression * > ( node - > getPlacementOffset ( ) ) ; offset ! = nullptr ) {
auto valueNode = evaluateMathematicalExpression ( offset ) ;
2021-03-31 22:54:43 +02:00
ON_SCOPE_EXIT { delete valueNode ; } ;
2020-11-19 11:36:52 +01:00
2021-01-21 11:36:58 +01:00
this - > m_currOffset = std : : visit ( [ this , node , type = valueNode - > getType ( ) ] ( auto & & value ) {
2021-01-05 14:42:08 +01:00
if ( Token : : isFloatingPoint ( type ) )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " placement offset must be an integer value " ) ;
2021-01-05 14:42:08 +01:00
return static_cast < u64 > ( value ) ;
} , valueNode - > getValue ( ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-12-06 21:40:57 +01:00
2021-04-13 21:50:24 +02:00
if ( this - > m_currOffset < this - > m_provider - > getBaseAddress ( ) | | this - > m_currOffset > = this - > m_provider - > getActualSize ( ) + this - > m_provider - > getBaseAddress ( ) ) {
if ( node - > getPlacementOffset ( ) ! = nullptr )
this - > getConsole ( ) . abortEvaluation ( " variable placed out of range " ) ;
else
return nullptr ;
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
auto startOffset = this - > m_currOffset ;
2020-11-19 11:36:52 +01:00
2021-01-04 14:10:59 +01:00
ASTNodeIntegerLiteral * valueNode ;
2021-01-07 21:16:34 +01:00
u64 arraySize = 0 ;
2021-01-04 14:10:59 +01:00
2021-01-07 21:16:34 +01:00
if ( node - > getSize ( ) ! = nullptr ) {
if ( auto sizeNumericExpression = dynamic_cast < ASTNodeNumericExpression * > ( node - > getSize ( ) ) ; sizeNumericExpression ! = nullptr )
valueNode = evaluateMathematicalExpression ( sizeNumericExpression ) ;
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " array size not a numeric expression " ) ;
2020-11-21 20:19:33 +01:00
2021-03-31 22:54:43 +02:00
ON_SCOPE_EXIT { delete valueNode ; } ;
2020-11-21 20:19:33 +01:00
2021-01-21 11:36:58 +01:00
arraySize = std : : visit ( [ this , node , type = valueNode - > getType ( ) ] ( auto & & value ) {
2021-01-07 21:16:34 +01:00
if ( Token : : isFloatingPoint ( type ) )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " array size must be an integer value " ) ;
2021-01-07 21:16:34 +01:00
return static_cast < u64 > ( value ) ;
} , valueNode - > getValue ( ) ) ;
2020-11-19 11:36:52 +01:00
2021-01-07 21:16:34 +01:00
if ( auto typeDecl = dynamic_cast < ASTNodeTypeDecl * > ( node - > getType ( ) ) ; typeDecl ! = nullptr ) {
if ( auto builtinType = dynamic_cast < ASTNodeBuiltinType * > ( typeDecl - > getType ( ) ) ; builtinType ! = nullptr ) {
if ( builtinType - > getType ( ) = = Token : : ValueType : : Padding ) {
this - > m_currOffset + = arraySize ;
return new PatternDataPadding ( startOffset , arraySize ) ;
}
2020-12-06 21:40:57 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2021-01-07 21:16:34 +01:00
} else {
u8 currByte = 0x00 ;
u64 offset = startOffset ;
do {
this - > m_provider - > read ( offset , & currByte , sizeof ( u8 ) ) ;
offset + = sizeof ( u8 ) ;
arraySize + = sizeof ( u8 ) ;
} while ( currByte ! = 0x00 & & offset < this - > m_provider - > getSize ( ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-12-06 21:40:57 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
std : : vector < PatternData * > entries ;
std : : optional < u32 > color ;
for ( s128 i = 0 ; i < arraySize ; i + + ) {
PatternData * entry ;
if ( auto typeDecl = dynamic_cast < ASTNodeTypeDecl * > ( node - > getType ( ) ) ; typeDecl ! = nullptr )
entry = this - > evaluateType ( typeDecl ) ;
else if ( auto builtinTypeDecl = dynamic_cast < ASTNodeBuiltinType * > ( node - > getType ( ) ) ; builtinTypeDecl ! = nullptr ) {
entry = this - > evaluateBuiltinType ( builtinTypeDecl ) ;
}
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " ASTNodeVariableDecl had an invalid type. This is a bug! " ) ;
2020-11-19 11:36:52 +01:00
2021-03-03 19:58:22 +01:00
entry - > setVariableName ( hex : : format ( " [{0}] " , ( u64 ) i ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
entry - > setEndian ( this - > getCurrentEndian ( ) ) ;
2020-11-21 20:19:33 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
if ( ! color . has_value ( ) )
color = entry - > getColor ( ) ;
entry - > setColor ( color . value_or ( 0 ) ) ;
2020-11-21 20:19:33 +01:00
2021-04-13 21:50:24 +02:00
if ( this - > m_currOffset > this - > m_provider - > getActualSize ( ) + this - > m_provider - > getBaseAddress ( ) ) {
delete entry ;
break ;
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
entries . push_back ( entry ) ;
2020-11-19 11:36:52 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * pattern ;
2021-01-07 21:16:34 +01:00
if ( entries . empty ( ) ) {
2021-01-04 16:25:03 +01:00
pattern = new PatternDataPadding ( startOffset , 0 ) ;
2021-01-07 21:16:34 +01:00
}
2021-01-04 16:25:03 +01:00
else if ( dynamic_cast < PatternDataCharacter * > ( entries [ 0 ] ) )
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
pattern = new PatternDataString ( startOffset , ( this - > m_currOffset - startOffset ) , color . value_or ( 0 ) ) ;
2021-01-07 21:16:34 +01:00
else {
if ( node - > getSize ( ) = = nullptr )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " no bounds provided for array " ) ;
2021-04-12 20:49:37 +02:00
auto arrayPattern = new PatternDataArray ( startOffset , ( this - > m_currOffset - startOffset ) , color . value_or ( 0 ) ) ;
arrayPattern - > setEntries ( entries ) ;
pattern = arrayPattern ;
2021-01-07 21:16:34 +01:00
}
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
pattern - > setVariableName ( node - > getName ( ) . data ( ) ) ;
2020-11-19 11:36:52 +01:00
2021-01-21 17:49:30 +01:00
return this - > evaluateAttributes ( node , pattern ) ;
2020-11-19 11:36:52 +01:00
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * Evaluator : : evaluatePointer ( ASTNodePointerVariableDecl * node ) {
s128 pointerOffset ;
if ( auto offset = dynamic_cast < ASTNodeNumericExpression * > ( node - > getPlacementOffset ( ) ) ; offset ! = nullptr ) {
auto valueNode = evaluateMathematicalExpression ( offset ) ;
2021-03-31 22:54:43 +02:00
ON_SCOPE_EXIT { delete valueNode ; } ;
2020-11-19 11:36:52 +01:00
2021-01-21 11:36:58 +01:00
pointerOffset = std : : visit ( [ this , node , type = valueNode - > getType ( ) ] ( auto & & value ) {
2021-01-05 14:42:08 +01:00
if ( Token : : isFloatingPoint ( type ) )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " pointer offset must be an integer value " ) ;
2021-01-05 14:42:08 +01:00
return static_cast < s128 > ( value ) ;
} , valueNode - > getValue ( ) ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
this - > m_currOffset = pointerOffset ;
} else {
pointerOffset = this - > m_currOffset ;
2020-11-19 11:36:52 +01:00
}
2021-04-13 21:50:24 +02:00
if ( this - > m_currOffset < this - > m_provider - > getBaseAddress ( ) | | this - > m_currOffset > = this - > m_provider - > getActualSize ( ) + this - > m_provider - > getBaseAddress ( ) ) {
if ( node - > getPlacementOffset ( ) ! = nullptr )
this - > getConsole ( ) . abortEvaluation ( " variable placed out of range " ) ;
else
return nullptr ;
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
PatternData * sizeType ;
2021-01-08 16:56:39 +01:00
auto underlyingType = dynamic_cast < ASTNodeTypeDecl * > ( node - > getSizeType ( ) ) ;
if ( underlyingType = = nullptr )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " underlying type is not ASTNodeTypeDecl. This is a bug " ) ;
2021-01-08 16:56:39 +01:00
if ( auto builtinTypeNode = dynamic_cast < ASTNodeBuiltinType * > ( underlyingType - > getType ( ) ) ; builtinTypeNode ! = nullptr ) {
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
sizeType = evaluateBuiltinType ( builtinTypeNode ) ;
} else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " pointer size is not a builtin type " ) ;
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
size_t pointerSize = sizeType - > getSize ( ) ;
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
u128 pointedAtOffset = 0 ;
2021-04-16 21:50:15 +02:00
this - > m_provider - > read ( pointerOffset , & pointedAtOffset , pointerSize ) ;
2021-01-08 16:56:39 +01:00
this - > m_currOffset = hex : : changeEndianess ( pointedAtOffset , pointerSize , underlyingType - > getEndian ( ) . value_or ( this - > m_defaultDataEndian ) ) ;
delete sizeType ;
2020-11-19 11:36:52 +01:00
2021-01-08 15:03:53 +01:00
2021-04-13 21:50:24 +02:00
if ( this - > m_currOffset > this - > m_provider - > getActualSize ( ) + this - > m_provider - > getBaseAddress ( ) )
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " pointer points past the end of the data " ) ;
2021-01-08 15:03:53 +01:00
PatternData * pointedAt ;
if ( auto typeDecl = dynamic_cast < ASTNodeTypeDecl * > ( node - > getType ( ) ) ; typeDecl ! = nullptr )
pointedAt = this - > evaluateType ( typeDecl ) ;
else if ( auto builtinTypeDecl = dynamic_cast < ASTNodeBuiltinType * > ( node - > getType ( ) ) ; builtinTypeDecl ! = nullptr )
pointedAt = this - > evaluateBuiltinType ( builtinTypeDecl ) ;
else
2021-01-21 11:36:58 +01:00
this - > getConsole ( ) . abortEvaluation ( " ASTNodeVariableDecl had an invalid type. This is a bug! " ) ;
2021-01-08 15:03:53 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
this - > m_currOffset = pointerOffset + pointerSize ;
2020-11-19 11:36:52 +01:00
2021-04-12 20:49:37 +02:00
auto pattern = new PatternDataPointer ( pointerOffset , pointerSize ) ;
2021-01-08 15:03:53 +01:00
pattern - > setVariableName ( node - > getName ( ) . data ( ) ) ;
pattern - > setEndian ( this - > getCurrentEndian ( ) ) ;
2021-04-12 20:49:37 +02:00
pattern - > setPointedAtPattern ( pointedAt ) ;
2021-01-08 15:03:53 +01:00
2021-01-21 17:49:30 +01:00
return this - > evaluateAttributes ( node , pattern ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-19 11:36:52 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
std : : optional < std : : vector < PatternData * > > Evaluator : : evaluate ( const std : : vector < ASTNode * > & ast ) {
2020-11-19 11:36:52 +01:00
2021-01-23 14:00:09 +01:00
this - > m_globalMembers . clear ( ) ;
this - > m_types . clear ( ) ;
this - > m_endianStack . clear ( ) ;
this - > m_currOffset = 0 ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
try {
2021-04-13 20:40:21 +02:00
for ( const auto & node : ast ) {
if ( auto typeDeclNode = dynamic_cast < ASTNodeTypeDecl * > ( node ) ; typeDeclNode ! = nullptr ) {
if ( this - > m_types [ typeDeclNode - > getName ( ) . data ( ) ] = = nullptr )
this - > m_types [ typeDeclNode - > getName ( ) . data ( ) ] = typeDeclNode - > getType ( ) ;
}
}
for ( const auto & [ name , node ] : this - > m_types ) {
if ( auto typeDeclNode = static_cast < ASTNodeTypeDecl * > ( node ) ; typeDeclNode - > getType ( ) = = nullptr )
this - > getConsole ( ) . abortEvaluation ( hex : : format ( " unresolved type '{}' " , name ) ) ;
}
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
for ( const auto & node : ast ) {
2021-04-12 20:49:37 +02:00
this - > m_currMembers . clear ( ) ;
this - > m_currMemberScope . clear ( ) ;
this - > m_currMemberScope . push_back ( nullptr ) ;
2021-01-08 15:03:53 +01:00
this - > m_endianStack . push_back ( this - > m_defaultDataEndian ) ;
2021-03-07 13:20:33 +01:00
this - > m_currRecursionDepth = 0 ;
2020-11-19 11:36:52 +01:00
2021-04-13 21:50:24 +02:00
PatternData * pattern = nullptr ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
if ( auto variableDeclNode = dynamic_cast < ASTNodeVariableDecl * > ( node ) ; variableDeclNode ! = nullptr ) {
2021-04-13 21:50:24 +02:00
pattern = this - > evaluateVariable ( variableDeclNode ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
} else if ( auto arrayDeclNode = dynamic_cast < ASTNodeArrayVariableDecl * > ( node ) ; arrayDeclNode ! = nullptr ) {
2021-04-13 21:50:24 +02:00
pattern = this - > evaluateArray ( arrayDeclNode ) ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
} else if ( auto pointerDeclNode = dynamic_cast < ASTNodePointerVariableDecl * > ( node ) ; pointerDeclNode ! = nullptr ) {
2021-04-13 21:50:24 +02:00
pattern = this - > evaluatePointer ( pointerDeclNode ) ;
2021-01-06 16:28:41 +01:00
} else if ( auto typeDeclNode = dynamic_cast < ASTNodeTypeDecl * > ( node ) ; typeDeclNode ! = nullptr ) {
2021-04-13 20:40:21 +02:00
// Handled above
2021-01-09 21:47:11 +01:00
} else if ( auto functionCallNode = dynamic_cast < ASTNodeFunctionCall * > ( node ) ; functionCallNode ! = nullptr ) {
auto result = this - > evaluateFunctionCall ( functionCallNode ) ;
delete result ;
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
}
2020-11-19 11:36:52 +01:00
2021-04-13 21:50:24 +02:00
if ( pattern ! = nullptr )
this - > m_globalMembers . push_back ( pattern ) ;
2021-01-10 17:14:38 +01:00
this - > m_endianStack . clear ( ) ;
2020-11-19 11:36:52 +01:00
}
2021-01-21 11:36:58 +01:00
} catch ( LogConsole : : EvaluateError & e ) {
this - > getConsole ( ) . log ( LogConsole : : Level : : Error , e ) ;
2021-01-08 15:03:53 +01:00
Pattern Language rewrite (#111)
* Initial parser rewrite effort
Lexer and Token cleanup, Parser started over
* Greatly improved parser syntax
* Reimplemented using declarations and variable placement parsing
* Added back unions and structs
* Added enums as well as mathematical expressions (+, -, *, /, <<, >>, &, |, ^)
* Code style improvement
* Implemented arrays and fixed memory issues
* Fixed more memory issues in parser, reimplemented validator, evaluator and patterns
* Fixed builtin types, arrays and reimplemented strings
* Improved error messages
* Made character a distinct type, used for chars and strings
* Implemented padding, fixed arrays
* Added bitfields
* Added rvalue parsing, no evaluating yet
* Added .idea folder to gitignore
* Fixed build on MacOS
* Added custom implementation of integral concept if not available
* Rebased onto master
* Fixed array variable decl crash
* Added rvalues and dot syntax
* Lower case all pattern language error messages
* Fixed typo in variable name
* Fixed bug where preprocessor would not ignore commented out directives
* Reimplemented pointers
* Fixed rebase issues
2021-01-02 20:27:11 +01:00
return { } ;
2020-11-19 11:36:52 +01:00
}
2021-01-08 17:37:05 +01:00
return this - > m_globalMembers ;
2020-11-19 11:36:52 +01:00
}
}