tools

utils.hpp (3793B)

---

 // Copyright (c) 2020 Morel Bérenger
 // 
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 // 
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 // 
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would be
 //    appreciated but is not required.
 // 2. Altered source versions must be plainly marked as such, and must not be
 //    misrepresented as being the original software.
 // 3. This notice may not be removed or altered from any source distribution.
 
 // This files contains various utilities and macros, some
 // useful, some useless, some harmful.
 
 #ifndef UTILS_HPP
 #define UTILS_HPP
 
 //TODO I wish this could be avoided, but FILE* is used there.
 #include <stdio.h>
 
 #define xstr(s) str(s)
 #define str(s) #s
 #define HEADER_LOG __FILE__ "[" xstr(__LINE__) "]"
 
 #ifndef NDEBUG
 //abort-like macro, but more flexible
 #define BUG_CHECK( cond, err )                                     \
 	do                                                               \
 	{                                                                \
 		if( cond )                                                     \
 		{                                                              \
 			fputs( HEADER_LOG ": " #err " caused by " #cond, stderr ); \
 			abort();                                                     \
 		}                                                              \
 	} while( 0 )
 #else
 #define BUG_CHECK( cond, err ) if( cond ) return err
 #endif
 
 //display a system error
 #define syserr( str )                   \
 	do {                                  \
 		fputs( HEADER_LOG ": ", stderr );   \
 		fputs( strerror( errno ), stderr ); \
 		fputs( ": " str "\n", stderr );     \
 	} while( 0 )
 
 // C++ malloc, because casting from malloc is annoying and
 // new does not just allocates (it constructs, too).
 #define ALLOC( type ) static_cast<type*>( malloc( sizeof( type ) ) )
 // tired of looooong lines of code because casting and
 // dereferencing? This saves 6 out of 11 characters per use.
 #define REDEF( type, dst, src ) type& dst = *static_cast<type*>( src )
 
 //simply check if an array is nullptr or starts with a value considered invalid
 template <typename T, T INVALID=T()>
 inline bool empty_array( T* arr )
 {
 	return !arr || *arr == INVALID;
 }
 
 //like fputs, but when character is blank, prints the C escape instead
 //returns 0 on success, INT_MAX on error
 int esc_fputs( const char *s, FILE *stream );
 
 // prints a string into stdin for further reading. Might not
 // be null-terminated.
 inline size_t ungets( char const* const str, size_t str_sz );
 
 // search for a specific character, if not preceded by an escape one.
 // return the distance, or end - start if not found
 inline uint16_t find_unescaped( int ch, int esc_ch, char const* start, char const* end )
 {
 	uint16_t ret = 0;
 	for( ; start != end && *start != ch; ++start, ++ret )
 	{
 		if( *start == esc_ch )
 		{
 			++start;
 			++ret;
 		}
 	}
 	return ret;
 }
 
 // returns the size in characters of terminal fd in w and h.
 // returns true on error.
 bool term_ch_size( uint16_t *w, uint16_t *h, int fd );
 
 // print [txt,end) on target, indenting it level times.
 // When a line is wider than max_width, try to break at last isblank(3).
 // returns true on error.
 // note:
 bool indent_txt( char const* txt, char const* end, uint8_t level, uint16_t max_width, uint8_t tab_width, FILE* target );
 
 #endif