48 lines
1.8 KiB
C
48 lines
1.8 KiB
C
// RUN: cat %s | %cling -I%p | FileCheck %s
|
|
|
|
// The tests shows the basic control flow structures that contain dynamic
|
|
// expressions. There are several cases that could be distinguished.
|
|
// 1. IfStmt with dynamic expression in the condition like if (h->Draw())
|
|
// In that case we know that the condition is going to be implicitly
|
|
// casted to bool. Clang does it even for integral types.
|
|
// 1.1 if the dynamic expression result type is bool no cast is needed
|
|
// and there shouldn't be problems at all.
|
|
// 1.2 if the dynamic expression is of integral type like int clang
|
|
// makes implicit cast. I've tested with few examples and it works
|
|
// even without the cast
|
|
// The real problem is that if we want to stick to clang's AST in the same
|
|
// way as clang builds it we need to have implicit casts for the dynamic
|
|
// expressions which return type differs from bool. The problem is we cannot
|
|
// do that at compile time because we don't know the return type of the
|
|
// expression.
|
|
|
|
|
|
#include "cling/Interpreter/Interpreter.h"
|
|
#include "cling/Interpreter/InterpreterCallbacks.h"
|
|
extern "C" int printf(const char*,...);
|
|
|
|
.dynamicExtensions
|
|
gCling->setCallbacks(new cling::test::SymbolResolverCallback(gCling));
|
|
|
|
int a[5] = {1,2,3,4,5};
|
|
if (h->PrintArray(a, 5)) { // runtime result type bool
|
|
whatever->PrintString("Replaced in then.\n");
|
|
printf("\n%s\n", "Array Printed Successfully!");
|
|
}
|
|
// CHECK: 12345
|
|
// CHECK: Array Printed Successfully!
|
|
|
|
int b, c = 1;
|
|
// Note that in case of function not returning bool we need an ImplicitCast
|
|
// which is tricky because we don't know the type of the function
|
|
if (h->Add(b, c)) { // runtime result type int
|
|
printf("\n%s\n", "Sum more than 0!");
|
|
}
|
|
// CHECK: Sum more than 0!
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
dependentInLoop->Add(b, c);
|
|
}
|
|
//CHECK-NOT:(int) 1
|
|
.q
|