Debugging and tracing

>>>

Common Text Transformation Library http://cttl.sourceforge.net/

Debugging and tracing

Debugging example
debugging_n_tracing.cpp
CTTL_LAMBDA_ASSERT and CTTL_LAMBDA_TRACE
lambda_assert.cpp

CTTL grammars support multiple tracing and debugging facilities. Furthermore, to simplify the debugging of in-line semantic actions, the lambda library provides additional levels of trace output to visualize the execution of lambda expressions at run-time. The messages are sent to the CTTL_UNILOG_STREAM stream (refer to CTTL documentation for the detailed description.) If CTTL_UNILOG_STREAM macro is undefined, the library uses std::cout stream. Trace messages are turned on by a combination of one or more of the following trace-level macros:

Macro	Description
CTTL_TRACE_EVERYTHING	Turns on lambda tracing mode, unless `CTTL_TRACE_DEPOSITS_OFF` is also defined. Usage: #define CTTL_TRACE_EVERYTHING
CTTL_TRACE_RULES	Turns on lambda tracing mode, unless `CTTL_TRACE_DEPOSITS_OFF` is also defined. Usage: #define CTTL_TRACE_RULES
CTTL_TRACE_DEPOSITS	Turns on lambda tracing mode. Usage: #define CTTL_TRACE_DEPOSITS
CTTL_TRACE_DEPOSITS_OFF	Turns lambda tracing mode off; used in combination with `CTTL_TRACE_EVERYTHING` and `CTTL_TRACE_RULES` macros. Usage: #define CTTL_TRACE_DEPOSITS_OFF
CTTL_TRACE_DEPOSIT_JUSTIFY()	In tracing mode, justifies the `CTTL_UNILOG_STREAM` to align output with the current level of CTTL grammar tracing. If tracing mode is off, the macro has no effect on the execution. Usage: CTTL_TRACE_DEPOSIT_JUSTIFY();
CTTL_TRACE_DEPOSIT_TEXT(expression) where `expression` is a C++ expression (not a lambda expression.)	In tracing mode, sends result of expression to `CTTL_UNILOG_STREAM`. If tracing mode is off, has no effect on the execution. Usage: CTTL_TRACE_DEPOSIT_TEXT( "text" ); CTTL_TRACE_DEPOSIT_TEXT( '\n' ); CTTL_TRACE_DEPOSIT_TEXT( 3.14 );
CTTL_LAMBDA_TRACE(message) where `message` is a zero-terminated character string, `char const*`	This is in-line tracing macro for lambda expressions. `CTTL_LAMBDA_TRACE` is implemented as a literal translator: ( ++( scalar( 0 )^atoi^( message ) ) ) In tracing mode, `CTTL_LAMBDA_TRACE` returns the result of `atoi(message)`. For example, CTTL_LAMBDA_TRACE( "-123 abc" ) is legal `atoi` argument and returns minus 123 as the result. If tracing mode is off, the macro has no effect on the execution and returns 1.
CTTL_LAMBDA_ASSERT(expression) where `expression` is a lambda expression.	This is in-line assertion macro for lambda expressions. It tests logical lambda expression. If the result is false, the macro invokes standard C `assert()`. For example, CTTL_LAMBDA_ASSERT( *dstack == scalar( 7.77 ) )

Debugging example

Program debugging_n_tracing.cpp prints tracing messages when tracing mode is on. The code shows how CTTL_LAMBDA_TRACE can be used to trace the source code location:


// debugging_n_tracing.cpp
// Program demonstrates lambda tracing macros.

#define CTTL_TRACE_RULES // automatically turns lambda tracing on

#include "cttl/cttl.h"
#include "lambda/lambda.h"

using namespace cttl;

int main(int argc, char* argv[])
{
    CTTL_TRACE_DEPOSIT_JUSTIFY();
    CTTL_TRACE_DEPOSIT_TEXT( "BEGIN" );
    CTTL_TRACE_DEPOSIT_TEXT( 123 );
    CTTL_TRACE_DEPOSIT_TEXT( std::endl );
    (
        CTTL_LAMBDA_TRACE( "File: " __FILE__ " Line:" CTTL_QUOTED_EXPRESSION( __LINE__ )  )
    ).evaluate();
    CTTL_TRACE_DEPOSIT_JUSTIFY();
    CTTL_TRACE_DEPOSIT_TEXT( "END" );

    return 0;
}
/*Output:
    BEGIN123
    ( ++ "File: .\main.cpp Line:18"  0 )
    END
*/

CTTL_LAMBDA_ASSERT and CTTL_LAMBDA_TRACE

These two macros are in-line assertion and tracing facilities for lambda expressions.
The program lambda_assert.cpp implements a simple grammar rule along with the two lambda-based boolean switch parsers. The CTTL_LAMBDA_TRACE macro prints the message on the screen. It has no effect on the grammar evaluation flow:
```
    CTTL_LAMBDA_TRACE( "checkpoint" )
```
- (Note that the agrument of CTTL_LAMBDA_TRACE must be char const*; no other types are supported. For example, CTTL_LAMBDA_TRACE(123) will not compile.)
Another macro,
```
    CTTL_LAMBDA_ASSERT( scalar( !"bad input" ) )
```
always fails, since the result of logical expression !"bad input" is zero.


// lambda_assert.cpp
// Program demonstrates lambda binary switch parser
// and CTTL_LAMBDA_ASSERT macro.

//#define NDEBUG
#define CTTL_TRACE_EVERYTHING

#include "cttl/cttl.h"
#include "lambda/lambda.h"

using namespace cttl;

int main(/*int argc, char* argv[]*/)
{
    std::string inp = "abc";
    const_edge<> substring( inp );
    (
        CTTL_LAMBDA_TRACE( "checkpoint" )
        |
        symbol( "xyz" )
        |
        CTTL_LAMBDA_ASSERT( scalar( !"bad input" ) )

    ).match( substring );

    return 0;
}

If NDEBUG is defined, CTTL_LAMBDA_ASSERT has no effect, and is being resolved as integral literal 1.

Otherwise, if tracing mode is enabled, (for example, when CTTL_TRACE_EVERYTHING is defined), the program generates output


 --------------------@abc?{|            0-3
 --------------------@abc? {|           0-3
 --------------------@abc?  {u          0-3
                             ( ++ "checkpoint"  0 )
                            }
 ~~~~~~~~~~~~~~~~~~~~~~~@~  T           0-3     FAIL xyz
 ~~~~~~~~~~~~~~~~~~~~~~~@~  |           0-3     FAIL
                           }
 --------------------@abc? {b           0-3
                            ( ||  0 ( -- "Assertion failed: scalar( !"bad input" )
                            in ./main.cpp:20" Assertion failed: CTTL_LAMBDA_ASSERT_,
                            file ./lambda/xst_literal_translator.h, line 110

and then stops the execution on a false assert.

Permission to copy and distribute this document is granted provided this copyright notice appears in all copies. This document is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.

<<< Integer tree

Lambda Home

>>>