OPT OSVERSION=37, PREPROCESS
MODULE 'utility', 'utility/hooks', 'utility/tagitem',
       'intuition/classes', 'intuition/classusr',
       'tools/installhook', 'AmigaLib/boopsi'
MODULE '*errorsy', 'tools/trapguru'
ENUM 	MKA_DUMMY=$CD410000,	-> Start tagów
	MKA_DATA,	-> zwraca ptr na dane objektu
	MKA_REZ,	-> rezerwacja pamiėci min. 3, (dla NewObject() )
	MKA_TYP,	-> typ elementu
	MKA_LIST,	-> ptr na listė elementów
	MKA_LEN,	-> dīugoōź listy
	MKA_ITEM,	-> ptr na element z listy
	MKA_POS,	-> pozycja elementu na liōcie
	MIA_FILE,	-> nazwa pliku
	MIA_DATA	-> miData dla OM_NEW
ENUM 	MKM_DUMMY=$CD4D0000,	-> Start metod
	MKM_Read,
	MKM_Write,
	MKM_Add,	-> dodaje gotowy element na koniec listy
	MKM_Ins,	-> wstawia gotowy element do listy - Insert
	MKM_Del,	-> usuwa dany element wycinajāc powstaīā dziurė
	MKM_NewItem,	-> tworzy nowy element
	MKM_EndItem,	-> zwalnia pamiėź elemenu
	MKM_NewAddItem,	-> MKM_NewItem i MKM_Add
	MKM_NewInsItem,	-> MKM_NewItem i MKM_Ins
	MKM_EndDelItem,	-> MKM_EndItem i MKM_Del
	MKM_GetItem,	-> zwraca element
	MIM_WriteFile	-> nagrywa baze do pliku

OBJECT mkData
  typ		-> typ listy
  list		-> ptr na listė elementów
  rez		-> rezerwacja cykliczna pamiėci dla rez elementów
  max		-> dīugoōź zarezerwowanej listy
  len		-> iloōź zapisanych elementów
  pos		-> numer elementu
ENDOBJECT

OBJECT mkm_Write
  methodid
  text
ENDOBJECT
OBJECT mkm_Add
  methodid
  item		-> ptr to item
ENDOBJECT
OBJECT mkm_Del
  methodid
  pos		-> pozycja
ENDOBJECT
OBJECT mkm_Ins
  methodid
  item
  pos
ENDOBJECT

OBJECT mim_Write
  methodid
  plik
ENDOBJECT



OBJECT oDataMikoHead
  itemlen:LONG
  compress : CHAR
  x : CHAR
  y : CHAR
  z : CHAR
ENDOBJECT

OBJECT oTypPozycji
  typ	: LONG	->"TXTn"
  len	: LONG
ENDOBJECT



OBJECT miData 
  data	: PTR TO oDataMikoHead
  ver	: PTR TO CHAR	-> copyring
  ques 	: PTR TO CHAR
  pics 	: PTR TO CHAR
  song	: PTR TO CHAR
  samp	: PTR TO CHAR
  anim	: PTR TO CHAR
  rexx	: PTR TO CHAR
  ados	: PTR TO CHAR
  sayq	: PTR TO CHAR
  sayk	: PTR TO CHAR
  komG	: PTR TO CHAR		-> pliki z komentarzami
  komC	: PTR TO CHAR
  komB	: PTR TO CHAR
  komg	: PTR TO CHAR		-> komentarze standardowe
  komc	: PTR TO CHAR
  komb	: PTR TO CHAR
  lenp				-> iloōź pozycji w pytn
  leno				-> iloōź pozycji w odpw
  typtp	: PTR TO LONG		-> tablica typów pytaļ
  typto	: PTR TO LONG
  lentp	: PTR TO LONG		-> tablica dīugoōci pytaļ
  lento	: PTR TO LONG
ENDOBJECT

OBJECT oItem
  pics 	: PTR TO CHAR 	->nazwy plików do obsīugi (wyōwietlanie itp.)
  song	: PTR TO CHAR
  samp	: PTR TO CHAR
  anim	: PTR TO CHAR
  rexx	: PTR TO CHAR
  ados	: PTR TO CHAR
  komg	: PTR TO CHAR
  komc	: PTR TO CHAR
  komb	: PTR TO CHAR
  pytn	: PTR TO LONG
  odpw	: PTR TO LONG
ENDOBJECT

RAISE ERR_MEM IF New()=NIL
RAISE ERR_MEM IF List()=NIL
RAISE ERR_MEM IF String()=NIL



DEF typ, var, lenmem

