static void set_method_types(reach_t* r, reach_method_t* m,
pass_opt_t* opt)
{
AST_GET_CHILDREN(m->r_fun, cap, id, typeparams, params, result, can_error,
body);
m->param_count = ast_childcount(params);
m->params = (reach_param_t*)ponyint_pool_alloc_size(
m->param_count * sizeof(reach_param_t));
ast_t* param = ast_child(params);
size_t i = 0;
while(param != NULL)
{
AST_GET_CHILDREN(param, p_id, p_type);
m->params[i].type = add_type(r, p_type, opt);
if(ast_id(p_type) != TK_NOMINAL && ast_id(p_type) != TK_TYPEPARAMREF)
m->params[i].cap = TK_REF;
else
m->params[i].cap = ast_id(cap_fetch(p_type));
++i;
param = ast_sibling(param);
}
m->result = add_type(r, result, opt);
}
static void handle_stack(reachable_method_stack_t* s, reachable_types_t* r,
uint32_t* next_type_id)
{
while(s != NULL)
{
reachable_method_t* m;
s = reachable_method_stack_pop(s, &m);
AST_GET_CHILDREN(m->r_fun, cap, id, typeparams, params, result, can_error,
body);
m->param_count = ast_childcount(params);
m->params = (reachable_type_t**)ponyint_pool_alloc_size(
m->param_count * sizeof(reachable_type_t*));
ast_t* param = ast_child(params);
size_t i = 0;
while(param != NULL)
{
AST_GET_CHILDREN(param, p_id, p_type);
m->params[i++] = add_type(&s, r, next_type_id, p_type);
param = ast_sibling(param);
}
m->result = add_type(&s, r, next_type_id, result);
reachable_expr(&s, r, next_type_id, body);
}
}
void collect_class(Stats& stats, const Index& index, const php::Class& cls) {
++stats.totalClasses;
if (cls.attrs & AttrPersistent) {
++stats.persistentClasses;
}
if (cls.attrs & AttrUnique) {
++stats.uniqueClasses;
}
stats.totalMethods += cls.methods.size();
for (auto& kv : index.lookup_private_props(&cls)) {
add_type(stats.privateProps, kv.second);
}
for (auto& kv : index.lookup_private_statics(&cls)) {
add_type(stats.privateStatics, kv.second);
}
for (auto& prop : cls.properties) {
if (prop.attrs & AttrStatic) {
++stats.totalSProps;
if (prop.attrs & AttrPersistent) {
if (prop.attrs & AttrPublic) ++stats.persistentSPropsPub;
if (prop.attrs & AttrProtected) ++stats.persistentSPropsProt;
if (prop.attrs & AttrPrivate) ++stats.persistentSPropsPriv;
}
}
}
}
static void reachable_ffi(reachable_method_stack_t** s, reachable_types_t* r,
uint32_t* next_type_id, ast_t* ast)
{
AST_GET_CHILDREN(ast, name, return_typeargs, args, namedargs, question);
ast_t* decl = (ast_t*)ast_data(ast);
if(decl != NULL)
{
AST_GET_CHILDREN(decl, decl_name, decl_ret_typeargs, params, named_params,
decl_error);
args = params;
return_typeargs = decl_ret_typeargs;
}
ast_t* return_type = ast_child(return_typeargs);
add_type(s, r, next_type_id, return_type);
ast_t* arg = ast_child(args);
while(arg != NULL)
{
if(ast_id(arg) != TK_ELLIPSIS)
{
ast_t* type = ast_type(arg);
if(type == NULL)
type = ast_childidx(arg, 1);
add_type(s, r, next_type_id, type);
}
arg = ast_sibling(arg);
}
}
static void reachable_ffi(reach_t* r, ast_t* ast, pass_opt_t* opt)
{
AST_GET_CHILDREN(ast, name, return_typeargs, args, namedargs, question);
ast_t* decl = (ast_t*)ast_data(ast);
if(decl != NULL)
{
AST_GET_CHILDREN(decl, decl_name, decl_ret_typeargs, params, named_params,
decl_error);
args = params;
return_typeargs = decl_ret_typeargs;
}
ast_t* return_type = ast_child(return_typeargs);
add_type(r, return_type, opt);
ast_t* arg = ast_child(args);
while(arg != NULL)
{
if(ast_id(arg) != TK_ELLIPSIS)
{
ast_t* type = ast_type(arg);
if(type == NULL)
type = ast_childidx(arg, 1);
add_type(r, type, opt);
}
arg = ast_sibling(arg);
}
}
static void setup_types()
{
add_type("i8", 1);
add_type("u8", 1);
add_type("i32", 4);
add_type("u32", 4);
add_type("i64", 8);
}
static void
handle_type (MonoClass *klass, guint32 flags)
{
int i;
guint32 missing;
MonoCustomAttrInfo* cattrs;
gpointer val = NULL, oldkey = NULL;
MonoProperty* prop;
MonoEvent* event;
MonoMethod* method;
MonoClassField* field;
gpointer iter;
if (g_hash_table_lookup_extended (type_table, klass, &oldkey, &val)) {
missing = flags & ~(GPOINTER_TO_UINT (val));
} else {
missing = flags;
}
if (!missing)
return;
g_hash_table_insert (type_table, klass, GUINT_TO_POINTER (missing));
if (verbose)
g_print ("#processing klass: %s.%s\n", klass->name_space, klass->name);
mono_class_init (klass);
if (klass->parent)
add_type (klass->parent);
if (klass->nested_in)
add_type (klass->nested_in);
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
if ((missing & TYPE_METHODS) || strcmp (method->name, ".cctor") == 0)
add_types_from_method (method);
}
if (klass->enumtype) {
add_field (mono_class_get_field_from_name (klass, "value__"));
}
if (force_enums || (missing & TYPE_FIELDS)) {
iter = NULL;
while ((field = mono_class_get_fields (klass, &iter)))
add_field (field);
}
iter = NULL;
while ((prop = mono_class_get_properties (klass, &iter))) {
cattrs = mono_custom_attrs_from_property (klass, prop);
handle_cattrs (cattrs);
}
iter = NULL;
while ((event = mono_class_get_events (klass, &iter))) {
cattrs = mono_custom_attrs_from_event (klass, event);
handle_cattrs (cattrs);
}
for (i = 0; i < klass->interface_count; ++i)
add_type (klass->interfaces [i]);
cattrs = mono_custom_attrs_from_class (klass);
handle_cattrs (cattrs);
}
static void
add_types_from_signature (MonoMethodSignature *sig)
{
MonoClass *klass;
int i;
for (i = 0; i < sig->param_count; ++i) {
klass = mono_class_from_mono_type (sig->params [i]);
add_type (klass);
}
klass = mono_class_from_mono_type (sig->ret);
add_type (klass);
}
usermessage::usermessage(QString msg_arg, int t_arg, QString receiver_arg):
my_msg(msg_arg), my_type(t_arg), my_user(singleton<netcoupler>().nick), my_receiver(receiver_arg){
Q_ASSERT_X(my_type & e_NOTICE || my_type & e_PRIVMSG || my_type & e_CTCP || my_type & e_RAWCOMMAND || my_type & e_GARBAGE || my_type & e_SCRIPTCOMMAND, Q_FUNC_INFO, qPrintable(QString::number(my_type)));
if(my_msg.startsWith("\001ACTION",Qt::CaseInsensitive)){
add_type(e_ACTION);
my_msg.remove("\001ACTION",Qt::CaseInsensitive).remove('\001');
} else if(my_msg.startsWith('\001')){
add_type(e_CTCP);
my_msg.remove('\001');
}
my_msg=my_msg.simplified();
}
static void
add_field (MonoClassField *field) {
MonoClass *k;
MonoCustomAttrInfo* cattrs;
gpointer val = NULL, oldkey = NULL;
if (g_hash_table_lookup_extended (field_table, field, &oldkey, &val))
return;
g_hash_table_insert (field_table, field, NULL);
add_type (field->parent);
k = mono_class_from_mono_type (field->type);
add_type (k);
cattrs = mono_custom_attrs_from_field (field->parent, field);
handle_cattrs (cattrs);
}
static reachable_type_t* add_tuple(reachable_method_stack_t** s,
reachable_types_t* r, uint32_t* next_type_id, ast_t* type)
{
if(contains_dontcare(type))
return NULL;
reachable_type_t* t = reach_type(r, type);
if(t != NULL)
return t;
t = add_reachable_type(r, type);
t->type_id = ++(*next_type_id);
t->field_count = (uint32_t)ast_childcount(t->ast);
t->fields = (reachable_field_t*)calloc(t->field_count,
sizeof(reachable_field_t));
size_t index = 0;
ast_t* child = ast_child(type);
while(child != NULL)
{
t->fields[index].ast = ast_dup(child);
t->fields[index].type = add_type(s, r, next_type_id, child);;
index++;
child = ast_sibling(child);
}
return t;
}
static void add_fields(reachable_method_stack_t** s, reachable_types_t* r,
uint32_t* next_type_id, ast_t* type)
{
ast_t* def = (ast_t*)ast_data(type);
ast_t* members = ast_childidx(def, 4);
ast_t* member = ast_child(members);
while(member != NULL)
{
switch(ast_id(member))
{
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
{
const char* name = ast_name(ast_child(member));
ast_t* r_member = lookup(NULL, NULL, type, name);
assert(r_member != NULL);
AST_GET_CHILDREN(r_member, id, ftype);
add_type(s, r, next_type_id, ftype);
if(r_member != member)
ast_free_unattached(r_member);
break;
}
default: {}
}
member = ast_sibling(member);
}
}
static reachable_type_t* add_tuple(reachable_method_stack_t** s,
reachable_types_t* r, uint32_t* next_type_id, ast_t* type)
{
if(contains_dontcare(type))
return NULL;
const char* type_name = genname_type(type);
reachable_type_t* t = reach_type(r, type_name);
if(t != NULL)
return t;
t = add_reachable_type(r, type, type_name);
t->type_id = ++(*next_type_id);
ast_t* child = ast_child(type);
while(child != NULL)
{
add_type(s, r, next_type_id, child);
child = ast_sibling(child);
}
return t;
}
static void reachable_method(reachable_method_stack_t** s,
reachable_types_t* r, uint32_t* next_type_id, ast_t* type,
const char* name, ast_t* typeargs)
{
switch(ast_id(type))
{
case TK_NOMINAL:
{
reachable_type_t* t = add_type(s, r, next_type_id, type);
add_method(s, t, name, typeargs);
break;
}
case TK_UNIONTYPE:
case TK_ISECTTYPE:
{
ast_t* child = ast_child(type);
while(child != NULL)
{
ast_t* find = lookup_try(NULL, NULL, child, name);
if(find != NULL)
reachable_method(s, r, next_type_id, child, name, typeargs);
child = ast_sibling(child);
}
break;
}
default:
assert(0);
}
}
void npc::load_info(std::string data)
{
std::stringstream dump;
dump << data;
// Standard player stuff
dump >> id >> posx >> posy >> str_cur >> str_max >> dex_cur >> dex_max >>
int_cur >> int_max >> per_cur >> per_max >> hunger >> thirst >>
fatigue >> stim >> pain >> pkill >> radiation >> cash >> recoil >>
scent >> moves >> underwater >> can_dodge >> oxygen;
for (int i = 0; i < PF_MAX2; i++)
dump >> my_traits[i];
for (int i = 0; i < num_hp_parts; i++)
dump >> hp_cur[i] >> hp_max[i];
for (int i = 0; i < num_skill_types; i++)
dump >> sklevel[i] >> skexercise[i];
int numill;
int typetmp;
disease illtmp;
dump >> numill;
for (int i = 0; i < numill; i++) {
dump >> typetmp >> illtmp.duration;
illtmp.type = dis_type(typetmp);
illness.push_back(illtmp);
}
int numadd;
addiction addtmp;
dump >> numadd;
for (int i = 0; i < numadd; i++) {
dump >> typetmp >> addtmp.intensity >> addtmp.sated;
addtmp.type = add_type(typetmp);
addictions.push_back(addtmp);
}
int numbio;
bionic biotmp;
dump >> numbio;
for (int i = 0; i < numbio; i++) {
dump >> typetmp >> biotmp.invlet >> biotmp.powered >> biotmp.charge;
biotmp.id = bionic_id(typetmp);
my_bionics.push_back(biotmp);
}
// Special NPC stuff
int misstmp, flagstmp, agg, bra, col, alt, tru, val, fea;
dump >> agg >> bra >> col >> alt >> wandx >> wandy >> wandf >> omx >> omy >>
omz >> mapx >> mapy >> plx >> ply >> goalx >> goaly >> misstmp >>
tru >> val >> fea >> flagstmp >> fac_id;
personality.aggression = agg;
personality.bravery = bra;
personality.collector = col;
personality.altruism = alt;
op_of_u.trust = tru;
op_of_u.value = val;
op_of_u.fear = fea;
mission = npc_mission(misstmp);
flags = flagstmp;
}
void EditorHelpIndex::_update_class_list() {
class_list->clear();
tree_item_map.clear();
TreeItem *root = class_list->create_item();
class_list->set_hide_root(true);
String filter = search_box->get_text().strip_edges();
String to_select = "";
for(Map<String,DocData::ClassDoc>::Element *E=EditorHelp::get_doc_data()->class_list.front();E;E=E->next()) {
if (filter == "") {
add_type(E->key(),tree_item_map,root);
} else {
bool found = false;
String type = E->key();
while(type != "") {
if (type.findn(filter)!=-1) {
if (to_select.empty()) {
to_select = type;
}
found=true;
break;
}
type = EditorHelp::get_doc_data()->class_list[type].inherits;
}
if (found) {
add_type(E->key(),tree_item_map,root);
}
}
}
if (tree_item_map.has(filter)) {
select_class(filter);
} else if (to_select != "") {
select_class(to_select);
}
}
static reachable_type_t* add_nominal(reachable_method_stack_t** s,
reachable_types_t* r, uint32_t* next_type_id, ast_t* type)
{
const char* type_name = genname_type(type);
reachable_type_t* t = reach_type(r, type_name);
if(t != NULL)
return t;
t = add_reachable_type(r, type, type_name);
AST_GET_CHILDREN(type, pkg, id, typeparams);
ast_t* typeparam = ast_child(typeparams);
while(typeparam != NULL)
{
add_type(s, r, next_type_id, typeparam);
typeparam = ast_sibling(typeparam);
}
ast_t* def = (ast_t*)ast_data(type);
switch(ast_id(def))
{
case TK_INTERFACE:
case TK_TRAIT:
add_types_to_trait(s, r, t);
break;
case TK_PRIMITIVE:
add_traits_to_type(s, r, t);
add_special(s, t, type, "_init");
add_special(s, t, type, "_final");
break;
case TK_STRUCT:
case TK_CLASS:
add_traits_to_type(s, r, t);
add_special(s, t, type, "_final");
add_fields(s, r, next_type_id, type);
break;
case TK_ACTOR:
add_traits_to_type(s, r, t);
add_special(s, t, type, "_event_notify");
add_special(s, t, type, "_final");
add_fields(s, r, next_type_id, type);
break;
default: {}
}
if(t->type_id == 0)
t->type_id = ++(*next_type_id);
return t;
}
void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p_types, TreeItem *p_root, TreeItem **to_select) {
if (p_types.has(p_type))
return;
if (!ClassDB::is_parent_class(p_type, base_type) || p_type == base_type)
return;
String inherits = ClassDB::get_parent_class(p_type);
TreeItem *parent = p_root;
if (inherits.length()) {
if (!p_types.has(inherits)) {
add_type(inherits, p_types, p_root, to_select);
}
if (p_types.has(inherits))
parent = p_types[inherits];
}
TreeItem *item = search_options->create_item(parent);
item->set_text(0, p_type);
if (!ClassDB::can_instance(p_type)) {
item->set_custom_color(0, Color(0.5, 0.5, 0.5));
item->set_selectable(0, false);
} else {
if ((!*to_select && (search_box->get_text().is_subsequence_ofi(p_type))) || search_box->get_text() == p_type) {
*to_select = item;
}
}
if (bool(EditorSettings::get_singleton()->get("docks/scene_tree/start_create_dialog_fully_expanded"))) {
item->set_collapsed(false);
} else {
// don't collapse search results
bool collapse = (search_box->get_text() == "");
// don't collapse the root node
collapse &= (item != p_root);
// don't collapse abstract nodes on the first tree level
collapse &= ((parent != p_root) || (ClassDB::can_instance(p_type)));
item->set_collapsed(collapse);
}
const String &description = EditorHelp::get_doc_data()->class_list[p_type].brief_description;
item->set_tooltip(0, description);
if (has_icon(p_type, "EditorIcons")) {
item->set_icon(0, get_icon(p_type, "EditorIcons"));
}
p_types[p_type] = item;
}
static void add_rmethod_to_subtypes(reach_t* r, reach_type_t* t,
reach_method_name_t* n, reach_method_t* m, pass_opt_t* opt)
{
switch(ast_id(t->ast))
{
case TK_NOMINAL:
{
ast_t* def = (ast_t*)ast_data(t->ast);
switch(ast_id(def))
{
case TK_INTERFACE:
case TK_TRAIT:
{
// Add to subtypes if we're an interface or trait.
size_t i = HASHMAP_BEGIN;
reach_type_t* t2;
while((t2 = reach_type_cache_next(&t->subtypes, &i)) != NULL)
add_rmethod_to_subtype(r, t2, n, m, opt);
break;
}
default: {}
}
return;
}
case TK_UNIONTYPE:
case TK_ISECTTYPE:
{
ast_t* child = ast_child(t->ast);
while(child != NULL)
{
ast_t* find = lookup_try(NULL, NULL, child, n->name);
if(find != NULL)
{
reach_type_t* t2 = add_type(r, child, opt);
add_rmethod_to_subtype(r, t2, n, m, opt);
ast_free_unattached(find);
}
child = ast_sibling(child);
}
return;
}
default: {}
}
assert(0);
}
static reachable_type_t* add_isect_or_union(reachable_method_stack_t** s,
reachable_types_t* r, uint32_t* next_type_id, ast_t* type)
{
ast_t* child = ast_child(type);
while(child != NULL)
{
add_type(s, r, next_type_id, child);
child = ast_sibling(child);
}
return NULL;
}
String Codegen_C::type_to_str( Type *type ) {
std::ostringstream ss;
if ( type->aryth )
ss << *type;
else if ( type->orig == ip->class_Ptr ) {
add_type( ip->type_PI8 );
ss << "TPTR";
} else {
ss << "GT" << type->size();
spec_types[ type->size() ] = ss.str();
}
return ss.str();
}
void
c_initialize(void)
{
/* add all the starting basic types */
add_type(1, "int");
add_type(1, "long");
add_type(1, "short");
add_type(1, "bool");
add_type(1, "u_int");
add_type(1, "u_long");
add_type(1, "u_short");
}
AST_Attribute *UTL_Scope::add_attribute(AST_Attribute *a)
{
if (a == NULL)
return NULL;
a->set_added(I_TRUE);
if (!a->field_type()->added())
{
return add_type(a->field_type()) ? a : NULL;
}
else
return a;
}
AST_Operation *UTL_Scope::add_operation(AST_Operation *o)
{
if (o == NULL)
return NULL;
o->set_added(I_TRUE);
if (!o->return_type()->added())
{
return add_type(o->return_type()) ? o : NULL;
}
else
return o;
}
AST_Argument *UTL_Scope::add_argument(AST_Argument *a)
{
if (a == NULL)
return NULL;
a->set_added(I_TRUE);
if (!a->field_type()->added())
{
return add_type(a->field_type()) ? a : NULL;
}
else
return a;
}
AST_UnionBranch *UTL_Scope::add_union_branch(AST_UnionBranch *u)
{
if (u == NULL)
return NULL;
u->set_added(I_TRUE);
if (!u->field_type()->added())
{
return add_type(u->field_type()) ? u : NULL;
}
else
return u;
}
AST_Field *UTL_Scope::add_field(AST_Field *f)
{
if (f == NULL)
return NULL;
f->set_added(I_TRUE);
if (!f->field_type()->added())
{
return add_type(f->field_type()) ? f : NULL;
}
else
return f;
}
AST_Typedef *UTL_Scope::add_typedef(AST_Typedef *t)
{
if (t == NULL)
return NULL;
t->set_added(I_TRUE);
if (!t->base_type()->added())
{
return add_type(t->base_type()) ? t : NULL;
}
else
return t;
}
AST_Sequence *UTL_Scope::add_sequence(AST_Sequence *s)
{
if (s == NULL)
return NULL;
s->set_added(I_TRUE);
if (!s->base_type()->added())
{
return add_type(s->base_type()) ? s : NULL;
}
else
return s;
}
AST_Array *UTL_Scope::add_array(AST_Array *a)
{
if (a == NULL)
return NULL;
a->set_added(I_TRUE);
if (!a->base_type()->added())
{
return add_type(a->base_type()) ? a : NULL;
}
else
return a;
}
