Subversion Repositories Kolibri OS

;workarea:    <- RTF_work

;  listptr dd savelist    0

;  szKeyword rb 31        4

;  szParameter rb 21      35

include 'rtftype.inc'

include 'rtfactn.inc'

read_next_block:

  inc  [cur_block]

read_block:

  mov  esi,I_END

  pusha

  mov  ecx,[cur_block]

  mov  ebx,fileinfo

  mov  eax,ecx

  shl  eax,7

  mov  [ebx+4],eax

;  mov  [ebx+12],esi

  mcall 58

if DEBUG_BLOCK eq 1

;  dps  'B='

;  dpd  ecx

;  dps  <13,10>

end if

  cmp  ecx,[max_block]

  je   .last

  mov  ebx,I_END+RTFSIZE

  jmp  .add

.last:

  mov  ebx,[tail]

;  dpd  ebx

.add:

;  dpd  ebx

  mov  [block_end],ebx

  popa

;  dpd  esi

;  dps  <13,10>

  ret

;

; %%Function: ecRtfParse

;

; Step 1:

; Isolate RTF keywords and send them to ecParseRtfKeyword;

; Push and pop state at the start and end of RTF groups;

; Send text to ecParseChar for further processing.

;

macro CopySave _src,_dest

{

    pusha

    mov  ecx,SIZE_save

    mov  esi,_src

    mov  edi,_dest

    rep  movsb

    popa

}

RtfParse:

 if BENCH eq 1

    mcall 26,9

    mov  [bench],eax

 end if

    mov  [RetroPtr],esi

    CopySave Chp,RetroSave

    push dword[Free+4]

    pop  dword[RetroXY]

    xor  eax,eax

    mov  [cur_block],eax

    mov  [RetroBlock],eax

    push [cGroup]

    pop  [RetroGroup]

    and  [mode],not RTF_BLIND

    mov  [listptr],save_stack

    mov  [fileinfo.size],128

;    test ebp,RTF_HELP

    test [mode],RTF_HELP

    jne  .noread

    call read_block

  .noread:

    mov  [RetroPtr],esi

  .nib2:

    mov  [nibble],2

    and  [b],al

  .getc:

    xor  eax,eax

    lods_block

    cmp  [cGroup],0

    jge  .ok1

    Return ecStackUnderflow

  .ok1:

    cmp  [ris],risBin

    jne  .nobin

    RetError ecParseChar

  .nobin:

    cmp  al,'{'

    jne  .nobr1

    RetError ecPushRtfState

  .nobr1:

    cmp  al,'}'

    jne  .nobr2

    RetError ecPopRtfState

  .nobr2:

    cmp  al,'\'

    jne  .noslash

    RetError ecParseRtfKeyword

  .noslash:

    cmp  al,0xd

    je   .getc

    cmp  al,0xa

    je   .getc

  .nouc:

    cmp  [ris],risNorm

    jne  .nonorm

    call ecParseChar

    cmp  eax,ecOutOfWindow

    je   .__ex

    test eax,eax

    je   .getc

    jmp  .__ex

  .nonorm:

    cmp  [ris],risHex

    je   .noassert

    Return ecAssertion

  .noassert:

    shl  [b],4

    isdigit al, .nodig

    sub  al,'0'

    add  [b],al

    jmp  .nibble

  .nodig:

    islower al, .nolow

    cmp  al,'a'

    jb   .inval

    cmp  al,'f'

    ja   .inval

    sub  al,'a'-10

    jmp  .nib0

  .inval:

  if INVALHEX eq 0

    jmp  .getc

  else

;    sub  esi,I_END+1

;    dpd  esi

;    movzx eax,al

;    dpd  eax

;    movzx eax,[b]

;    dpd  eax

    Return ecInvalidHex

  end if

  .nolow:

    cmp  al,'A'

    jb   .inval

    cmp  al,'F'

    ja   .inval

    sub  al,'A'-10

  .nib0:

    add  [b],al

  .nibble:

    dec  [nibble]

    cmp  [nibble],0

    jnz  .getc

    movzx eax,[b]

    mov  [ris],risNorm

    call ecParseChar

    test eax,eax

    jnz  .__ex