PROC mkDispatch(cl:PTR TO iclass, o, msg:PTR TO msg)
DEF id

    id:=msg.methodid
    SELECT id
    CASE OM_NEW;	RETURN mkNew(cl, o, msg)
    CASE OM_DISPOSE;	RETURN mkDispose(cl, o, msg)
    CASE OM_SET;	RETURN mkSet(cl, o, msg)
    CASE OM_GET;	RETURN mkGet(cl, o, msg)
    CASE MKM_Add;	RETURN mkAdd(cl, o, msg)
    CASE MKM_Ins;	RETURN mkIns(cl, o, msg)
    CASE MKM_Del;	RETURN mkDel(cl, o, msg)
    CASE MKM_NewItem;	RETURN mkNewItem(cl, o, msg)
    CASE MKM_EndItem;	RETURN mkEndItem(cl, o, msg)
    CASE MKM_NewAddItem;RETURN mkNewAddItem(cl, o, msg)
    CASE MKM_NewInsItem;RETURN mkNewInsItem(cl, o, msg)
    CASE MKM_EndDelItem;RETURN mkEndDelItem(cl, o, msg)
    CASE MKM_Write;	RETURN mkWrite(cl, o, msg)
    DEFAULT;		RETURN doSuperMethodA(cl, o, msg)
    ENDSELECT

ENDPROC

PROC mkNew(cl:PTR TO iclass, o, msg:PTR TO opnew)
DEF data:PTR TO mkData, return
  return := doSuperMethodA(cl, o, msg)
  data:=INST_DATA(cl, return)
  data.typ:=GetTagData(MKA_TYP, 0, msg.attrlist)
  data.rez:=GetTagData(MKA_REZ, 3, msg.attrlist)
  IF data.rez < 3 THEN data.rez := 3
  data.list:=New(lenmem:=data.rez*4)
  data.max:=data.rez
  data.len:=0
  data.pos:=0
ENDPROC return

PROC mkDispose(cl:PTR TO iclass, o, msg:PTR TO msg)
DEF  data:PTR TO mkData,return
  data:=INST_DATA(cl, o)
  WHILE data.len DO doMethodA(o,[MKM_EndDelItem,0])
  Dispose(data.list)
  return := doSuperMethodA(cl, o, msg)
ENDPROC return

PROC mkSet(cl:PTR TO iclass, o, msg:PTR TO opset)
DEF data:PTR TO mkData, 
    tag, tagi, ti:PTR TO tagitem,
    return
  data:=INST_DATA(cl, o)
  return := doSuperMethodA(cl,o,msg)
  tagi:=msg.attrlist
  WHILE ti:=NextTagItem({tagi})
    tag:=ti.tag
    SELECT tag
    CASE MKA_POS;	data.pos:=ti.data
    CASE MKA_TYP;	data.typ:=ti.data
    ENDSELECT
  ENDWHILE
ENDPROC return

PROC mkGet(cl:PTR TO iclass, o, msg:PTR TO opget)
DEF data:PTR TO mkData, id, addr:PTR TO LONG, list:PTR TO LONG
    data:=INST_DATA(cl, o)
    id:=msg.attrid
    list:=data.list
    addr:=msg.storage
    SELECT id
    CASE MKA_DATA;	addr[]:=data		; RETURN TRUE
    CASE MKA_TYP;	addr[]:=data.typ	; RETURN TRUE
    CASE MKA_LIST;	addr[]:=data.list	; RETURN TRUE
    CASE MKA_LEN;	addr[]:=data.len	; RETURN TRUE
    CASE MKA_ITEM;	addr[]:=list[data.pos]	; RETURN TRUE
    CASE MKA_POS;	addr[]:=data.pos	; RETURN TRUE
    DEFAULT;		RETURN doSuperMethodA(cl, o, msg)
    ENDSELECT
ENDPROC FALSE

PROC mkWrite(cl:PTR TO iclass, o, msg:PTR TO mkm_Write)
DEF data:PTR TO mkData,i, list:PTR TO LONG
  data:=INST_DATA(cl, o)
  list:=data.list
  FOR i:=0 TO data.len-1 DO WriteF('\s, ',list[i])
  WriteF(' = \d\n',data.len)
ENDPROC

PROC mkAdd(cl:PTR TO iclass, o, msg:PTR TO mkm_Add) HANDLE
DEF data:PTR TO mkData,i, mem, list:PTR TO LONG
  data:=INST_DATA(cl, o)
  IF data.max=data.len
    mem:=New(lenmem:=(data.max+data.rez * 4))
    list:=data.list
    CopyMemQuick(data.list, mem, (data.len * 4))
    Dispose(data.list)
    data.list:=mem
    data.max :=data.max + data.rez
  ENDIF
  data.len:=data.len+1
  data.pos:=data.len
  list:=data.list
  list[data.pos-1]:=msg.item
EXCEPT
  jaki_ERR()
ENDPROC

