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:{}; } } }