;    mov  [ris],risNorm

    jmp  .nib2

  .eof:

    xor  eax,eax

    cmp  eax,[cGroup]

    je   .__ex

    jg   .unbr

    Return ecStackUnderflow

  .unbr:

    mov  eax,ecUnmatchedBrace

  .__ex:

    ret

nibble db 2

b      db 0

RTF_maxlist dd ?

;

; %%Function: ecParseRtfKeyword

;

; Step 2:

; get a control word (and its associated value) and

; call ecTranslateKeyword to dispatch the control.

;

ecParseRtfKeyword:

; ch-al,bl-fParam, bh-fNeg

    mov  [ris],risNorm

    xor  eax,eax

    xor  ebx,ebx

    push edx

    mov  [szKeyword],al

    mov  [szParameter],al

    lods_block

    isalpha al,.ctrl

    jmp  .alph

  .ctrl:

    push esi

    mov  esi,szKeyword

    inc  byte[esi]

    mov  [esi+1],al

    mov  eax,ebx

    xor  ebx,ebx

    call ecTranslateKeyword

    pop  esi

    jmp  .__ex

  .alph:

    push edi

    mov  edi,szKeyword+1

  .loop1:

    stosb

    inc  [szKeyword]

    lods_block

    isalpha al,.outloop1

    jmp  .loop1

  .outloop1:

    pop  edi

    cmp  al,'-'

    jne  .noneg

    not  bh

    lods_block

  .noneg:

    isdigit al,.nodig

    not  bl

    push edi

    mov  edi,szParameter+1

  .loop2:

    stosb

    inc  [szParameter]

    lods_block

    isdigit al,.outloop2

    jmp  .loop2

  .outloop2:

    pop  edi

    push eax esi

    mov  esi,szParameter

    atoi

    pop  esi

    mov  edx,eax

    pop  eax

    mov  [lParam],edx

    test bh,bh

    jz   .nodig

    neg  edx

  .nodig:

    cmp  al,' '

    je   .space

    cmp  esi,I_END

    jne  .ok_block

    dec  [cur_block]

    call read_block

    mov  esi,[block_end]

  .ok_block:

    dec  esi

  .space:

    mov eax,ebx

    mov ebx,edx

    push esi

    mov  esi,szKeyword

    call ecTranslateKeyword

    pop  esi

  .__ex:

    pop  edx

    ret

;

; %%Function: ecParseChar

;

; Route the character to the appropriate destination stream.

;

ecParseChar:

;in: ch-al, esi->rtf

   cmp  [ris],risBin

   jne  .nobin

   dec  [cbBin]

   cmp  [cbBin],0

   jg   .nobin

   mov  [ris],risNorm

 .nobin:

   cmp  [rds],rdsColor

   jne  .nodelim

   cmp  al,';'

   jne  .non

   mov  eax,[colorptr]

   cmp  eax,ct_end-4

   jae  .non

   add  [colorptr],4

   jmp  .non

 .nodelim:

   cmp  [rds],rdsSkip

   je  .non

   cmp  [rds],rdsNorm

   je   ecPrintChar

;   ret

 .non:

   mov  eax,ecOK

   ret

macro PrintTrap _char

{

local .notrap

    cmp  byte[esi],_char

    jne  .notrap

    sub  esi,I_END

    dps  'Trapped at '

    dpd  esi

    dps  <13,10>

    ud2

  .notrap:

}

;

; %%Function: ecPrintChar

;

; Send a character to the output file.

;

ecPrintChar:

; in:ch-al, esi - rtf pointer

;    stosb

;    jmp  .nowrap

    mov  ebp,[mode]

    cmp  al,0xa

    jne   .nopar

;    and  ebp,not RTF_NO1STLINE

    and  [mode],not RTF_NO1STLINE

    jmp  .par

  .nopar:

    cmp  al,0x9

    jne  .notab

    add  word[Free+6],CHARW*3

    jmp  .chkwrap

  .notab:

    xor  ebx,ebx

  if ~ RENDER eq FREE

    cmp  word[Free+4],TOP

    jl   .nodraw

  end if

    ansi2oem

    mov  [char],al

;    PrintTrap '/'

    pusha

    xor   eax,eax

;    test  [mode],RTF_BLIND

    test  ebp,RTF_BLIND

    je   .rend