PROC mkIns(cl:PTR TO iclass, o, msg:PTR TO mkm_Ins) HANDLE
DEF data:PTR TO mkData, list:PTR TO LONG,
    mem, mem_surce, mem_dest, item,len
  data:=INST_DATA(cl, o)
  IF msg.pos >= data.len THEN doMethodA(o,[MKM_Add, msg.item])
  list:=data.list
  mem:=New(lenmem:=(data.max+1) * 4)
  mem_surce := data.list
  mem_dest := mem
  len := (msg.pos) * 4
  CopyMemQuick(mem_surce, mem_dest, len )
  mem_surce := mem_surce + len
  mem_dest := mem + len + 4
  len := (data.len * 4) - len
  CopyMemQuick(mem_surce, mem_dest, len )
  Dispose(data.list)
  data.list:=mem
  list:=data.list
  list[msg.pos]:=msg.item
  data.max:=data.max+1
  data.len:=data.len+1

EXCEPT
  jaki_ERR()
ENDPROC

PROC mkDel(cl:PTR TO iclass, o, msg:PTR TO mkm_Del) HANDLE
DEF data:PTR TO mkData, list:PTR TO LONG,
    mem=NIL, mem_surce, mem_dest, item,len
  data:=INST_DATA(cl, o)
  list:=data.list
  IF data.max > 1
    mem:=New(lenmem:=(data.max-1) * 4)
    IF msg.pos = 0
      mem_surce := data.list
      mem_surce := mem_surce + 4
      mem_dest := mem
      len := ((data.len-1) * 4)
      CopyMemQuick(mem_surce, mem_dest, len )
    ELSE
      mem_surce := data.list
      mem_dest := mem
      len := msg.pos * 4
      CopyMemQuick(mem_surce, mem_dest, len )
      mem_surce := mem_surce + len + 4
      mem_dest := mem + len
      IF (len := (((data.len-1) * 4) - len)) <> 0
        CopyMemQuick(mem_surce, mem_dest, len )
      ENDIF
    ENDIF
  ENDIF
  Dispose(data.list)
  data.list:=mem
  data.max:=data.max-1
  data.len:=data.len-1
EXCEPT
  jaki_ERR()
ENDPROC

PROC mkNewItem(cl:PTR TO iclass, o, msg:PTR TO mkm_Add) 
ENDPROC msg.item

PROC mkEndItem(cl:PTR TO iclass, o, msg:PTR TO mkm_Add) IS EMPTY
-> usuwa z pamiėci (usuwa z listy metoda MKM_Del)

PROC mkNewAddItem(cl:PTR TO iclass, o, msg:PTR TO mkm_Add)
DEF ptr
  ptr := doMethodA(o,[MKM_NewItem, msg.item])
ENDPROC  doMethodA(o,[MKM_Add,ptr]);

PROC mkNewInsItem(cl:PTR TO iclass, o, msg:PTR TO mkm_Ins)
DEF ptr
  ptr := doMethodA(o,[MKM_NewItem, msg.item])
ENDPROC  doMethodA(o,[MKM_Ins, ptr, msg.pos ]);

PROC mkEndDelItem(cl:PTR TO iclass, o, msg:PTR TO mkm_Del)
  doMethodA(o,[MKM_EndItem, msg.pos])
ENDPROC  doMethodA(o,[MKM_Del, msg.pos]);

/*==================================================================*/
/*==================================================================*/
PROC miDispatch(cl:PTR TO iclass, o, msg:PTR TO msg)
DEF id
    id:=msg.methodid
    SELECT id
    CASE OM_NEW;	RETURN miNew(cl, o, msg)
    CASE OM_DISPOSE;	RETURN miDispose(cl, o, msg)
    CASE MKM_NewItem;	RETURN miNewItem(cl, o, msg)
    CASE MKM_Write;	RETURN miWrite(cl, o, msg)
    CASE MKM_EndItem;	RETURN miEndItem(cl, o, msg)
    CASE MIM_WriteFile;	RETURN miWriteFile(cl, o, msg)
    DEFAULT;		RETURN doSuperMethodA(cl, o, msg)
    ENDSELECT
ENDPROC

PROC miNew(cl:PTR TO iclass, o, msg:PTR TO opnew) HANDLE
DEF data:PTR TO miData, return=NIL, msgData:PTR TO miData
DEF plik:PTR TO CHAR, fh, len,
    headMain[28]:STRING, lenHead:PTR TO LONG,
    head=NIL, body=NIL,
    ptr:PTR TO LONG, ptrt:PTR TO LONG, ptrl:PTR TO LONG
