END_TEST
#define make_str(x) #x
START_TEST(Reading_invalid_piref_fails)
{
const char* data[] =
{
"0, 0]",
"[0 0]",
"[0, 0",
"[0, -1]",
"[-1, 0]",
"[0, " make_str(KQT_PAT_INSTANCES_MAX) "]",
"[" make_str(KQT_PATTERNS_MAX) ", 0]",
};
for (size_t i = 0; i < arr_size(data); ++i)
{
Streader* sr = init_with_cstr(data[i]);
Pat_inst_ref* result = PAT_INST_REF_AUTO;
fail_if(Streader_read_piref(sr, result),
"Streader accepted `%s` as a valid pattern instance reference",
data[i]);
}
}
/// Initialize the ROOT environment to compile and execute a ROOT AClick
int initAClick(const char* command=0) {
std::string rootsys = make_str(gSystem->Getenv("ROOTSYS"));
std::string geant4 = make_str(gSystem->Getenv("G4INSTALL"));
std::string dd4hep = make_str(gSystem->Getenv("DD4hepINSTALL"));
std::string clhep = make_str(gSystem->Getenv("CLHEP_DIR"));
std::string defs = "";
std::string libs = " -L"+rootsys+"/lib";
std::string inc = " -I"+dd4hep+"/examples/DDG4/examples -I"+dd4hep + " -I"+dd4hep+"/include";
libs += " -L"+dd4hep+"/lib -lDDCore -lDDG4 -lDDSegmentation";
if ( !geant4.empty() ) {
inc += " -I"+geant4+"/include/Geant4";
libs += (" -L"+geant4+"/lib -L"+geant4+"/lib64 -lG4event -lG4tracking -lG4particles");
}
if ( !clhep.empty() ) {
// A bit unclear how to deal with CLHEP libraries here,
// if CLHEP is not included in Geant4...
inc += " -I"+clhep+"/include";
}
inc += " -Wno-shadow -g -O0" + defs;
if ( ROOT_VERSION_CODE < ROOT_VERSION(6,0,0) )
libs += " -lCint";
libs += " -lCore -lMathCore -pthread -lm -ldl -rdynamic";
gSystem->AddIncludePath(inc.c_str());
gSystem->AddLinkedLibs(libs.c_str());
std::cout << "+++ Includes: " << gSystem->GetIncludePath() << std::endl;
std::cout << "+++ Linked libs:" << gSystem->GetLinkedLibs() << std::endl;
int ret = gSystem->Load("libDDG4Plugins");
if ( 0 == ret ) {
if ( command ) {
processCommand(command, true);
}
}
return ret;
}
// Like make_str, but parses entities.
// Returns an inline sequence consisting of str and entity elements.
static cmark_node *make_str_with_entities(cmark_chunk *content)
{
cmark_strbuf unescaped = GH_BUF_INIT;
if (houdini_unescape_html(&unescaped, content->data, (size_t)content->len)) {
return make_str(cmark_chunk_buf_detach(&unescaped));
} else {
return make_str(*content);
}
}
// Like make_str, but parses entities.
static cmark_node *make_str_with_entities(cmark_mem *mem,
cmark_chunk *content) {
cmark_strbuf unescaped = CMARK_BUF_INIT(mem);
if (houdini_unescape_html(&unescaped, content->data, content->len)) {
return make_str(mem, cmark_chunk_buf_detach(&unescaped));
} else {
return make_str(mem, *content);
}
}
/* Parse and evaluate match (regex) expressions */
struct val *
eval5(void)
{
regex_t rp;
regmatch_t rm[2];
char errbuf[256];
int eval;
struct val *l, *r;
struct val *v;
l = eval6();
while (token == MATCH) {
nexttoken(1);
r = eval6();
/* coerce to both arguments to strings */
to_string(l);
to_string(r);
/* compile regular expression */
if ((eval = regcomp(&rp, r->u.s, 0)) != 0) {
regerror(eval, &rp, errbuf, sizeof(errbuf));
errx(2, "%s", errbuf);
}
/* compare string against pattern -- remember that patterns
are anchored to the beginning of the line */
if (regexec(&rp, l->u.s, 2, rm, 0) == 0 && rm[0].rm_so == 0) {
if (rm[1].rm_so >= 0) {
*(l->u.s + rm[1].rm_eo) = '\0';
v = make_str(l->u.s + rm[1].rm_so);
} else {
v = make_int((int)(rm[0].rm_eo - rm[0].rm_so));
}
} else {
if (rp.re_nsub == 0) {
v = make_int(0);
} else {
v = make_str("");
}
}
/* free arguments and pattern buffer */
free_value(l);
free_value(r);
regfree(&rp);
l = v;
}
return l;
}
// Parse backslash-escape or just a backslash, returning an inline.
static cmark_node *handle_backslash(subject *subj) {
advance(subj);
unsigned char nextchar = peek_char(subj);
if (cmark_ispunct(
nextchar)) { // only ascii symbols and newline can be escaped
advance(subj);
return make_str(subj->mem, cmark_chunk_dup(&subj->input, subj->pos - 1, 1));
} else if (!is_eof(subj) && skip_line_end(subj)) {
return make_linebreak(subj->mem);
} else {
return make_str(subj->mem, cmark_chunk_literal("\\"));
}
}
// Assumes we have a period at the current position.
static cmark_node *handle_period(subject *subj, bool smart) {
advance(subj);
if (smart && peek_char(subj) == '.') {
advance(subj);
if (peek_char(subj) == '.') {
advance(subj);
return make_str(subj->mem, cmark_chunk_literal(ELLIPSES));
} else {
return make_str(subj->mem, cmark_chunk_literal(".."));
}
} else {
return make_str(subj->mem, cmark_chunk_literal("."));
}
}
// Parse an entity or a regular "&" string.
// Assumes the subject has an '&' character at the current position.
static cmark_node *handle_entity(subject *subj) {
cmark_strbuf ent = CMARK_BUF_INIT(subj->mem);
bufsize_t len;
advance(subj);
len = houdini_unescape_ent(&ent, subj->input.data + subj->pos,
subj->input.len - subj->pos);
if (len == 0)
return make_str(subj->mem, cmark_chunk_literal("&"));
subj->pos += len;
return make_str(subj->mem, cmark_chunk_buf_detach(&ent));
}
// Assumes we have a hyphen at the current position.
static cmark_node* handle_hyphen(subject* subj, bool smart)
{
advance(subj);
if (smart && peek_char(subj) == '-') {
advance(subj);
if (peek_char(subj) == '-') {
advance(subj);
return make_str(cmark_chunk_literal(EMDASH));
} else {
return make_str(cmark_chunk_literal(ENDASH));
}
} else {
return make_str(cmark_chunk_literal("-"));
}
}
extern "C" CDECL rust_str *
upcall_dup_str(rust_task *task, rust_task *target, rust_str *str) {
LOG_UPCALL_ENTRY(task);
scoped_lock with(task->kernel->scheduler_lock);
return make_str(target, (char const *)str->data, str->fill);
}
extern "C" CDECL rust_str *
upcall_new_str(rust_task *task, char const *s, size_t fill) {
LOG_UPCALL_ENTRY(task);
scoped_lock with(task->kernel->scheduler_lock);
return make_str(task, s, fill);
}
int ft_readline(int fd, char **line)
{
int line_end;
int can_read;
t_fd *fdatas;
static t_fd *flst;
if (!(fdatas = get_fdatas(&flst, fd)))
return (-1);
if (fdatas->start == -1)
{
free(fdatas->lst);
fdatas->lst = NULL;
fdatas->start = 0;
return (0);
}
line_end = get_line_end(fdatas, &can_read);
*line = make_str(fdatas, line_end);
if (line_end < FILE_BUFF_SIZE && can_read == 0)
fdatas->start = -1;
if (line_end == FILE_BUFF_SIZE && can_read == 0)
return (0);
if (can_read == -1 || line == NULL)
return (-1);
return (1);
}
int get_next_line(int const fd, char **line)
{
int line_end;
int can_read;
t_fd *fdatas;
static t_fd *flst;
fdatas = get_fdatas(&flst, fd);
if (fdatas == NULL)
return (-1);
if (fdatas->start == -1)
{
free(fdatas->lst);
fdatas->lst = NULL;
fdatas->start = 0;
return (0);
}
line_end = get_line_end(fdatas, &can_read);
*line = make_str(fdatas, line_end);
if (can_read == 0)
fdatas->start = -1;
if (can_read == -1)
return (-1);
if (line == NULL)
return (-1);
return (1);
}
char *cpy_from_env(char **tab, char *str)
{
char *found;
int i;
int j;
j = 0;
i = 0;
while (tab[j] != NULL && str[i] != '\0')
{
while (tab[j][i] != str[i] && str[i] != '\0' && tab[j][i] != '\0')
{
i = 0;
j++;
if (tab[j] == NULL)
return (NULL);
}
if (tab[j][i] == str[i])
i++;
}
if (i == 0)
return (NULL);
found = make_str(found, tab[j]);
return (found);
}
// Parse an autolink or HTML tag.
// Assumes the subject has a '<' character at the current position.
static cmark_node *handle_pointy_brace(subject *subj) {
bufsize_t matchlen = 0;
cmark_chunk contents;
advance(subj); // advance past first <
// first try to match a URL autolink
matchlen = scan_autolink_uri(&subj->input, subj->pos);
if (matchlen > 0) {
contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1);
subj->pos += matchlen;
return make_autolink(subj->mem, contents, 0);
}
// next try to match an email autolink
matchlen = scan_autolink_email(&subj->input, subj->pos);
if (matchlen > 0) {
contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1);
subj->pos += matchlen;
return make_autolink(subj->mem, contents, 1);
}
// finally, try to match an html tag
matchlen = scan_html_tag(&subj->input, subj->pos);
if (matchlen > 0) {
contents = cmark_chunk_dup(&subj->input, subj->pos - 1, matchlen + 1);
subj->pos += matchlen;
return make_raw_html(subj->mem, contents);
}
// if nothing matches, just return the opening <:
return make_str(subj->mem, cmark_chunk_literal("<"));
}
// Assumes the subject has a c at the current position.
static cmark_node* handle_delim(subject* subj, unsigned char c, bool smart)
{
int numdelims;
cmark_node * inl_text;
bool can_open, can_close;
cmark_chunk contents;
numdelims = scan_delims(subj, c, &can_open, &can_close);
if (c == '\'' && smart) {
contents = cmark_chunk_literal(RIGHTSINGLEQUOTE);
} else if (c == '"' && smart) {
contents = cmark_chunk_literal(can_close ? RIGHTDOUBLEQUOTE : LEFTDOUBLEQUOTE);
} else {
contents = cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims);
}
inl_text = make_str(contents);
if ((can_open || can_close) &&
(!(c == '\'' || c == '"') || smart)) {
push_delimiter(subj, c, can_open, can_close, inl_text);
}
return inl_text;
}
extern "C" CDECL void
upcall_s_str_new_uniq(s_str_new_uniq_args *args) {
rust_task *task = args->task;
LOG_UPCALL_ENTRY(task);
args->retval = make_str(task->kernel, args->cstr, args->len,
"str_new_uniq");
}
// Assumes we have a hyphen at the current position.
static cmark_node *handle_hyphen(subject *subj, bool smart) {
cmark_strbuf buf = CMARK_BUF_INIT(NULL);
int startpos = subj->pos;
int en_count = 0;
int em_count = 0;
int numhyphens;
int i;
advance(subj);
if (!smart || peek_char(subj) != '-') {
return make_str(subj->mem, cmark_chunk_literal("-"));
}
while (smart && peek_char(subj) == '-') {
advance(subj);
}
numhyphens = subj->pos - startpos;
buf.mem = subj->mem;
if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes
em_count = numhyphens / 3;
} else if (numhyphens % 2 == 0) { // if divisible by 2, use all en dashes
en_count = numhyphens / 2;
} else if (numhyphens % 3 == 2) { // use one en dash at end
en_count = 1;
em_count = (numhyphens - 2) / 3;
} else { // use two en dashes at the end
en_count = 2;
em_count = (numhyphens - 4) / 3;
}
for (i = em_count; i > 0; i--) {
cmark_strbuf_puts(&buf, EMDASH);
}
for (i = en_count; i > 0; i--) {
cmark_strbuf_puts(&buf, ENDASH);
}
return make_str(subj->mem, cmark_chunk_buf_detach(&buf));
}
int main(int argc, char* argv[]) {
char dest[10];
char * name;
name = make_str();
// assert(strlen(name) < 10);
__CPROVER_assume(strlen(name) < 10);
strcpy(dest, name);
return 0;
}
extern "C" CDECL rust_vec_box*
rust_list_files(rust_str *path) {
rust_task *task = rust_get_current_task();
array_list<rust_str*> strings;
#if defined(__WIN32__)
WIN32_FIND_DATA FindFileData;
HANDLE hFind = FindFirstFile((char*)path->body.data, &FindFileData);
if (hFind != INVALID_HANDLE_VALUE) {
do {
rust_str *str = make_str(task->kernel, FindFileData.cFileName,
strlen(FindFileData.cFileName),
"list_files_str");
strings.push(str);
} while (FindNextFile(hFind, &FindFileData));
FindClose(hFind);
}
#else
DIR *dirp = opendir((char*)path->body.data);
if (dirp) {
struct dirent *dp;
while ((dp = readdir(dirp))) {
rust_vec_box *str = make_str(task->kernel, dp->d_name,
strlen(dp->d_name),
"list_files_str");
strings.push(str);
}
closedir(dirp);
}
#endif
rust_vec_box *vec = (rust_vec_box *)
task->kernel->malloc(vec_size<rust_vec_box*>(strings.size()),
"list_files_vec");
size_t alloc_sz = sizeof(rust_vec*) * strings.size();
vec->body.fill = vec->body.alloc = alloc_sz;
memcpy(&vec->body.data[0], strings.data(), alloc_sz);
return vec;
}
LLVMValueRef gen_const(struct node *ast)
{
switch (ast->val[0]) {
case '\'':
return make_char(ast->val);
case '"':
return make_str(ast->val);
case '0':
/* TODO: Support 09 and 08: see section 4.1.4 */
return LLVMConstIntOfString(TYPE_INT, ast->val, 8);
default:
return LLVMConstIntOfString(TYPE_INT, ast->val, 10);
}
}
extern "C" rust_str *
shape_log_str(const type_desc *tydesc, uint8_t *data) {
rust_task *task = rust_get_current_task();
shape::arena arena;
std::stringstream ss;
shape::log log(task, true, tydesc->shape, tydesc->shape_tables,
data, ss);
log.walk();
int len = ss.str().length();
return make_str(task->kernel, ss.str().c_str(), len, "log_str");
}
// Parse strong/emph or a fallback.
// Assumes the subject has '_' or '*' at the current position.
static cmark_node* handle_strong_emph(subject* subj, unsigned char c)
{
int numdelims;
cmark_node * inl_text;
bool can_open, can_close;
numdelims = scan_delims(subj, c, &can_open, &can_close);
inl_text = make_str(cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims));
if (can_open || can_close) {
push_delimiter(subj, c, can_open, can_close, inl_text);
}
return inl_text;
}
// Parse backtick code section or raw backticks, return an inline.
// Assumes that the subject has a backtick at the current position.
static cmark_node* handle_backticks(subject *subj)
{
cmark_chunk openticks = take_while(subj, isbacktick);
int startpos = subj->pos;
int endpos = scan_to_closing_backticks(subj, openticks.len);
if (endpos == 0) { // not found
subj->pos = startpos; // rewind
return make_str(openticks);
} else {
cmark_strbuf buf = GH_BUF_INIT;
cmark_strbuf_set(&buf, subj->input.data + startpos, endpos - startpos - openticks.len);
cmark_strbuf_trim(&buf);
cmark_strbuf_normalize_whitespace(&buf);
return make_code(cmark_chunk_buf_detach(&buf));
}
}
extern "C" CDECL rust_str*
last_os_error() {
rust_task *task = rust_get_current_task();
LOG(task, task, "last_os_error()");
#if defined(__WIN32__)
LPTSTR buf;
DWORD err = GetLastError();
DWORD res = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &buf, 0, NULL);
if (!res) {
task->fail();
return NULL;
}
#elif defined(_GNU_SOURCE)
char cbuf[BUF_BYTES];
char *buf = strerror_r(errno, cbuf, sizeof(cbuf));
if (!buf) {
task->fail();
return NULL;
}
#else
char buf[BUF_BYTES];
int err = strerror_r(errno, buf, sizeof(buf));
if (err) {
task->fail();
return NULL;
}
#endif
rust_str * st = make_str(task->kernel, buf, strlen(buf),
"last_os_error");
#ifdef __WIN32__
LocalFree((HLOCAL)buf);
#endif
return st;
}
void
nexttoken(int pat)
{
char *p;
if ((p = *av) == NULL) {
token = EOI;
return;
}
av++;
if (pat == 0 && p[0] != '\0') {
if (p[1] == '\0') {
const char *x = "|&=<>+-*/%:()";
char *i; /* index */
if ((i = strchr(x, *p)) != NULL) {
token = i - x;
return;
}
} else if (p[1] == '=' && p[2] == '\0') {
switch (*p) {
case '<':
token = LE;
return;
case '>':
token = GE;
return;
case '!':
token = NE;
return;
}
}
}
tokval = make_str(p);
token = OPERAND;
return;
}
command_line_args(rust_task *task,
int sys_argc,
char **sys_argv)
: kernel(task->kernel),
task(task),
argc(sys_argc),
argv(sys_argv)
{
#if defined(__WIN32__)
LPCWSTR cmdline = GetCommandLineW();
LPWSTR *wargv = CommandLineToArgvW(cmdline, &argc);
kernel->win32_require("CommandLineToArgvW", wargv != NULL);
argv = (char **) kernel->malloc(sizeof(char*) * argc,
"win32 command line");
for (int i = 0; i < argc; ++i) {
int n_chars = WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1,
NULL, 0, NULL, NULL);
kernel->win32_require("WideCharToMultiByte(0)", n_chars != 0);
argv[i] = (char *) kernel->malloc(n_chars,
"win32 command line arg");
n_chars = WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1,
argv[i], n_chars, NULL, NULL);
kernel->win32_require("WideCharToMultiByte(1)", n_chars != 0);
}
LocalFree(wargv);
#endif
args = (rust_vec *)
kernel->malloc(vec_size<rust_vec*>(argc),
"command line arg interior");
args->fill = args->alloc = sizeof(rust_vec*) * argc;
for (int i = 0; i < argc; ++i) {
rust_str *str = make_str(kernel, argv[i],
strlen(argv[i]),
"command line arg");
((rust_str**)&args->data)[i] = str;
}
}
extern "C" CDECL rust_str *
rust_getcwd() {
rust_task *task = rust_scheduler::get_task();
LOG(task, task, "rust_getcwd()");
char cbuf[BUF_BYTES];
#if defined(__WIN32__)
if (!_getcwd(cbuf, sizeof(cbuf))) {
#else
if (!getcwd(cbuf, sizeof(cbuf))) {
#endif
task->fail();
return NULL;
}
return make_str(task->kernel, cbuf, strlen(cbuf), "rust_str(getcwd");
}
// TODO: Allow calling native functions that return double results.
extern "C" CDECL
void squareroot(double *input, double *output) {
*output = sqrt(*input);
}
extern "C" CDECL rust_str *
rust_getcwd() {
rust_task *task = rust_get_current_task();
LOG(task, task, "rust_getcwd()");
char cbuf[BUF_BYTES];
#if defined(__WIN32__)
if (!_getcwd(cbuf, sizeof(cbuf))) {
#else
if (!getcwd(cbuf, sizeof(cbuf))) {
#endif
task->fail();
return NULL;
}
return make_str(task->kernel, cbuf, strlen(cbuf), "rust_str(getcwd)");
}
#if defined(__WIN32__)
extern "C" CDECL rust_vec_box *
rust_env_pairs() {
rust_task *task = rust_get_current_task();
size_t envc = 0;
LPTCH ch = GetEnvironmentStringsA();
LPTCH c;
for (c = ch; *c; c += strlen(c) + 1) {
++envc;
}
c = ch;
rust_vec_box *v = (rust_vec_box *)
task->kernel->malloc(vec_size<rust_vec_box*>(envc),
"str vec interior");
v->body.fill = v->body.alloc = sizeof(rust_vec*) * envc;
for (size_t i = 0; i < envc; ++i) {
size_t n = strlen(c);
rust_str *str = make_str(task->kernel, c, n, "str");
((rust_str**)&v->body.data)[i] = str;
c += n + 1;
}
if (ch) {
FreeEnvironmentStrings(ch);
}
return v;
}
#else
extern "C" CDECL rust_vec_box *
rust_env_pairs() {
rust_task *task = rust_get_current_task();
#ifdef __APPLE__
char **environ = *_NSGetEnviron();
#endif
char **e = environ;
size_t envc = 0;
while (*e) {
++envc; ++e;
}
return make_str_vec(task->kernel, envc, environ);
}
#endif
extern "C" CDECL void
unsupervise() {
rust_task *task = rust_get_current_task();
task->unsupervise();
}
// Parse an inline, advancing subject, and add it as a child of parent.
// Return 0 if no inline can be parsed, 1 otherwise.
static int parse_inline(subject* subj, cmark_node * parent, int options)
{
cmark_node* new_inl = NULL;
cmark_chunk contents;
unsigned char c;
int endpos;
c = peek_char(subj);
if (c == 0) {
return 0;
}
switch(c) {
case '\n':
new_inl = handle_newline(subj);
break;
case '`':
new_inl = handle_backticks(subj);
break;
case '\\':
new_inl = handle_backslash(subj);
break;
case '&':
new_inl = handle_entity(subj);
break;
case '<':
new_inl = handle_pointy_brace(subj);
break;
case '*':
case '_':
case '\'':
case '"':
new_inl = handle_delim(subj, c, options & CMARK_OPT_SMART);
break;
case '-':
new_inl = handle_hyphen(subj, options & CMARK_OPT_SMART);
break;
case '.':
new_inl = handle_period(subj, options & CMARK_OPT_SMART);
break;
case '[':
advance(subj);
new_inl = make_str(cmark_chunk_literal("["));
push_delimiter(subj, '[', true, false, new_inl);
break;
case ']':
new_inl = handle_close_bracket(subj, parent);
break;
case '!':
advance(subj);
if (peek_char(subj) == '[') {
advance(subj);
new_inl = make_str(cmark_chunk_literal("
