void heap_stat(heapstat_t* used, heapstat_t* free) {
HEAP_VALIDATE;
used->size = 0;
used->count = 0;
free->size = 0;
free->count = 0;
size_t offset = 0;
while (offset < heap_size) {
header_t* h = offset_header(heap, offset);
if (is_type(h, HT_FREE)) {
free->size += h->e.size;
free->count++;
} else if (is_type(h, HT_USED) || is_type(h, HT_PROTECTED)) {
used->size += h->e.size;
used->count++;
} else {
consout("Heap corrupted (magic)\n");
HEAP_EXIT;
}
offset += h->e.size;
}
}
void heap_validate(const char* file, const int lineno) {
// consout("%04x !\n", context->programCounter);
size_t used_m = 0;
size_t free_m = 0;
size_t free_l = 0;
// Traverse through heap memory:
size_t offset = 0;
while (offset < heap_size) {
header_t* h = offset_header(heap, offset);
if (is_type(h, HT_FREE)) {
free_m += h->e.size;
} else if (is_type(h, HT_USED) || is_type(h, HT_PROTECTED)) {
used_m += h->e.size;
} else {
consout("Heap corrupted (magic)\n");
heap_dump();
heap_exit(file, lineno);
}
// Advance pointer using size of element:
offset += h->e.size;
}
if (used_m + free_m != heap_size) {
consout("Heap corrupted (size)\n");
heap_exit(file, lineno);
}
// Validate free list:
if (free_list != NULL) {
header_t* h = free_list;
header_t* prev = NULL;
free_l = 0;
while (h != NULL) {
if (is_type(h, HT_FREE)) {
free_l += h->e.size;
} else {
consout("Heap corrupted (free magic)\n");
heap_exit(file, lineno);
}
if (prev != NULL && h < prev) {
consout("Heap corrupted (free list order)\n");
heap_exit(file, lineno);
}
prev = h;
h = h->e.next;
}
}
if (free_l != free_m) {
consout("Heap corrupted (free size)\n");
heap_exit(file, lineno);
}
}
void print_object(pointer P, symbol_table* table)
{
FILE* out = stdout;
if(P == NIL)
{
fputs("NIL", out);
return;
}
switch(get_type_id(P))
{
case DT_Pair:
if(is_type(pair_car(P), DT_Pair))
{
putc('(', out);
print_object(pair_car(P), table);
putc(')', out);
}
else
print_object(pair_car(P), table);
putc(' ', out);
if(pair_cdr(P) != NIL)
{
if(!is_type(pair_cdr(P), DT_Pair))
fputs(". ", out);
print_object(pair_cdr(P), table);
}
break;
case DT_Symbol:
fputs(string_from_symbol(table, *get_symbol(P)), out);
break;
case DT_Int:
fprintf(out, "%d", get_int(P));
break;
case DT_Real:
fprintf(out, "%f", get_real(P));
break;
case DT_String:
fputs(get_string(P), out);
break;
case DT_Char:
putc(get_char(P), out);
break;
case DT_TypeInfo:
print_typeinfo(P, table, out);
break;
case DT_Invalid:
fputs("#INVALID#", out);
break;
case DT_Any:
fputs("#ANY#", out);
break;
}
}
void heap_sweep(unsigned int markValue) {
HEAP_VALIDATE;
// TODO Clear free list and rebuild during this sweep ?
header_t* h = heap;
size_t offset = 0;
// previous is != NULL, if the previous was free entry:
header_t* previous = NULL;
while (offset < heap_size) {
h = offset_header(heap, offset);
if (is_type(h, HT_FREE)) {
previous = h;
offset += h->e.size;
} else if (is_type(h, HT_USED)) {
if (h->e.mark != markValue) {
// consoutli("FREE: %p, mark = %d\n", h, h->e.mark);
//--------------------------
// Garbage collect this one:
//--------------------------
size_t previousSize = 0;
if (previous != NULL) {
// h shall be merged with previous, remember the size of previous:
previousSize = previous->e.size;
}
// This call might merge with previous and next element on heap:
heap_free(h);
if (previous != NULL) {
// h might have been merged with previous; don't count previous size twice
// (previous->e.size might have been increased with the size of h during the merge):
offset += previous->e.size - previousSize;
// don't change previous
} else {
offset += h->e.size;
previous = h;
}
} else {
offset += h->e.size;
previous = NULL;
}
} else if (is_type(h, HT_PROTECTED)) {
previous = NULL;
offset += h->e.size;
} else {
consout("Heap corrupted (magic)\n");
HEAP_EXIT;
}
}
HEAP_VALIDATE;
}
void pre_erase_term(Term* term)
{
// If this term declares a Type, then clear the Type.declaringTerm pointer,
// before it becomes invalid.
if (is_type(term) && as_type(term_value(term))->declaringTerm == term)
as_type(term_value(term))->declaringTerm = NULL;
}
int get_type(const char *format, int i, t_a *arg)
{
arg->type = format[i];
if (is_type(format[i]))
return (i + 1);
return (i);
}
void print(Value x)
{
if (is_nil(x))
prints("nil");
else if (is_eof(x))
printf("#eof");
else if (is_fixnum(x))
printf("%d", as_fixnum(x));
else if (is_bool(x))
printf("%s", as_bool(x) ? "true" : "false");
else if (is_char(x))
printf("'%c'", as_char(x));
else if (is_pair(x))
print_list(x);
else if (is_symbol(x))
prints(as_symbol(x)->value);
else if (is_string(x))
print_string(as_string(x));
else if (is_procedure(x))
printf("#<procedure %s>", as_procedure(x)->name->value);
else if (is_module(x))
printf("#<module>");
else if (is_type(x))
printf("#<type %s>", as_type(x)->name->value);
else if (is_ptr(x))
printf("#<object %p>", as_ptr(x));
else if (is_undefined(x))
printf("#undefined");
else
printf("#ufo");
}
PExprAST
Parser::parse_function()
{
get_next_token(); // eat the Define token
if (!is_type(current_tok))
throw ParserException(ParserExceptionType::ExpectedType);
PPrototypeAST prototype = parse_prototype();
if (current_tok != Token::StartContent)
throw ParserException(ParserExceptionType::ExpectedStartContent);
get_next_token(); // eat '['
InstList imp;
while (current_tok != Token::EndContent)
{
PExprAST inst = parse_expr();
if (current_tok != Token::EndInstr)
throw ParserException(ParserExceptionType::ExpectedEndOfInstr);
get_next_token(); // eat ':'
imp.push_back(inst);
}
get_next_token(); // eat ']'
return PExprAST(new FunctionAST(prototype, imp));
}
Type* Type_cast_specializeType(Term* caller)
{
if (is_value(caller->input(0)) && is_type(caller->input(0)))
return as_type(term_value(caller->input(0)));
return NULL;
}
void detail::core_terminal_t::reset()
{
if (is_type(OUTPUT))
set_state(STATE_OUT);
else
set_state(STATE_INP_ACTIVE);
}
PPrototypeAST
Parser::parse_prototype()
{
Type return_type = get_type(current_tok);
get_next_token(); // eat type token
std::string name;
//We should read identifier or entry point token
if (current_tok == Token::Identifier)
{
name = lex.get_last_token_value<std::string>();
get_next_token(); // eat identifier
}
else if (current_tok == Token::EntryPoint)
{
name = "Coq";
get_next_token(); // eat identifier
}
else
throw ParserException(ParserExceptionType::ExpectedIdentifier);
if (current_tok != Token::StartArg)
throw ParserException(ParserExceptionType::ExpectedStartArg);
get_next_token(); // eat '<'
//Read types of arguments
ArgList args;
if (current_tok != Token::EndArg)
while (true)
{
if (!is_type(current_tok))
throw ParserException(ParserExceptionType::ExpectedType);
Type arg_type = get_type(current_tok);
get_next_token(); // eat type
// Users are allowed to do not specify a name
std::string arg_name;
if (current_tok == Token::Identifier)
{
name = lex.get_last_token_value<std::string>();
get_next_token();
}
args.push_back(ArgPair(arg_type, arg_name));
if (current_tok == Token::EndArg)
break;
if (current_tok != Token::ArgSep)
throw ParserException(ParserExceptionType::ExpectedEndOfArg);
get_next_token(); //eat separator ','
}
get_next_token(); // eat '>'
return PPrototypeAST(new PrototypeAST(return_type, name, args));
}
int heap_used() {
HEAP_VALIDATE;
int size = 0;
size_t offset = 0;
while (offset < heap_size) {
header_t* h = offset_header(heap, offset);
if (is_type(h, HT_USED) || is_type(h, HT_PROTECTED)) {
size += h->e.size;
}
offset += h->e.size;
}
return size * sizeof (align_t);
}
void append_in_place(pointer P, pointer V)
{
assert(is_type(P, DT_Pair));
if(cdr(P) == NIL)
set_cdr(P, V);
else
append_in_place(cdr(P), V);
}
int main (int argc, char* argv[]) {
int a = add_symbol("a", type_int);
printf("1 = %d\n", a);
printf("1 = %d\n", add_symbol("b", type_double));
printf("1 = %d\n", add_symbol("c", type_char));
printf("0 = %d\n", add_symbol("a", type_char)); // ERRO: já declarada
printf("0 = %d\n", add_symbol("b", type_double)); // ERRO: Já declarada
printf("1 = %d\n", is_type("a", type_int));
printf("1 = %d\n", is_type("b", type_int));
}
static int json_getattr(const char *path, struct stat *stbuf)
{
int res = 0, i;
cJSON *element = NULL;
memset(stbuf, 0, sizeof(struct stat));
if(!strcmp(path, "/")) {
stbuf->st_mode = S_IFDIR | 0755;
stbuf->st_nlink = 2;
return res;
}
for (i = 0; i < size; i++) {
if (!element_exist(array[i], "name") || !is_type(array[i], "name", cJSON_String))
continue;
if (!strcmp(path+1, cJSON_GetObjectItem(array[i], "name")->valuestring)) {
element = array[i];
if (element_exist(array[i], "mode") && is_type(array[i], "mode", cJSON_Number))
stbuf->st_mode = S_IFREG | cJSON_GetObjectItem(array[i], "mode")->valueint;
else
stbuf->st_mode = S_IFREG | 0444;
if (element_exist(array[i], "nlink") && is_type(array[i], "nlink", cJSON_Number))
stbuf->st_nlink = cJSON_GetObjectItem(array[i], "nlink")->valueint;
else
stbuf->st_nlink = 1;
if (element_exist(array[i], "content") && is_type(array[i], "content", cJSON_String))
stbuf->st_size = strlen(cJSON_GetObjectItem(array[i], "content")->valuestring);
else
stbuf->st_size = 0;
break;
}
}
if (!element)
res = -ENOENT;
return res;
}
void heap_free(header_t* h) {
HEAP_VALIDATE;
if (h == NULL) {
consout("Element is NULL\n");
HEAP_EXIT;
}
if (!is_type(h, HT_USED) && !is_type(h, HT_PROTECTED)) {
consout("Magic\n");
HEAP_EXIT;
}
set_type(h, HT_FREE);
list_insert_ordered(&free_list, h);
HEAP_VALIDATE;
}
void Lex_analyzer::addToken(int tokenType, QString tokenValue){
TokenType *t = new TokenType;
Token *tok = new Token;
switch(tokenType){
case 1:
if(is_keyword(tokenValue,t)){
qDebug() <<"Token" <<tokenValue <<"found in keywords: id=" <<t->id <<"type=" <<t->type <<endl;
tok->id=t->id;
tok->tokclass = "keywords";
tok->toktype = t->type;
tok->value = tokenValue;
tokens->append(tok);
}else if(is_type(tokenValue,t)){
qDebug() <<"Token" <<tokenValue <<"found in types: id=" <<t->id <<"type=" <<t->type <<endl;
tok->id=t->id;
tok->tokclass = "types";
tok->toktype = t->type;
tok->value = tokenValue;
tokens->append(tok);
}else{
is_id(tokenValue, t);
qDebug() <<"Token" <<tokenValue <<"found in/inserted to ids: id=" <<t->id <<"type=" <<t->type <<endl;
tok->id=t->id;
tok->tokclass = "ids";
tok->toktype = t->type;
tok->value = tokenValue;
tokens->append(tok);
}
break;
case 2:
is_const(tokenValue, t);
qDebug() <<"Token" <<tokenValue <<"found in/inserted to constants: id=" <<t->id <<"type=" <<t->type <<endl;
tok->id=t->id;
tok->tokclass = "constants";
tok->toktype = t->type;
tok->value = tokenValue;
tokens->append(tok);
break;
case 3:
case 4:
if(is_operator(tokenValue, t)){
qDebug() <<"Token" <<tokenValue <<"found in operators/separators: id=" <<t->id <<"type=" <<t->type <<endl;
tok->id=t->id;
tok->tokclass = "separators";
tok->toktype = t->type;
tok->value = tokenValue;
tokens->append(tok);
}else{
qDebug() <<"Error unknown token type: " <<tokenType <<endl;
}
break;
default:
qDebug() <<"Error unknown token type: " <<tokenType <<endl;
}
qDebug() <<"Adding token of type[" <<tokenType <<"] = " <<tokenValue <<endl;
}
void ObjectTypeDB::get_extensions_for_type(const StringName& p_type,List<String> *p_extensions) {
const StringName *K=NULL;
while((K=resource_base_extensions.next(K))) {
StringName cmp = resource_base_extensions[*K];
if (is_type(cmp,p_type))
p_extensions->push_back(*K);
}
}
void qz_get_args(qz_state_t* st, qz_obj_t* args, const char* spec, ...)
{
va_list ap;
va_start(ap, spec);
size_t nargs = 0;
for(const char* s = spec; *s; /**/)
{
qz_obj_t* obj = va_arg(ap, qz_obj_t*);
int type_char = *s++;
int eval = (*s == '~') ? (s++, 0) : 1;
int optional = (*s == '?') ? (s++, 1) : 0;
if(qz_is_pair(*args)) {
/* pull argument from list and advance */
*obj = qz_first(*args);
*args = qz_rest(*args);
if(eval) {
/* evaluate argument */
*obj = qz_eval(st, *obj);
}
else {
/* don't evaluate argument */
*obj = qz_ref(st, *obj);
}
qz_push_safety(st, *obj);
nargs++;
/* check argument type */
if(!is_type(*obj, type_char)) {
char msg[64];
sprintf(msg, "expected %s at argument %ld", type_name(type_char), nargs);
qz_error(st, msg, obj, NULL);
}
}
else if(qz_is_null(*args)) {
/* allow optional arguments */
if(optional) {
*obj = QZ_NONE;
continue; /* missing optional argument */
}
char msg[64];
sprintf(msg, "missing %s at argument %ld", type_name(type_char), nargs);
qz_error(st, msg, NULL);
}
else {
qz_error(st, "improper argument list", args, NULL);
}
}
qz_pop_safety(st, nargs);
va_end(ap);
}
Type* specializeType(Term* caller)
{
Term* input = caller->input(0);
if (input == NULL)
return &ANY_T;
if (is_value(input) && is_type(input))
return as_type(input);
return &ANY_T;
}
void destroy_list(pointer P)
{
if(is_type(P, DT_Pair))
{
if(pair_car(P) != NIL)
destroy_list(pair_car(P));
if(pair_cdr(P) != NIL)
destroy_list(pair_cdr(P));
}
ploy_free(P);
}
static void check_tore(type_or_ent tore, void *env)
{
bool *fine = (bool*)env;
if (is_type(tore.typ)) {
*fine &= check_type(tore.typ);
} else {
assert(is_entity(tore.ent));
*fine &= check_entity(tore.ent);
}
}
Type* type_make_specializeType(Term* caller)
{
Term* input = caller->input(0);
if (input == NULL)
return TYPES.any;
if (is_value(input) && is_type(input))
return as_type(input);
return TYPES.any;
}
int count_for_obj(char **str, int i, t_pars *pars)
{
int j;
j = 0;
while (str && str[i] && is_type(str[i], pars) == -1)
{
i++;
j++;
}
return (j);
}
bool is_considered_config(Term* term)
{
if (term == NULL) return false;
if (has_empty_name(term)) return false;
if (!is_value(term)) return false;
if (is_declared_state(term)) return false;
if (is_hidden(term)) return false;
if (is_function(term)) return false;
if (is_type(term)) return false;
return true;
}
bool fits_lookup_type(Term* term, Symbol type)
{
switch (type) {
case s_LookupAny:
return true;
case s_LookupType:
return is_type(term);
case s_LookupFunction:
return is_function(term);
}
internal_error("unknown type in fits_lookup_type");
return false;
}
static int json_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
size_t len;
char *str;
(void) fi;
int i;
cJSON *element;
for (i = 0; i < size; i++) {
if (!element_exist(array[i], "name") || !is_type(array[i], "name", cJSON_String))
continue;
if (!strcmp(path+1, cJSON_GetObjectItem(array[i], "name")->valuestring)) {
element = array[i];
str = (element_exist(array[i], "content") && is_type(array[i], "content", cJSON_String)) ? cJSON_GetObjectItem(array[i], "content")->valuestring : "";
len = strlen(str);
if (offset < len) {
if (offset + size > len)
size = len - offset;
memcpy(buf, str + offset, size);
} else
size = 0;
return size;
}
}
if (!element)
return -ENOENT;
return size;
}
void ObjectTypeDB::get_inheriters_from( const StringName& p_type,List<StringName> *p_types) {
OBJTYPE_LOCK;
const StringName *k=NULL;
while((k=types.next(k))) {
if (*k!=p_type && is_type(*k,p_type))
p_types->push_back(*k);
}
}
std::string generate_cpp_headers(Branch* branch)
{
std::stringstream out;
for (int i=0; i < branch->length(); i++) {
if (branch->get(i) == NULL) continue;
Term* term = branch->get(i);
if (is_type(term))
out << cpp_accessor_for_type(as_type(term_value(term)));
}
return out.str();
}
Name list_get_parameter_type(caValue* parameter)
{
if (is_null(parameter))
return name_Untyped;
if (is_type(parameter))
return name_UniformListType;
if (is_list(parameter)) {
if ((list_length(parameter) == 2) && is_list(list_get(parameter, 0)))
return name_StructType;
else
return name_AnonStructType;
}
return name_Invalid;
}