DEF pyt=TRUE, i, j, def:PTR TO CHAR,lendef,
    itempomoc:oTypPozycji,pos,
    oItem: PTR TO oItem

  return := doSuperMethodA(cl, o, msg)
  data:=INST_DATA(cl, return)
  plik:=GetTagData(MIA_FILE, 0, msg.attrlist)
  IF plik = NIL
    msgData:=GetTagData(MIA_DATA, 0, msg.attrlist)
    IF msgData
      data.data:=New(SIZEOF oDataMikoHead)
      CopyMem(msgData.data,data.data,SIZEOF oDataMikoHead)
      data.ver :=newandadd(msgData.ver )
      data.ques:=newandadd(msgData.ques)
      data.pics:=newandadd(msgData.pics)
      data.song:=newandadd(msgData.song)
      data.samp:=newandadd(msgData.samp)
      data.anim:=newandadd(msgData.anim)
      data.rexx:=newandadd(msgData.rexx)
      data.ados:=newandadd(msgData.ados)
      data.sayq:=newandadd(msgData.sayq)
      data.sayk:=newandadd(msgData.sayk)
      data.komG:=newandadd(msgData.komG)
      data.komC:=newandadd(msgData.komC)
      data.komB:=newandadd(msgData.komB)
      data.komg:=newandadd(msgData.komg)
      data.komc:=newandadd(msgData.komc)
      data.komb:=newandadd(msgData.komb)
      data.lenp:=msgData.lenp
      data.leno:=msgData.leno
      IF data.lenp
        data.typtp:=New(data.lenp*4)
        data.lentp:=New(data.lenp*4)
        CopyMem(typ:=msgData.typtp, var:=data.typtp, (data.lenp*4))
        CopyMem(typ:=msgData.lentp, var:=data.lentp, (data.lenp*4))
      ELSE
        data.typtp:=NIL;	data.lentp:=NIL
      ENDIF
      IF data.leno
        data.typto:=New(data.leno*4)
        data.lento:=New(data.leno*4)
        CopyMem(typ:=msgData.typto, var:=data.typto, (data.leno*4))
        CopyMem(typ:=msgData.lento, var:=data.lento, (data.leno*4))
      ELSE
        data.typto:=NIL;	data.lento:=NIL
      ENDIF
    ELSE
      FOR i:=0 TO (SIZEOF miData)-1 DO CopyMem([0], data+i, 1)
    ENDIF
    RETURN return
  ENDIF
  IF ((len:=FileLength(plik))<=NIL) OR ((fh:=Open(plik,OLDFILE))=NIL) THEN Throw(ERR_OPEN,plik)
  Read(fh, headMain, 28)
  IF StrCmp(headMain,'MiKO',4) = NIL THEN Throw(ERR_STR,'Zīy nagīówek pliku')
  IF ((ptr := szukaj4char(headMain, headMain+20, 'DANE'))  = FALSE) THEN Throw(ERR_STR,'Brak nagīówka "DANE"')
  lenHead:=ptr[1]
  len:=SIZEOF oDataMikoHead
  data.data:=New(lenmem:=len)
  CopyMem(ptr+8,data.data,len)
  head:= New(lenmem:=lenHead)
  Read(fh,head, lenHead)
  IF ((ptr := szukaj4char(head, head+lenHead, 'DEFI')) = FALSE) THEN Throw(ERR_STR,'Zīa definicja elementów w pliku')
  lendef:=ptr[1]
  def:=ptr+8
  FOR i:=0 TO lendef-1 STEP 8
    CopyMem(def+i,itempomoc,8)
    IF StrCmp(itempomoc,'ODPW',4)
      pyt:=FALSE
      data.leno:=itempomoc.len
      data.typto:=New(lenmem:=data.leno*4)
      data.lento:=New(lenmem:=data.leno*4)
      ptrt:=data.typto
      ptrl:=data.lento
    ELSEIF StrCmp(itempomoc,'PYTN',4)
      pyt:=TRUE
      data.lenp:=itempomoc.len
      data.typtp:=New(lenmem:=data.lenp*4)
      data.lentp:=New(lenmem:=data.lenp*4)
      ptrt:=data.typtp
      ptrl:=data.lentp
    ELSE
      IF pyt
        ptrt[]++:=itempomoc.typ;
        ptrl[]++:=itempomoc.len;
      ELSE
        ptrt[]++:=itempomoc.typ;
        ptrl[]++:=itempomoc.len;
      ENDIF
    ENDIF
  ENDFOR
  data.ver  := znajdziwpisz('VER:', '\n', head, head+lenHead)
  data.ques := znajdziwpisz('QUES', '\n', head, head+lenHead)
  data.pics := znajdziwpisz('PICS', '\n', head, head+lenHead)
  data.song := znajdziwpisz('SONG', '\n', head, head+lenHead)
  data.samp := znajdziwpisz('SAMP', '\n', head, head+lenHead)
  data.anim := znajdziwpisz('ANIM', '\n', head, head+lenHead)
  data.rexx := znajdziwpisz('REXX', '\n', head, head+lenHead)
  data.ados := znajdziwpisz('ADOS', '\n', head, head+lenHead)
  data.sayq := znajdziwpisz('SAYQ', '\n', head, head+lenHead)
  data.sayk := znajdziwpisz('SAYK', '\n', head, head+lenHead)
  data.komG := znajdziwpisz('KOMG', '\n', head, head+lenHead)
  data.komC := znajdziwpisz('KOMC', '\n', head, head+lenHead)
  data.komB := znajdziwpisz('KOMB', '\n', head, head+lenHead)
  data.komg := znajdziwpisz('KOMg', '\n', head, head+lenHead)
  data.komc := znajdziwpisz('KOMc', '\n', head, head+lenHead)
  data.komb := znajdziwpisz('KOMb', '\n', head, head+lenHead)

  IF (ptr := szukaj4char(head, head+lenHead, 'BODY')) = FALSE THEN Throw(ERR_STR,'Brak nagīówka "BODY"')
  len:=ptr[1]
  ptr:=ptr+8
  body:= New(lenmem:=len)
  pos:=(ptr-head)+28
  Seek(fh,pos,-1)	-> OFFSET_BEGINNING = -1
  Read(fh, body, len)
  Close(fh)

  oItem:=New(lenmem:=(SIZEOF oItem))
  oItem.pytn:=New(lenmem:=(data.lenp*4))
  oItem.odpw:=New(lenmem:=data.leno*4)
  ptr:=body
  FOR i:=1 TO data.data.itemlen
    IF (ptr := szukaj4char(ptr, ptr+100, 'ITEM')) <> FALSE
      len:=ptr[1]
      def:=ptr+8
      oItem.pics:= znajdziwpisz('PICS', '\n', def, def+len)
      oItem.song:= znajdziwpisz('SONG', '\n', def, def+len)
      oItem.samp:= znajdziwpisz('SAMP', '\n', def, def+len)
      oItem.anim:= znajdziwpisz('ANIM', '\n', def, def+len)
      oItem.rexx:= znajdziwpisz('REXX', '\n', def, def+len)
      oItem.ados:= znajdziwpisz('ADOS', '\n', def, def+len)
      oItem.komg:= znajdziwpisz('KOMg', '\n', def, def+len)
      oItem.komc:= znajdziwpisz('KOMc', '\n', def, def+len)
      oItem.komb:= znajdziwpisz('KOMb', '\n', def, def+len)
    ENDIF
    ptr:=ptr+8+len
    FOR j:=0 TO data.lenp-1
      oItem.pytn[j]:=readTo(ptr,'\n',data.lentp[j])
      ptr:=ptr+StrLen(oItem.pytn[j])+1
    ENDFOR
    FOR j:=0 TO data.leno-1
      oItem.odpw[j]:=readTo(ptr,'\n',data.lento[j])
      ptr:=ptr+StrLen(oItem.odpw[j])+1
    ENDFOR
    doMethodA(return, [MKM_NewAddItem, oItem])
  ENDFOR