;    test  [mode],RTF_COLORLESS

    test  ebp,RTF_COLORLESS

    jz    .setcolor

    mov   ecx,DEFCOLOR

    jmp   .rend

  .setcolor:

    movzx ecx,byte[Chp+3]

    mov   ecx,[colortbl+ecx*4]

  .rend:

  if RENDER eq FREE

    mov   ebx,Free

    mov   dword[ebx+32],eax

    mov   [ebx+28],ecx

;    test  [mode], RTF_BOTTOM

    test  ebp, RTF_BOTTOM

    jne   .nodraw2

    cmp  word[Free+4],TOP

    jl   .nodraw2

    cmp   byte[Chp],fTrue

    jne   .nobold

    or    dword[ebx+32],BGI_BOLD

  .nobold:

;    test  [mode], RTF_BLIND

    test  ebp, RTF_BLIND

    jne   .freet

  .nodraw2:

    or    dword[ebx+32],BGI_NODRAW

  .freet:

    BGIfont_Freetext

    mov  [Free+4],eax

    test [mode],RTF_BLIND

;    jmp  .nohei

    jne  .nohei

    fild word[BGIheight]

    fmul dword[Free+12]

;    fistp word[curheight]

    fistp word[maxheight]

;    movzx eax,[curheight]

;    dpd  eax

;    cmp  ax,[maxheight]

;    jae  .nohei

;    mov  [maxheight],ax

;    dps 'M'

;    dpd  eax

;    dps <13,10>

  .nohei:

  else

    and   ecx,0xffffff

    mov   ebx,[Free+4]

    mov   edx,char

    mov   esi,1

  end if

  if RENDER eq BGI

    add   ecx,0x44000000

    cmp   byte[Chp],fTrue

    jne   .nobold

    or    esi,BGI_BOLD

  .nobold:

    test  ebp,RTF_BLIND

;    test  [mode],RTF_BLIND

    jne    .freet

    or    esi,BGI_NODRAW

  .freet:

    BGIfont_Outtext

    mov   [Free+4],eax

  end if

  if RENDER eq PIX

;    test  [mode],RTF_TOEOF

;    jne   .blind

;    test  [mode],RTF_BOTTOM

    test  ebp,RTF_BOTTOM

    jne   .nobold

  .blind:

;    test  [mode],RTF_BLIND

    test  ebp,RTF_BLIND

    je    .nobold

    mcall 4

    cmp   byte[Chp],fTrue

    jne   .nobold

    add   ebx,1 shl 16

    mcall

  .nobold:

  end if

    popa

  .nodraw:

  if  RENDER eq PIX

    add  word[Free+6],CHARW

  end if

    movsx eax,[pitch]

    add  word[Free+6],ax

  .chkwrap:

    mov  eax,dword[prcinfo+42]

    cmp  ax,word[Free+6]

    ja   .nowrap

;    or   ebp,RTF_NO1STLINE

    or   [mode],RTF_NO1STLINE

  .par:

    xor  [mode],RTF_BLIND

;    not  [blind]

    test [mode] ,RTF_BLIND

    je   .makewrap

    ; [blind]=false

    movzx eax,word[Free+6]

    sub  ax,word[RetroXY+2]

    push dword[RetroXY]

    pop  dword[Free+4]

    mov  [mark],0xff0000

    test [mode],RTF_ALIGNLESS

    jnz  .letsdraw

    cmp  byte[Pap+12],justR

    jb   .letsdraw

    mov  [mark],0xff

    mov  ebx,dword[prcinfo+42] ; wnd width

    sub  ebx,eax

    cmp  byte[Pap+12],justC

    jne  .nocenter

    shr  ebx,1

    mov  [mark],0x00ff00

  .nocenter:

    mov  word[Free+6],bx

  .letsdraw:

;    test [mode],RTF_NO1STLINE

;    jnz  .no1st

;    add  word[Free+6],60

  .no1st:

  if STEPBYSTEP eq 1

;    movzx eax,[mode]

;    dph  eax

;    test [mode],RTF_NO1STLINE

;    jnz  .no1st

;    mcall 4,[RetroXY],[mark],sym,1

;    dps  '1st '

