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 */