EXCEPT DO
  IF head <> NIL THEN Dispose(head)
  IF body <> NIL THEN Dispose(body)
  IF oItem.pytn THEN Dispose(oItem.pytn)
  IF oItem.odpw THEN Dispose(oItem.odpw)
  IF oItem THEN	Dispose(oItem)
  IF exception THEN return:=doMethodA(return, [OM_DISPOSE, NIL])
  jaki_ERR()
ENDPROC return

PROC znajdziwpisz(co, do, poczatek, koniec )
DEF ptr :PTR TO LONG
  IF (ptr := szukaj4char(poczatek, koniec, co)) <> FALSE
    RETURN readTo(ptr+4,do,100)
  ELSE
    RETURN NIL
  ENDIF
ENDPROC

PROC miDispose(cl:PTR TO iclass, o, msg:PTR TO msg)
DEF data:PTR TO miData,return
  data:=INST_DATA(cl, o)
  IF data.ver  <> NIL THEN DisposeLink(data.ver)
  IF data.ques <> NIL THEN DisposeLink(data.ques)
  IF data.pics <> NIL THEN DisposeLink(data.pics)
  IF data.song <> NIL THEN DisposeLink(data.song)
  IF data.samp <> NIL THEN DisposeLink(data.samp)
  IF data.anim <> NIL THEN DisposeLink(data.anim)
  IF data.rexx <> NIL THEN DisposeLink(data.rexx)
  IF data.ados <> NIL THEN DisposeLink(data.ados)
  IF data.sayq <> NIL THEN DisposeLink(data.sayq)
  IF data.sayk <> NIL THEN DisposeLink(data.sayk)
  IF data.komG <> NIL THEN DisposeLink(data.komG)
  IF data.komC <> NIL THEN DisposeLink(data.komB)
  IF data.komB <> NIL THEN DisposeLink(data.komB)
  IF data.komg <> NIL THEN DisposeLink(data.komg)
  IF data.komc <> NIL THEN DisposeLink(data.komc)
  IF data.komb <> NIL THEN DisposeLink(data.komb)

  IF data.typtp <> NIL THEN Dispose(data.typtp)
  IF data.typto <> NIL THEN Dispose(data.typto)
  IF data.lentp <> NIL THEN Dispose(data.lentp)
  IF data.lento <> NIL THEN Dispose(data.lento)

  IF data.data <> NIL THEN Dispose(data.data)
  return := doSuperMethodA(cl, o, msg)
ENDPROC return

PROC newandadd(surc)
DEF dest
  IF surc
    dest:=String(StrLen(surc))
    StrCopy(dest,surc)
  ELSE
    dest:=NIL
  ENDIF
ENDPROC dest

