struct NamedObject *util_AllocNamedObjectA(pUtility UtilBase, STRPTR name, struct TagItem *tagList) { if (name == NULL) return NULL; UINT32 ns = GetTagData(ANO_NameSpace, FALSE, tagList); if (ns == TRUE) ns = sizeof(struct NameSpace); UINT32 us = GetTagData(ANO_UserSpace, 0, tagList); if (us != 0) us +=3; UINT32 nameSize = Strlen((const char*)name); UINT32 allocSize = ns + us + sizeof(struct NamedObj) + nameSize + 1; UINT8 *mem = AllocVec(allocSize, MEMF_PUBLIC|MEMF_CLEAR); if (mem == NULL) return NULL; struct NamedObj *object = (struct NamedObj *) mem; mem += sizeof(struct NamedObj); if (ns) { object->no_Nos.nos_NameSpace = (struct NameSpace *)mem; mem += ns; } object->no_Non.non_Node.ln_Name = (STRPTR)mem; Strcpy((char *)mem, (const char *)name); mem += nameSize+1; struct NamedObject *ret = (struct NamedObject *)BASEOBJECT(object); //&object->no_Nos; if (us) { UINT32 align = (UINT32)mem; align = (align+3) & ~0x03; SYSTEM(ret)->no_Nos.nos_Object = (UINT8*)align; } UINT32 flags = GetTagData(ANO_Flags, 0, tagList); struct NameSpace *namSp = SYSTEM(ret)->no_Nos.nos_NameSpace; if (namSp != NULL) { namSp->ns_Flags = flags; NewList((struct List *)&namSp->ns_Entries); InitSemaphore(&namSp->ns_Semaphore); } INT8 prio = GetTagData(ANO_Priority, 0, tagList); SYSTEM(ret)->no_Non.non_Node.ln_Pri = prio; SYSTEM(ret)->no_Non.non_UseCount = 1; return ret; }
static ULONG rootDispatcher (Class *cl, Object *o, Msg msg) { ULONG retval = 0; switch (msg->MethodID) { case OM_NEW: /* Called at beginning of constructor, allocate memory for object. */ cl = _OBJECT(o)->o_Class; retval = (ULONG)g_mem_chunk_alloc0(cl->cl_MemChunk); retval = (ULONG) BASEOBJECT(retval); OCLASS(retval) = cl; break; case OM_DISPOSE: /* Speicher freigeben. Aufrufer ist verantwortlich, dass bereits alles andere freigegeben wurde ! */ cl = _OBJECT(o)->o_Class; /* g_print("rootDispatcher: DISPOSE: obj=%p cl=%p %s, clmc=%p\n", o, cl, */ /* cl->cl_ID ? cl->cl_ID : "", cl->cl_MemChunk); */ g_mem_chunk_free(cl->cl_MemChunk, _OBJECT(o)); break; #ifdef REALAROSSTUFF /* unused in Zune */ case OM_ADDTAIL: /* Fuege <o> an Liste an. */ AddTail (((struct opAddTail *)msg)->opat_List, (struct Node *) _OBJECT(o)); break; case OM_REMOVE: /* Entferne Object aus der Liste */ Remove ((struct Node *) _OBJECT(o)); break; #endif default: /* Ignore */ break; } /* switch */ return (retval); }
struct NamedObject *util_FindNamedObject(pUtility UtilBase, struct NamedObject *nameSpace, STRPTR name, struct NamedObject *lastObject) { struct NamedObj *tmp; struct NamedObject *ret = NULL; struct NameSpace *ns = getNameSpace(UtilBase, nameSpace); if (ns == NULL) return NULL; ObtainSemaphoreShared(&ns->ns_Semaphore); if (lastObject == NULL) tmp = (struct NamedObj *)ns->ns_Entries.mlh_Head; else tmp = (struct NamedObj *)SYSTEM(lastObject)->no_Non.non_Node.ln_Succ; tmp = searchns(UtilBase, tmp, ns, name); if (tmp) { tmp->no_Non.non_UseCount++; ret = (struct NamedObject *) BASEOBJECT(tmp); } ReleaseSemaphore(&ns->ns_Semaphore); return ret; }
/* * Create an object from a class. */ Object * NewObjectA (struct IClass *classPtr, ClassID classID, struct TagItem *tagList) { Object * object; struct _Object carrier; /* No classPtr ? */ if (!classPtr) { /* Search for the class */ if (!(classPtr = GetPublicClass(classID)) ) { /* I used to have a last-resort builtin class creation here, * but I decided nobody should need it, because you * dont have to call this function with a non-public class -dlc */ g_error("NewObjectA: null classPtr, and non public class %s\n" "Perhaps you should try MUI_NewObjectA ?\n", classID); return (NULL); /* Nothing found */ } } /* Put the classPtr in our dummy object */ carrier.o_Class = classPtr; /* Try to create a new object */ if ((object = (Object *) DoMethod (BASEOBJECT(&carrier), OM_NEW, (ULONG)tagList))) { OCLASS(object) = classPtr; /* One more object */ classPtr->cl_ObjectCount ++; } return (object); } /* NewObjectA */
/*****i************************************************************************ NAME */ AROS_UFH3(IPTR, rootDispatcher, /* SYNOPSIS */ AROS_UFHA(Class *, cl, A0), AROS_UFHA(Object *, o, A2), AROS_UFHA(Msg, msg, A1)) /* FUNCTION Internal function! Processes all messages sent to the RootClass. Unknown messages are silently ignored. INPUTS cl - Pointer to the RootClass o - This object was the destination for the message in the first place msg - This is the message. RESULT The meaning of the result depends on the type of the message. NOTES This is a good place to debug BOOPSI objects since every message should eventually show up here. EXAMPLE BUGS SEE ALSO ******************************************************************************/ { AROS_USERFUNC_INIT IPTR retval = 0; Class *iclass; switch (msg->MethodID) { case OM_NEW: iclass = (Class *) o; /* Get memory for the instance data. The class knows how much is needed. NOTE: The object argument is actually the class! */ o = (Object *) alloc ( iclass->cl_MemoryPool, iclass->cl_ObjectSize ); if (o) { _OBJ(o)->o_Class = iclass; AROS_ATOMIC_INC(iclass->cl_ObjectCount); retval = (IPTR) BASEOBJECT(o); } break; case OM_DISPOSE: /* Free memory. Caller is responsible that everything else is already cleared! */ iclass = OCLASS(o); free ( iclass->cl_MemoryPool, _OBJECT(o), iclass->cl_ObjectSize ); AROS_ATOMIC_DEC(iclass->cl_ObjectCount); break; case OM_ADDTAIL: /* Add <o> to list. */ AddTail (((struct opAddTail *)msg)->opat_List, (struct Node *) _OBJECT(o)); retval = TRUE; break; case OM_REMOVE: /* Remove object from list. */ Remove ((struct Node *) _OBJECT(o)); retval = TRUE; break; case OM_SET: case OM_GET: case OM_UPDATE: case OM_NOTIFY: case OM_ADDMEMBER: case OM_REMMEMBER: default: /* Ignore */ break; } /* switch */ return (retval); AROS_USERFUNC_EXIT } /* rootDispatcher */