unsigned long CBOFSDecoder::helper(unsigned char* inputBuffer, int& inputPosition, unsigned char& flags, int& flagLeft, int num)
{
//"""Returns a value equal to the next num bits in stream.
//itr should point to the self._flags() method above."""
unsigned long v=0;
for (int i = 0; i < num; i++)
{
v <<=1;
bool flagRet = _flags(inputBuffer, inputPosition, flags, flagLeft);;
v|=flagRet;
}
return v;
}
std::string OcelotConfig::string() const
{
std::string result;
if( version )
{
result = _version();
}
else if( flags )
{
result = _flags();
}
else if( prefix )
{
result = _prefix();
}
else if( libs )
{
result = _libs();
}
else if( includedir )
{
result = _includedir();
}
else if( libdir )
{
result = _libdir();
}
else if( bindir )
{
result = _bindir();
}
else
{
return "";
}
if( trace )
{
result += _tracelibs();
}
return result + "\n";
}
IPTR Pendisplay__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Pendisplay_DATA *data;
const struct TagItem *tags;
struct TagItem *tag;
BOOL newcol = FALSE;
IPTR retval;
data = INST_DATA(cl, obj);
for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Pendisplay_Reference:
if (data->refobj)
{
DoMethod(data->refobj, MUIM_KillNotifyObj, MUIA_Pendisplay_Spec, (IPTR)obj);
}
data->refobj = (Object *)tag->ti_Data;
if (data->refobj)
{
DoMethod(data->refobj, MUIM_Notify, MUIA_Pendisplay_Spec, MUIV_EveryTime,
(IPTR)obj, 3, MUIM_Set, MUIA_Pendisplay_Spec, MUIV_TriggerValue);
}
newcol = TRUE;
break;
case MUIA_Pendisplay_RGBcolor:
{
struct MUI_RGBcolor *rgb = (struct MUI_RGBcolor *)tag->ti_Data;
snprintf(data->penspec.ps_buf, sizeof(data->penspec.ps_buf),
"%lc%08lx,%08lx,%08lx", (LONG)PST_RGB, rgb->red, rgb->green, rgb->blue);
}
newcol = TRUE;
break;
case MUIA_Pendisplay_Spec:
if (tag->ti_Data)
{
data->penspec = *(struct MUI_PenSpec *)tag->ti_Data;
newcol = TRUE;
}
break;
}
}
retval = DoSuperMethodA(cl, obj, (Msg)msg);
if (newcol && (_flags(obj) & MADF_SETUP))
{
if (data->pen != -1)
{
MUI_ReleasePen(muiRenderInfo(obj), data->pen);
data->pen = -1;
}
if (!data->refobj)
{
data->pen = MUI_ObtainPen(muiRenderInfo(obj), &data->penspec, 0);
}
MUI_Redraw(obj, MADF_DRAWUPDATE);
}
return retval;
}
static OBJ parse(FILE *f, HASHTAB t, OBJ *ep){
OBJ d;
int shared;
d = read_obj(f,ep);
if (*ep) return NIL;
if (isVal(d)) {
return d;
} else if (isRefToCell(d)) {
WORD lab = getLabel(d);
int i; HASHENTRY e;
i = lab % HASHSIZE;
for (e = t->tab[i]; e; e = e->next) {
if (e->label == lab) {
/* increment RC of refered cell and return it. */
_incRc(_header(e->obj),1);
return e->obj;
}
}
/* Format error. */
copy_some(__ABinFile_AinvalidFormat,1);
*ep = __ABinFile_AinvalidFormat;
return NIL;
} else if ((shared = isSharedCell(d)) || isExclCell(d)) {
int sz = getSize(d), fs = getFlags(d), i;
intptr_t flds;
OBJ * data; OBJ ob; WORD lab;
if (shared) {
lab = (WORD)read_obj(f,ep);
if (*ep) return NIL;
if (!isRefToCell(lab)){
copy_some(__ABinFile_AinvalidFormat,1);
*ep = __ABinFile_AinvalidFormat;
return NIL;
}
}
if (sz % flat_offset_ssize == big_escape_ssize){
flds = (intptr_t)read_obj(f,ep);
if (*ep) return NIL;
ob = _bigAlloc(flds);
_mkHeader(_header(ob),sz,1);
((BCELL)ob)->size = pack_word(flds);
data = _bdata(ob);
} else {
flds = sz % flat_offset_ssize;
_alloc(flds,ob);
_mkHeader(_header(ob),sz,1);
data = _data(ob);
}
_flags(_header(ob)) = fs;
if (shared){
HASHENTRY e;
lab = getLabel(lab);
e = newEntry();
e->label = lab; e->obj = ob;
i = lab % HASHSIZE;
e->next = t->tab[i]; t->tab[i] = e;
}
if (sz >= flat_offset_ssize) {
if (fs & (1 << byte_flat_sflag)){
/* read two words and rest as char stream */
/* (UPDATE STRING FORMAT) */
unsigned char * cdata = (unsigned char*)(data+2);
int ch, cflds = (flds-2) * sizeof(OBJ);
data[0] = read_obj(f,ep); data[1] = read_obj(f,ep);
for (i = 0; i < cflds && !*ep; i++) {
if ((ch = getc(f)) != EOF){
cdata[i] = ch;
} else
get_unix_failure(errno,*ep);
}
} else {
/* read contents of unstructured cell. */
for (i = 0; i < flds && !*ep; i++) {
data[i] = read_obj(f,ep);
}
}
} else {
/* recursivly parse structured cell. */
for (i = 0; i < flds && !*ep; i++) {
data[i] = parse(f,t,ep);
}
}
/* process closures */
if (tst_sflag(ob, closure_sflag)){
char msgbuf[128];
char * msg = link_closure(ob);
if (msg){
strcpy(msgbuf, (char*)
data_denotation(__ABinFile_AlinkErrorPrefix));
strcat(msgbuf, (char*)
data_denotation(((CLOSURE)ob)->symbolid));
strcat(msgbuf,"': ");
strcat(msgbuf,msg);
*ep = declare_failure_answer(msgbuf);
return NIL;
}
}
return ob;
} else {
copy_some(__ABinFile_AinvalidFormat,1);
*ep = __ABinFile_AinvalidFormat;
return NIL;
}
}
static void dump(FILE *f, HASHTAB t, OBJ ob, int *labct, OBJ *ep) {
if (is_structured(ob)){
int sz = _size(_header(ob)), fs = _flags(_header(ob)), i;
intptr_t flds;
OBJ *data;
if (_tstRc(_header(ob),1)) {
write_obj(f,mkExclCell(fs,sz),ep);
if (*ep) return;
} else {
HASHENTRY e;
/* check if object already dumped */
i = (WORD)ob % HASHSIZE;
for (e = t->tab[i]; e; e = e->next) {
if (e->obj == ob) {
write_obj(f,mkRefToCell(e->label),ep);
return;
}
}
/* first time dumping a shared cell */
write_obj(f,mkSharedCell(fs,sz),ep);
if (*ep) return;
/* create new entry in hashtab and assign
label to it, since we might have to visit it again.
*/
e = newEntry();
e->label = (*labct)++;
write_obj(f,mkRefToCell(e->label),ep);
if (*ep) return;
e->obj = ob;
e->next = t->tab[i]; t->tab[i] = e;
}
/* calculate no of fields */
if (sz % flat_offset_ssize == big_escape_ssize){
flds = unpack_word(((BCELL)ob)->size);
write_obj(f,(OBJ)flds,ep);
if (*ep) return;
data = _bdata(ob);
} else {
flds = sz % flat_offset_ssize;
data = _data(ob);
}
if (sz >= flat_offset_ssize) {
if (fs & (1 << byte_flat_sflag)){
/* write 2 words and rest as char stream */
unsigned char * cdata = (unsigned char*)(data+2);
int cflds = (flds-2) * sizeof(OBJ);
write_obj(f,data[0],ep); write_obj(f,data[1],ep);
for (i = 0; i < cflds && !*ep; i++) {
if (putc(cdata[i],f) != cdata[i]){
get_unix_failure(errno,*ep);
}
}
} else {
/* write fields as coded longwords */
for (i = 0; i < flds && !*ep; i++) {
write_obj(f,data[i],ep);
}
}
} else {
/* recursivly dump fields. */
for (i = 0; i < flds && !*ep; i++) {
dump(f,t,data[i],labct,ep);
}
}
} else {
write_obj(f,ob,ep);
}
}
IPTR Colorfield__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Colorfield_DATA *data;
const struct TagItem *tags;
struct TagItem *tag;
ULONG *rgb;
BOOL newcol = FALSE;
IPTR retval;
data = INST_DATA(cl, obj);
for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Colorfield_Red:
data->rgb[0] = (ULONG)tag->ti_Data;
newcol = TRUE;
break;
case MUIA_Colorfield_Green:
data->rgb[1] = (ULONG)tag->ti_Data;
newcol = TRUE;
break;
case MUIA_Colorfield_Blue:
data->rgb[2] = (ULONG)tag->ti_Data;
newcol = TRUE;
break;
case MUIA_Colorfield_RGB:
rgb = (ULONG *)tag->ti_Data;
data->rgb[0] = *rgb++;
data->rgb[1] = *rgb++;
data->rgb[2] = *rgb++;
newcol = TRUE;
break;
case MUIA_Colorfield_Pen:
if (data->flags & FLAG_PEN_ALLOCATED)
{
ReleasePen(_screen(obj)->ViewPort.ColorMap, data->pen);
data->flags &= ~(FLAG_PEN_ALLOCATED | FLAG_NO_PEN);
}
data->pen = (UBYTE)data->pen;
data->flags |= FLAG_FIXED_PEN;
break;
}
}
retval = DoSuperMethodA(cl, obj, (Msg)msg);
if (newcol && (_flags(obj) & MADF_SETUP) && !(data->flags & FLAG_NO_PEN))
{
SetRGB32(&_screen(obj)->ViewPort, data->pen, data->rgb[0], data->rgb[1], data->rgb[2]);
if (GetBitMapAttr(_rp(obj)->BitMap, BMA_DEPTH) > 8)
{
MUI_Redraw(obj, MADF_DRAWUPDATE);
}
}
return retval;
}
EXAMPLE
BUGS
The function itself is a bug ;-) Remove it!
SEE ALSO
INTERNALS
HISTORY
*****************************************************************************/
{
AROS_LIBFUNC_INIT
if (muiRenderInfo(obj) && (_flags(obj) & MADF_SETUP) && _win(obj))
{
if (muiAreaData(obj)->mad_hiehn.ehn_Events)
{
DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&muiAreaData(obj)->mad_hiehn);
}
muiAreaData(obj)->mad_hiehn.ehn_Events &= ~flags;
if (muiAreaData(obj)->mad_hiehn.ehn_Events)
{
DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&muiAreaData(obj)->mad_hiehn);
}
}
else
{
muiAreaData(obj)->mad_hiehn.ehn_Events &= ~flags;
}
IPTR Prop__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Prop_DATA *data;
struct TagItem *tags,*tag;
obj = (Object *)DoSuperNewTags(cl, obj, NULL,
MUIA_Background, MUII_PropBack,
TAG_MORE, (IPTR) msg->ops_AttrList);
if (!obj)
return FALSE;
data = INST_DATA(cl, obj);
data->deltafactor = 1;
/* parse initial taglist */
for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Prop_Entries:
data->entries = tag->ti_Data;
break;
case MUIA_Prop_First:
data->first = tag->ti_Data;
break;
case MUIA_Prop_Horiz:
data->horiz = tag->ti_Data;
break;
case MUIA_Prop_Slider:
break;
case MUIA_Prop_UseWinBorder:
data->usewinborder = tag->ti_Data;
break;
case MUIA_Prop_Visible:
data->visible = tag->ti_Data;
break;
case MUIA_Prop_DeltaFactor:
data->deltafactor = tag->ti_Data;
break;
}
}
if (data->horiz == TRUE)
{
data->minwidth = 6;
data->minheight = 6;
data->maxwidth = MUI_MAXMAX;
data->maxheight = MUI_MAXMAX;
data->defwidth = 50;
data->defheight = 6;
}
else
{
data->minwidth = 6;
data->minheight = 6;
data->maxwidth = MUI_MAXMAX;
data->maxheight = MUI_MAXMAX;
data->defwidth = 6;
data->defheight = 50;
}
if (data->first < 0)
data->first = 0;
data->ehn.ehn_Events = IDCMP_IDCMPUPDATE;
data->ehn.ehn_Priority = 0;
data->ehn.ehn_Flags = 0;
data->ehn.ehn_Object = obj;
data->ehn.ehn_Class = cl;
if (data->usewinborder)
_flags(obj) |= MADF_BORDERGADGET;
calcscale16(data);
return (IPTR)obj;
}