PROC miNewItem(cl:PTR TO iclass, o, msg:PTR TO mkm_Add) HANDLE
DEF mem:PTR TO oItem, item:PTR TO oItem, i, return=NIL,
    data:PTR TO miData
  data:=INST_DATA(cl,o)
  item:=msg.item
  mem:=New(lenmem:=(SIZEOF oItem))
  mem.pics:=newandadd(item.pics)
  mem.song:=newandadd(item.song)
  mem.samp:=newandadd(item.samp)
  mem.anim:=newandadd(item.anim)
  mem.rexx:=newandadd(item.rexx)
  mem.ados:=newandadd(item.ados)
  mem.komg:=newandadd(item.komg)
  mem.komc:=newandadd(item.komc)
  mem.komb:=newandadd(item.komb)
  mem.pytn:=New(lenmem:=data.lenp*4)
  mem.odpw:=New(lenmem:=data.leno*4)
  FOR i:=0 TO data.lenp-1
     mem.pytn[i]:=newandadd(item.pytn[i])
  ENDFOR
  FOR i:=0 TO data.leno-1
    mem.odpw[i]:=newandadd(item.odpw[i])
  ENDFOR
  return:=doSuperMethodA(cl, o, [MKM_NewItem, mem])
EXCEPT
  jaki_ERR()
ENDPROC return


PROC miEndItem(cl:PTR TO iclass, o, msg:PTR TO mkm_Del)
DEF list:PTR TO LONG, pItem:PTR TO oItem, i, return=NIL,
    data:PTR TO miData
  data:=INST_DATA(cl, o)
  GetAttr(MKA_LIST, o, {list})
  pItem:=list[msg.pos]
  IF pItem = NIL THEN RETURN FALSE
  FOR i:=0 TO data.lenp-1
    DisposeLink(pItem.pytn[i])
  ENDFOR
  FOR i:=0 TO data.leno-1
    DisposeLink(pItem.odpw[i])
  ENDFOR
  Dispose(pItem)
  return:=doSuperMethodA(cl, o, [MKM_EndItem, msg.pos])
ENDPROC return


PROC miWrite(cl:PTR TO iclass, o, msg:PTR TO mkm_Write)
DEF pItem:PTR TO oItem, data: PTR TO miData,
    i,j, len,
    list:PTR TO LONG
  data:=INST_DATA(cl, o)
  GetAttr(MKA_LIST, o, {list})
  GetAttr(MKA_LEN, o, {len})
  FOR j:=0 TO len-1
    pItem:=list[j]
    WriteF('element nr \d\n', j)
    WriteF('pytanie\n')
    FOR i:=0 TO data.lenp-1
      WriteF('\s\n', pItem.pytn[i])
    ENDFOR
    WriteF('odpowiedś\n')
    FOR i:=0 TO data.leno-1
      WriteF('\s\n', pItem.odpw[i])
    ENDFOR
  ENDFOR
  WriteF('elementów = \d\n',len)
ENDPROC

PROC dajlen(text:PTR  TO CHAR)
DEF wynik=0
  IF text 
    IF (wynik:=StrLen(text)) THEN wynik:=wynik+5 ELSE RETURN FALSE
  ELSE
    RETURN FALSE
  ENDIF
ENDPROC wynik