;  .no1st:

    dps  <'false ',13,10>

;    dpd  eax

;    dpd  ebx

  end if

  if SHOWALIGN eq 1

    mcall 4,[RetroXY],[mark],sym,1

  end if

  if STEPBYSTEP eq 1

    mcall 10

    mcall 2

  end if

    mov  eax,[RetroBlock]

    cmp  eax,[cur_block]

    je   .norblock

    mov  [cur_block],eax

    call read_block

  .norblock:

    mov  esi,[RetroPtr]

    push [RetroGroup]

    pop  [cGroup]

    CopySave RetroSave,Chp

    jmp  .nowrap

  .makewrap:       ; second pass preparing

    ; [blind]=true

  if STEPBYSTEP eq 1

    dps  'true '

    mcall 10

    mcall 2

  end if

    mov  word[Free+6],LMARGIN

  if RENDER eq FREE

    fld [line_space]

    fimul [maxheight]

    fistp [maxheight]

    movzx eax,[maxheight]

    add  word[Free+4],ax

;    and  [maxheight],0

;    add  word[Free+4],CHARH

  else

    mov  eax,CHARH

    add  word[Free+4],ax

  end if

    test [mode],RTF_TOEOF

    je   .nohdoc

    add  [HDoc],eax

    inc  [line_count]

  .nohdoc:

    test [mode],RTF_BOTTOM

    jne  .text

;    dps  '1'

    mov  ebx,dword[prcinfo+46]

    cmp  bx,word[Free+4]

    jge   .text

    or   [mode],RTF_BOTTOM

    dps  <'btm',13,10>

    test [mode],RTF_TOEOF

    jne  .text

    mov  eax,ecOutOfWindow

    ret

;  end if

  .text:

    push dword[Free+4]

    pop  dword[RetroXY]

    mov  word[RetroXY+2],LMARGIN

    mov  [RetroPtr],esi

    push [cur_block]

    pop  [RetroBlock]

    CopySave Chp,RetroSave

    push [cGroup]

    pop  [RetroGroup]

;  if STEPBYSTEP eq 1

;    mcall 10

;    mcall 2

;  end if

  .nowrap:

    mov  eax,ecOK

    ret

mark dd ?

sym db 0x10

line_space dd 1.6

;

; %%Function: ecPushRtfState

;

; Save relevant info on a linked list of SAVE structures.

;

ecPushRtfState:

    pusha

    mov  edi,[listptr]

    mov  eax,edi

    mov  ecx,SIZE_save

    add  eax,ecx

    cmp  eax,save_limit

    jb   .malloc

    Return ecStackOverflow

  .malloc:

    mov  esi,Chp

    rep  movsb

    mov  [listptr],edi

    mov  [ris],risNorm

    inc  [cGroup]

    xor  eax,eax

    Epilog

; %%Function: ecPopRtfState

;

; If we're ending a destination (that is, the destination is changing),

; call ecEndGroupAction.

; Always restore relevant info from the top of the SAVE list.

ecPopRtfState:

    pusha

    mov  esi,[listptr]

    cmp  esi,save_stack

    ja  .okpop

    Return ecStackUnderflow

  .okpop:

    movzx eax,[rds]

    cmp  al,[esi-2]

    je   .noega

    RetError ecEndGroupAction, .noega

  .noega:

    mov  ecx,SIZE_save

    sub  esi,ecx

    mov  [listptr],esi

    mov  edi,Chp

    rep  movsb

    dec  [cGroup]

    xor  eax,eax

    Epilog

ansitbl:

    db 0xaa,0xba,0xbf,0xaf

    db 0xa7,0xa8,0xa1,0xab,0xb0,0xb2,0xb3,0xb6,0xb7,0xb8,0xb9

    db 0xa2,0xbb,0x93,0x94,0x85

oematbl:

 if RENDER eq PIX

    db 0xf2,0xf3,0xf5,0xf4

 else

    db 0x85,0xa5,0x69,0x49

 end if

    db 0x15,0xf0,0xf6,0x22,0x1d,0x49,0x69,0x14,0x1c,0xf1,0x23

    db 0xf7,0x22,0x22,0x22,0x16

uctbl:

    dw 0x451

oemutbl:

    db 0xb8