void java_bytecode_parsert::rRuntimeAnnotation(
annotationt &annotation)
{
u2 type_index=read_u2();
annotation.type=type_entry(type_index);
relement_value_pairs(annotation.element_value_pairs);
}
local var return_true(var self)
{
return type_class_method(self, ReturnTrue, return_true, self);
}
local var IntParent_ReturnTrue(var self)
{
return True;
}
instance(IntParent, ReturnTrue) = {
IntParent_ReturnTrue};
var IntParent = type_data {
type_begin(IntParent),
type_entry(IntParent, ReturnTrue),
type_end(IntParent),
};
PT_FUNC(test_type)
{
PT_ASSERT(type_of($(Int, 1)) is Int);
PT_ASSERT(type_of($(Real, 1.0)) is Real);
PT_ASSERT(type_of(True) is Bool);
PT_ASSERT(type_of(False) is Bool);
PT_ASSERT(type_of(Int) is Type);
PT_ASSERT(type_of(Real) is Type);
PT_ASSERT(type_of(Type) is Type);
}
PT_FUNC(test_cast)
#include "Cello/File.h"
#include "Cello/Exception.h"
#include "Cello/Number.h"
#include "Cello/String.h"
var File = type_data {
type_begin(File),
type_entry(File, New),
type_entry(File, With),
type_entry(File, Stream),
type_entry(File, Dict),
type_entry(File, Format),
type_end(File),
};
var File_New(var self, var_list vl) {
FileData* fd = cast(self, File);
const char* filename = as_str(var_list_get(vl));
const char* access = as_str(var_list_get(vl));
stream_open(self, filename, access);
return self;
}
var File_Delete(var self) {
FileData* fd = cast(self, File);
if (fd->f != NULL) { stream_close(self); }
return self;
}
size_t File_Size(void) {
if (!o2fsck_test_inode_allocated(ost, dirent->inode) &&
prompt(ost, PY, PR_DIRENT_INODE_FREE,
"Directory entry '%.*s' refers to inode number "
"%"PRIu64" which isn't allocated, clear the entry?",
dirent->name_len, dirent->name, (uint64_t)dirent->inode)) {
dirent->inode = 0;
*flags |= OCFS2_DIRENT_CHANGED;
}
out:
return;
}
#define type_entry(type) [type] = #type
static char *file_types[] = {
type_entry(OCFS2_FT_UNKNOWN),
type_entry(OCFS2_FT_REG_FILE),
type_entry(OCFS2_FT_DIR),
type_entry(OCFS2_FT_CHRDEV),
type_entry(OCFS2_FT_BLKDEV),
type_entry(OCFS2_FT_FIFO),
type_entry(OCFS2_FT_SOCK),
type_entry(OCFS2_FT_SYMLINK),
};
#undef type_entry
static char *file_type_string(uint8_t type)
{
if (type >= OCFS2_FT_MAX)
return "(unknown)";
struct MapNode {
var leaf_key;
var leaf_val;
struct MapNode* left;
struct MapNode* right;
};
data {
var type;
var keys;
struct MapNode* root;
} MapData;
var Map = type_data {
type_begin(Map),
type_entry(Map, New),
type_entry(Map, Assign),
type_entry(Map, Copy),
type_entry(Map, Eq),
type_entry(Map, Collection),
type_entry(Map, Dict),
type_entry(Map, Iter),
type_entry(Map, Show),
type_end(Map),
};
var Map_New(var self, var_list vl) {
MapData* md = cast(self, Map);
md->keys = new(List);
md->root = NULL;
return self;
#include "Vec2.h"
#include <math.h>
float dot(var self, var obj) {
return type_class_method(type_of(self), Vector, dot, self, obj);
}
float length(var self) {
return type_class_method(type_of(self), Vector, length, self);
}
var Vec2 = type_data {
type_begin(Vec2),
type_entry(Vec2, New),
type_entry(Vec2, Assign),
type_entry(Vec2, Copy),
type_entry(Vec2, Eq),
type_entry(Vec2, Show),
type_entry(Vec2, Vector),
type_end(Vec2)
};
var Vec2_New(var self, var_list vl) {
Vec2Data* v = cast(self, Vec2);
v->x = as_double(var_list_get(vl));
v->y = as_double(var_list_get(vl));
return self;
}
var Vec2_Delete(var self) {
#include "Cello/Exception.h"
#include <stdlib.h>
#include <string.h>
data {
var type;
int size;
var keys;
var* key_buckets;
var* val_buckets;
} DictionaryData;
var Dictionary = type_data {
type_begin(Dictionary),
type_entry(Dictionary, New),
type_entry(Dictionary, Assign),
type_entry(Dictionary, Copy),
type_entry(Dictionary, Eq),
type_entry(Dictionary, Collection),
type_entry(Dictionary, Dict),
type_entry(Dictionary, Iter),
type_entry(Dictionary, Show),
type_end(Dictionary)
};
var Dictionary_New(var self, var_list vl) {
DictionaryData* dict = cast(self, Dictionary);
dict->size = 1024;
dict->keys = new(List);
#include <stdlib.h>
#include <string.h>
data {
var type;
var key_type;
var val_type;
int size;
var keys;
var* key_buckets;
var* val_buckets;
} TableData;
var Table = type_data {
type_begin(Table),
type_entry(Table, New),
type_entry(Table, Assign),
type_entry(Table, Copy),
type_entry(Table, Eq),
type_entry(Table, Collection),
type_entry(Table, Dict),
type_entry(Table, Iter),
type_entry(Table, Show),
type_end(Table)
};
var Table_New(var self, var_list vl) {
TableData* tab = cast(self, Table);
tab->key_type = cast(var_list_get(vl), Type);
tab->val_type = cast(var_list_get(vl), Type);
#include "Cello/Reference.h"
#include "Cello/Bool.h"
#include "Cello/Type.h"
#include "Cello/Exception.h"
#include <string.h>
var Reference = type_data {
type_begin(Reference),
type_entry(Reference, New),
type_entry(Reference, Assign),
type_entry(Reference, Copy),
type_entry(Reference, Eq),
type_entry(Reference, Hash),
type_entry(Reference, At),
type_entry(Reference, With),
type_entry(Reference, Show),
type_end(Reference)
};
var Reference_New(var self, var_list vl)
{
ReferenceData *rd = cast(self, Reference);
rd->ref = var_list_get(vl);
return rd;
}
var Reference_Delete(var self)
{
return self;
void java_bytecode_parsert::rconstant_pool()
{
u2 constant_pool_count=read_u2();
if(constant_pool_count==0)
{
error() << "invalid constant_pool_count" << eom;
throw 0;
}
constant_pool.resize(constant_pool_count);
for(constant_poolt::iterator
it=constant_pool.begin();
it!=constant_pool.end();
it++)
{
// the first entry isn't used
if(it==constant_pool.begin())
continue;
it->tag=read_u1();
switch(it->tag)
{
case CONSTANT_Class:
it->ref1=read_u2();
break;
case CONSTANT_Fieldref:
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
case CONSTANT_NameAndType:
case CONSTANT_InvokeDynamic:
it->ref1=read_u2();
it->ref2=read_u2();
break;
case CONSTANT_String:
case CONSTANT_MethodType:
it->ref1=read_u2();
break;
case CONSTANT_Integer:
case CONSTANT_Float:
it->number=read_u4();
break;
case CONSTANT_Long:
case CONSTANT_Double:
it->number=read_u8();
// Eight-byte constants take up two entires
// in the constant_pool table, for annoying this programmer.
if(it==constant_pool.end())
{
error() << "invalid double entry" << eom;
throw 0;
}
it++;
it->tag=0;
break;
case CONSTANT_Utf8:
{
u2 bytes=read_u2();
std::string s;
s.resize(bytes);
for(std::string::iterator s_it=s.begin(); s_it!=s.end(); s_it++)
*s_it=read_u1();
it->s=s; // hashes
}
break;
case CONSTANT_MethodHandle:
it->ref1=read_u1();
it->ref2=read_u2();
break;
default:
error() << "unknown constant pool entry (" << it->tag << ")"
<< eom;
throw 0;
}
}
// we do a bit of post-processing after we have them all
for(constant_poolt::iterator
it=constant_pool.begin();
it!=constant_pool.end();
it++)
{
// the first entry isn't used
if(it==constant_pool.begin())
continue;
switch(it->tag)
{
case CONSTANT_Class:
{
const std::string &s=id2string(pool_entry(it->ref1).s);
it->expr=type_exprt(java_classname(s));
}
break;
case CONSTANT_Fieldref:
{
const pool_entryt &nameandtype_entry=pool_entry(it->ref2);
const pool_entryt &name_entry=pool_entry(nameandtype_entry.ref1);
const pool_entryt &class_entry=pool_entry(it->ref1);
const pool_entryt &class_name_entry=pool_entry(class_entry.ref1);
typet type=type_entry(nameandtype_entry.ref2);
symbol_typet class_symbol=
java_classname(id2string(class_name_entry.s));
exprt fieldref("fieldref", type);
fieldref.set(ID_class, class_symbol.get_identifier());
fieldref.set(ID_component_name, name_entry.s);
it->expr=fieldref;
}
break;
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
{
const pool_entryt &nameandtype_entry=pool_entry(it->ref2);
const pool_entryt &name_entry=pool_entry(nameandtype_entry.ref1);
const pool_entryt &class_entry=pool_entry(it->ref1);
const pool_entryt &class_name_entry=pool_entry(class_entry.ref1);
typet type=type_entry(nameandtype_entry.ref2);
symbol_typet class_symbol=
java_classname(id2string(class_name_entry.s));
irep_idt component_name=
id2string(name_entry.s)+
":"+id2string(pool_entry(nameandtype_entry.ref2).s);
irep_idt class_name=
class_symbol.get_identifier();
irep_idt identifier=
id2string(class_name)+"."+id2string(component_name);
exprt virtual_function(ID_virtual_function, type);
virtual_function.set(ID_component_name, component_name);
virtual_function.set(ID_C_class, class_name);
virtual_function.set(ID_C_base_name, name_entry.s);
virtual_function.set(ID_identifier, identifier);
it->expr=virtual_function;
}
break;
case CONSTANT_String:
{
// ldc turns these into references to java.lang.String
exprt string_literal(ID_java_string_literal);
string_literal.set(ID_value, pool_entry(it->ref1).s);
it->expr=string_literal;
}
break;
case CONSTANT_Integer:
it->expr=from_integer(it->number, java_int_type());
break;
case CONSTANT_Float:
{
ieee_floatt value(ieee_float_spect::single_precision());
value.unpack(it->number);
it->expr=value.to_expr();
}
break;
case CONSTANT_Long:
it->expr=from_integer(it->number, java_long_type());
break;
case CONSTANT_Double:
{
ieee_floatt value(ieee_float_spect::double_precision());
value.unpack(it->number);
it->expr=value.to_expr();
}
break;
case CONSTANT_NameAndType:
{
it->expr.id("nameandtype");
}
break;
case CONSTANT_MethodHandle:
{
it->expr.id("methodhandle");
}
break;
case CONSTANT_MethodType:
{
it->expr.id("methodtype");
}
break;
case CONSTANT_InvokeDynamic:
{
it->expr.id("invokedynamic");
const pool_entryt &nameandtype_entry=pool_entry(it->ref2);
typet type=type_entry(nameandtype_entry.ref2);
it->expr.type()=type;
}
break;
default:{};
}
}
}