PROC miWriteFile(cl:PTR TO iclass, o, msg:PTR TO mim_Write) HANDLE
DEF data:PTR TO miData, pItem:PTR TO oItem, buffor, fh=NIL,
    lenfull=0, lenlist, list:PTR TO LONG, i, j, ptr:PTR TO CHAR,
    body,item, typek: oTypPozycji, len

  data:=INST_DATA(cl,o)
  GetAttr(MKA_LIST, o, {list})
  GetAttr(MKA_LEN, o, {lenlist})

  lenfull:=12+(SIZEOF oDataMikoHead)+8			->DATA
  lenfull:=lenfull+((data.lenp+data.leno)*8) +24	->DEFI
  lenfull:=lenfull+dajlen(data.ver)
  lenfull:=lenfull+dajlen(data.ques)
  lenfull:=lenfull+dajlen(data.pics)
  lenfull:=lenfull+dajlen(data.song)
  lenfull:=lenfull+dajlen(data.samp)
  lenfull:=lenfull+dajlen(data.anim)
  lenfull:=lenfull+dajlen(data.rexx)
  lenfull:=lenfull+dajlen(data.ados)
  lenfull:=lenfull+dajlen(data.sayq)
  lenfull:=lenfull+dajlen(data.sayk)
  lenfull:=lenfull+dajlen(data.komG)
  lenfull:=lenfull+dajlen(data.komC)
  lenfull:=lenfull+dajlen(data.komB)
  lenfull:=lenfull+dajlen(data.komg)
  lenfull:=lenfull+dajlen(data.komc)
  lenfull:=lenfull+dajlen(data.komb)
  lenfull:=lenfull+8+1			-> BODY
  body:=lenfull

  FOR i:=0 TO lenlist-1
    pItem:=list[i]
    lenfull:=lenfull+8			-> ITEM
    lenfull:=lenfull+dajlen(pItem.pics) 	->nazwy plików do obsīugi (wyōwietlanie itp.)
    lenfull:=lenfull+dajlen(pItem.song)
    lenfull:=lenfull+dajlen(pItem.samp)
    lenfull:=lenfull+dajlen(pItem.anim)
    lenfull:=lenfull+dajlen(pItem.rexx)
    lenfull:=lenfull+dajlen(pItem.ados)
    lenfull:=lenfull+dajlen(pItem.komg)
    lenfull:=lenfull+dajlen(pItem.komc)
    lenfull:=lenfull+dajlen(pItem.komb)
    FOR j:=0 TO data.lenp-1
      lenfull:=lenfull+StrLen(pItem.pytn[j])+1
    ENDFOR
    FOR j:=0 TO data.leno-1
      lenfull:=lenfull+StrLen(pItem.odpw[j])+1	-> +'\n'
    ENDFOR
  ENDFOR

  WriteF('dīugoōź pliku : \d\n',lenfull)
  buffor:=New(lenfull)
  ptr:=buffor
  typek.typ:="MiKO"; 	typek.len:=lenfull-8;
  CopyMem(typek,ptr,8);	ptr:=ptr+8
  CopyMem('TEST',ptr,4);ptr:=ptr+4

  typek.typ:="DANE"; 	typek.len:=body-12-16	->-MiKO-DATA
  CopyMem(typek,ptr,8);	ptr:=ptr+8

  data.data.itemlen:=lenlist
  CopyMem(data.data,ptr,SIZEOF oDataMikoHead);	ptr:=ptr+(SIZEOF oDataMikoHead)

  typek.typ:="DEFI";	typek.len:=(data.lenp+data.leno)*8+16
  CopyMem(typek,ptr,8);	ptr:=ptr+8

  typek.typ:="PYTN";	typek.len:=data.lenp
  CopyMem(typek,ptr,8);	ptr:=ptr+8
  FOR j:=0 TO data.lenp-1
    typek.typ:=data.typtp[j];	typek.len:=data.lentp[j]
    CopyMem(typek,ptr,8);	ptr:=ptr+8
  ENDFOR

  typek.typ:="ODPW";	typek.len:=data.leno
  CopyMem(typek,ptr,8);	ptr:=ptr+8
  FOR j:=0 TO data.leno-1
    typek.typ:=data.typto[j];	typek.len:=data.lento[j]
    CopyMem(typek,ptr,8);	ptr:=ptr+8
  ENDFOR
  CopyMem('$VER:',ptr,5); ptr:=ptr+5
  CopyMem(data.ver,ptr,i:=StrLen(data.ver));	ptr:=ptr+i
  CopyMem('\n',ptr,1);	ptr := ptr+1
  ptr:=przepisz('QUES', data.ques, ptr)
  ptr:=przepisz('PICS', data.pics, ptr)
  ptr:=przepisz('SONG', data.song, ptr)
  ptr:=przepisz('SAMP', data.samp, ptr)
  ptr:=przepisz('ANIM', data.anim, ptr)
  ptr:=przepisz('REXX', data.rexx, ptr)
  ptr:=przepisz('ADOS', data.ados, ptr)
  ptr:=przepisz('SAYQ', data.sayq, ptr)
  ptr:=przepisz('SAYK', data.sayk, ptr)
  ptr:=przepisz('KOMG', data.komG, ptr)
  ptr:=przepisz('KOMC', data.komC, ptr)
  ptr:=przepisz('KOMB', data.komB, ptr)
  ptr:=przepisz('KOMg', data.komg, ptr)
  ptr:=przepisz('KOMc', data.komc, ptr)
  ptr:=przepisz('KOMb', data.komb, ptr)

  typek.typ:="BODY";	typek.len:=lenfull-body
  CopyMem(typek,ptr,8);	ptr:=ptr+8

  FOR i:=0 TO lenlist-1
    pItem:=list[i]

    typek.typ:="ITEM";	item:=ptr
    CopyMem(typek,ptr,8);	ptr:=ptr+8

    ptr:=przepisz('PICS', pItem.pics, ptr)
    ptr:=przepisz('SONG', pItem.song, ptr)
    ptr:=przepisz('SAMP', pItem.samp, ptr)
    ptr:=przepisz('ANIM', pItem.anim, ptr)
    ptr:=przepisz('REXX', pItem.rexx, ptr)
    ptr:=przepisz('ADOS', pItem.ados, ptr)
    ptr:=przepisz('KOMg', pItem.komg, ptr)
    ptr:=przepisz('KOMc', pItem.komc, ptr)
    ptr:=przepisz('KOMb', pItem.komb, ptr)

    typek.typ:="ITEM";	typek.len:=ptr-item-8
    CopyMem(typek,item,8);

    FOR j:=0 TO data.lenp-1
      CopyMem(pItem.pytn[j],ptr,len:=StrLen(pItem.pytn[j]));ptr:=ptr+len
      CopyMem('\n',ptr,1);	ptr := ptr+1
    ENDFOR
    FOR j:=0 TO data.leno-1
      CopyMem(pItem.odpw[j],ptr,len:=StrLen(pItem.odpw[j]));ptr:=ptr+len
      CopyMem('\n',ptr,1);	ptr := ptr+1
    ENDFOR

  ENDFOR

  IF (fh:=Open(msg.plik,NEWFILE))=NIL THEN Throw(ERR_OPEN,msg.plik)
  IF (Write(fh,buffor,lenfull)) <> lenfull THEN Throw(ERR_WRITE,msg.plik)
EXCEPT DO
  IF fh THEN Close(fh)
  IF buffor THEN Dispose(buffor)
  jaki_ERR()
ENDPROC

PROC przepisz(head,str:PTR TO CHAR, ptr)
DEF len
  IF str
    IF (len:=StrLen(str))
      CopyMem(head,ptr,4);
      ptr:=ptr+4
      CopyMem(str,ptr,len);
      ptr:=ptr+len
      CopyMem('\n',ptr,1);
      ptr := ptr+1
    ENDIF
  ENDIF
ENDPROC ptr
/*==================================================================*/

PROC main() HANDLE
DEF mkClass	= NIL:PTR TO iclass,
    miClass 	= NIL:PTR TO iclass,
    miObject	= NIL:PTR TO object
DEF s[256]:STRING, ptr

->DEF data:PTR TO miData

->  trapguru()
  IF (utilitybase:=OpenLibrary('utility.library', 37)) = NIL THEN Throw(ERR_LIB,'utility.library v.37')
  IF (mkClass := MakeClass(NIL, 'rootclass', NIL, SIZEOF mkData, NIL))=NIL THEN Throw(ERR_STR,'Nie mogė stworzyź classy "mikoclass"')
  installhook(mkClass.dispatcher, {mkDispatch})
->  AddClass(mkClass)
  IF (miClass := MakeClass( NIL, NIL, mkClass, SIZEOF miData, NIL))=NIL THEN Throw(ERR_STR,'Nie mogė stworzyź potomka classy "mikoclass"')
  installhook(miClass.dispatcher, {miDispatch})
/*
  typ:=	["CHBn", "CHBn", "CHBn"]
  var:=["TXTn"]
  data:=[[0,0],
	'Niesamowity plik z wnėtrza komputera',
  	NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL,
	1, 3,
	var,typ,
	[50]:LONG,
	[30, 30, 3]:LONG]:miData
*/
  IF (miObject := NewObjectA(miClass, NIL, [MIA_FILE, 'S:file', NIL]))=NIL THEN Throw(ERR_STR,'Nie mogė stworzyź objectu potomka classy "mikoclass"')
/*
  doMethodA(miObject,[MKM_NewAddItem,
	['work:obrazki/pikturek.ilbm',
	'work:music/melodyjka',
	NIL, NIL, NIL, NIL,
	'bardzo dobrze',
	'nieśle',
	'kipsko',
	['Mam nowe pytanie'],
	['jakie?',
	'nie wiem o co chodzi',
	'1']]:oItem])
*/
  doMethodA(miObject,[MKM_Write, NIL])
  doMethodA(miObject,[MIM_WriteFile, 'S:file1'])


EXCEPT DO
  IF miObject	THEN DisposeObject(miObject)
  IF miClass	THEN FreeClass(miClass)
->  IF mkClass	THEN RemoveClass(mkClass)  
  IF mkClass	THEN FreeClass(mkClass)  
  IF utilitybase THEN CloseLibrary(utilitybase)
  jaki_ERR()
WriteF('\e[1mkoniec \e[0m \n')
ENDPROC

/*-----------------------------------------------------------------------*/
PROC szukaj4char(poczatek:PTR TO CHAR, koniec, poszukiwanychar)
  IF poczatek=NIL THEN Raise("mem")
  WHILE poczatek < koniec
    IF StrCmp( poczatek, poszukiwanychar,4)
      RETURN poczatek
    ENDIF
    poczatek++
  ENDWHILE
  RETURN FALSE
ENDPROC

/*-----------------------------------------------------------------------*/
/*-----------------------------------------------------------------------*/
PROC readTo(mem:PTR TO CHAR,wzor,max)
DEF len_wzor, i=0, wynik
  IF wynik = NIL THEN RETURN FALSE
  len_wzor:=StrLen(wzor)
  IF len_wzor=0
    wynik:=String(StrLen(mem))
  ELSE
    WHILE (i++<=max) AND (StrCmp(mem+i-1, wzor, len_wzor)=FALSE)
    ENDWHILE
    wynik:=String(i-StrLen(wzor))
  ENDIF
  StrCopy(wynik,mem)
ENDPROC wynik

/*-----------------------------------------------------------------------*/