{-------------------------------------------------------------}
{
{    Webvox - Módulo de leitura interativa
{
{    Autor: Jose' Antonio Borges
{
{    Em 14/05/98
{
{-------------------------------------------------------------}

unit webleit;
interface

uses winProcs, winDos, winTypes, shellApi,
     dvcrt, strings, dvWin, winsock, dvexec, dvdde,
     webVars, webConf, webTraz, webMsg, webComp, webCabec, webUrl;

procedure lerPagina;

implementation

var
    cmd, sentenca, nome: string;
    centrando: integer;
    emTabela: boolean;
    paginaATrazer: string;
    metodoAExecutar: char;
    coluna: integer;
    nt: integer;
    emBold, emItalico, emRefer: boolean;
    nomeRef: string;
    passoAPasso: boolean;
    opinput: char;
    lido1, lido2: char;
    preLido: boolean;

procedure linkAnterior (var nt: integer);   forward;

{-------------------------------------------------------------}
{            extrai um comando de um tag da pagina
{    Esta rotina retorna as variaveis globais cmd e sentenca
{-------------------------------------------------------------}

procedure extraiCmd (nt: integer);
var p: integer;
begin
    if nt > ntags then
        begin
            cmd := '</HTML>';
            sentenca := '';
            exit;
        end;

    p := pos ('|', tagsPagina^[nt]^);
    cmd := copy (tagsPagina^[nt]^, 1, p-1);
    sentenca := copy (tagsPagina^[nt]^, p+1, length(tagsPagina^[nt]^)-p);
end;

{-------------------------------------------------------------}
{      extrai (e remove) o primeiro parâmetro da sentença
{-------------------------------------------------------------}

function extraiSentenca: string;
var p: integer;
begin
    p := pos ('|', sentenca);
    if p > 0 then
         begin
             extraiSentenca := copy (sentenca, 1, p-1);
             delete (sentenca, 1, p);
         end
    else
        begin
            extraiSentenca := sentenca;
            sentenca := '';
        end;
end;

{-------------------------------------------------------------}
{       extrai um comando de um tag do formulario editado
{    Esta rotina retorna as variaveis globais cmd e sentenca
{-------------------------------------------------------------}

procedure extraiCmdForm (ntForm: integer);
var p: integer;
begin
    p := pos ('|', tagsForms^[ntForm]^);
    cmd := copy (tagsForms^[ntForm]^, 1, p-1);
    sentenca := copy (tagsForms^[ntForm]^, p+1, length(tagsForms^[ntForm]^)-p);
end;

{-------------------------------------------------------------}
{                     edita uma senha
{-------------------------------------------------------------}

function editaSenha (var s: string): char;
var c: char;
    i: integer;
label sai;
begin
    gotoxy (1, wherey);
    for i := 1 to length (s) do write ('*');
    s := '';

    repeat
        gotoxy (length(s) + 1, wherey);
        c := readkey;
        sintclek;
        if (c = #$0) then
            begin
                c := readkey ;
                goto sai;
            end;
        if (c = ESC) or (c = ENTER) then goto sai;
        if c = BS then
            delete (s, length(s), 1)
        else
            s := s + c;
    until false;

sai:
    editaSenha := c;
end;

{-------------------------------------------------------------}
{                    da saída numa linha
{-------------------------------------------------------------}

procedure sailinha (s: string);
var s2, s3: string;
    i, nbr: integer;

begin
    if emItalico then
        textColor (CYAN)
    else
    if emBold then
        textColor (YELLOW)
    else
    if emRefer then
        textColor (GREEN)
    else
        textColor (LIGHTGRAY);

    if (centrando > 0) and (wherex = 1) then
        begin
            while (s <> '') and (s[1] = ' ') do
                    delete (s, 1, 1);
                nbr := (72 - length (s)) div 2;
                for i := 1 to nbr do
                     s := ' ' + s;

            write (s);
            textColor (LIGHTGRAY);
            if emPortug then
                sintetiza (s)
            else
                begin
                    while sintFalando do;
                    enviaStringDDE ('MONOLOG', 'TALK', '', s);
                end;
            exit;
        end;

    while (s <> '') and (s[1] = ' ') do
        delete (s, 1, 1);
    if wherex <> 1 then
        s := ' ' + s;

    s2 := '';
    s3 := s;
    while s <> '' do
        begin
            repeat
                 s2 := s2 + s[1];
                 delete (s, 1, 1);
            until (s = '') or (s2 [length(s2)] = ' ');

            if wherex + length (s2) > 79 then
                 begin
                     writeln;
                     if (s2 <> '') and (s2[1] = ' ') then delete (s2, 1, 1);
                 end;

            write (s2);
            s2 := '';

            while (s <> '') and (s[1] = ' ') do
                delete (s, 1, 1);
        end;

    textColor (LIGHTGRAY);
    if not keypressed then
        if emPortug then
            sintetiza (s3)
        else
            begin
                while sintFalando do;
                enviaStringDDE (servDDE, 'TALK', '', s3);
            end;

end;

{-------------------------------------------------------------}
{      desmarca outros botoes de radio com mesmo nome
{-------------------------------------------------------------}

procedure marcaRadio (nt: integer; nome: string);
var
    ponteiro, tipo: string;
    i, erro, indPreenc: integer;
label ok1, ok2;

    procedure desmarcaInput;
    begin
        if cmd = 'INPUT' then
            begin
                ponteiro  := extraiSentenca;
                val (ponteiro, indPreenc, erro);
                tipo      := extraiSentenca;
                if tipo = 'RADIO' then
                    if extraiSentenca = nome then
                        tagsForms^[indPreenc+1]^[8] := 'N';
            end;
    end;

begin
    for i := nt-1 downto 1 do
        begin
            extraiCmd (i);
            if cmd = 'FORM' then goto ok1;
            desmarcaInput;
        end;

ok1:
    for i := nt+1 to nTags do
        begin
            extraiCmd (i);
            if cmd = '/FORM' then goto ok2;
            desmarcaInput;
        end;

ok2:
    extraiCmd (nt);
    ponteiro  := extraiSentenca;
    val (ponteiro, indPreenc, erro);

    tagsForms^[indPreenc+1]^[8] := 'S';
end;

{-------------------------------------------------------------}
{                   trata o comando INPUT
{-------------------------------------------------------------}

procedure trataInput;
var ponteiro, tipo, nome, valor, tamanho, tamVisual,
    nomRef, valorDefault: string;
    ativado: boolean;
    tam, tamVisu, erro, i, indPreenc: integer;
    salvaCor: word;
    salva, inicForm: integer;
begin
    passoAPasso := true;
    ponteiro  := extraiSentenca;
    val (ponteiro, indPreenc, erro);

    tipo      := extraiSentenca;
    nome      := extraiSentenca;
    tamanho   := extraiSentenca;
    val (tamanho, tam, i);
    tamVisual := extraiSentenca;
    val (tamVisual, tamVisu, i);
    if tamVisu >= 80 then tamVisu := 79;
    nomRef    := extraiSentenca;

    valorDefault := copy (tagsForms^[indPreenc+1]^, 10, 255);

    ativado := copy (tagsForms^[indPreenc+1]^, 8, 1) = 'S';
    valor := copy (tagsForms^[indPreenc+1]^, 10, 255);

    if wherex <> 1 then
        writeln;

    if tipo = 'RESET' then
        begin
            if valor <> '' then sintWriteln (valor);
            textBackground (RED);
            mensagem ('WBINRSET', 0);   {'Botão para limpar formulario, aperte 'S' para limpar'}
            textBackground (BLACK);
            sintLeTecla (lido1, lido2);
            writeln;

            if (lido1 = #0) then
                begin
                    prelido := true;
                    exit;
                end;

            if upcase (lido1) <> 'S' then
                begin
                    prelido := true;
                    if upcase(lido1) in [TAB, 'A'..'Z'] then
                        lido1 := ' ';
                    exit;
                end;

            while (nt > 1) and (copy (tagsPagina^[nt]^, 1, 4) <> 'FORM') do
                nt := nt - 1;
            inicForm := nt;

            while (nt <= ntags) and (copy (tagsPagina^[nt]^, 1, 5) <> '/FORM') do
                begin
                    extraiCmd (nt);
                    if (cmd = 'INPUT2') or (cmd = 'TEXTAREA2') then
                        begin
                            ponteiro  := extraiSentenca;
                            val (ponteiro, indPreenc, erro);
                            freemem (tagsForms^[indPreenc], 1+length(tagsForms^[indPreenc]^));
                            sentenca := cmd + '|' + sentenca;
                            getmem (tagsForms^[indPreenc], 1+length (sentenca));
                            tagsForms^[indPreenc]^ := sentenca;
                        end;
                    nt := nt + 1;
                end;

            nt := inicForm;
            mensagem ('WBRESTAD', 1);  {'Formulário recriado'}
        end

    else
    if tipo = 'HIDDEN' then
        prelido := true    {nada faz}

    else
    if tipo = 'TEXT' then
        begin
            textBackground (RED);
            mensagem ('WBINTEXT', 0);     {'Campo de entrada, pode editar, valor atual'}
            textBackground (BLACK);
            writeln;

            if valor = '' then
                begin
                   sintClek; sintClek;
                end;

            write (copy (valor, 1, tamVisu));
            sintetiza (valor);
            gotoxy (1, wherey);

            lido2 := sintEditaCampo (valor, 1, wherey, tam, tamVisu, true);
            writeln;
            if lido2 <> ESC then
                begin
                    valor := copy (tagsForms^[indPreenc+1]^, 1, 9) + valor;
                    freemem (tagsForms^[indPreenc+1], 1+length(tagsForms^[indPreenc+1]^));
                    getmem (tagsForms^[indPreenc+1], 1+length (valor));
                    tagsForms^[indPreenc+1]^ := valor;
                end;

            prelido := true;
            lido1 := #$0;
            if (lido2 = TAB) or (lido2 = ENTER) or (lido2 = ESC) then
                lido1 := ' ';
        end

    else
    if tipo = 'PASSWORD' then
        begin
            textBackground (RED);
            mensagem ('WBINPASS', 0);     {'Campo de senha, pode digitar'}
            textBackground (BLACK);
            writeln;

            salvaCor := textAttr;
            textColor (black);
            lido2 := editaSenha (valor);
            textAttr := salvaCor;

            if lido2 <> ESC then
                begin
                    valor := copy (tagsForms^[indPreenc+1]^, 1, 9) + valor;
                    freemem (tagsForms^[indPreenc+1], 1+length(tagsForms^[indPreenc+1]^));
                    getmem (tagsForms^[indPreenc+1], 1+length (valor));
                    tagsForms^[indPreenc+1]^ := valor;
                end;

            prelido := true;
            lido1 := #$0;
            if (lido2 = TAB) or (lido2 = ENTER) or (lido2 = ESC) then
                lido1 := ' ';
        end

    else
    if tipo = 'CHECKBOX' then
        begin
            textBackground (RED);
            mensagem ('WBCHKBOX', 0);     {'Ítem de seleção: '}
            textBackground (BLACK);
            clreol;

            salva := nt;
            repeat
                 nt := nt + 1;
                 extraiCmd (nt);
            until (cmd = 'T') or (cmd = '/HTML');
            saiLinha (sentenca);
            nt := salva;

            if ativado then
                 mensagem ('WBLIGADO', 0)      {'ligado.'}
            else
                 mensagem ('WBDESLIG', 0);     {'desligado.'}

            mensagem ('WBPMARCA', 0);   {'Deixa essa marca ? '}
            sintLeTecla (lido1, lido2);
            writeln;

            if upcase(lido1) = 'S' then
                 begin
                     ativado := true;
                     tagsForms^[indPreenc+1]^[8] := 'S'
                 end
            else
            if upcase(lido1) = 'N' then
                begin
                    ativado := false;
                    tagsForms^[indPreenc+1]^[8] := 'N';
                end;

            prelido := true;
            if upcase(lido1) in [TAB, 'A'..'Z'] then
                begin
                    repeat
                         nt := nt + 1;
                         extraiCmd (nt);
                    until cmd  = 'T';
                    lido1 := ' ';
                end;
        end

    else
    if tipo = 'RADIO' then
        begin
            textBackground (RED);
            if tipo = 'RADIO' then
                mensagem ('WBRADIO', 0);      {'Ítem de seleção exclusiva: '}
            textBackground (BLACK);
            clreol;

            salva := nt;
            repeat
                 nt := nt + 1;
                 extraiCmd (nt);
            until (cmd = 'T') or (cmd = '/HTML');
            saiLinha (sentenca);
            nt := salva;

            if ativado then
                mensagem ('WBLIGADO', 0)      {'ligado.'}
            else
                begin
                    mensagem ('WBDESLIG', 0); {'desligado.'}
                    mensagem ('WBLIGA', 0);   {'Devo ligar ? '}
                    sintLeTecla (lido1, lido2);
                    writeln;
                    if upcase(lido1) = 'S' then
                         begin
                             ativado := true;
                             marcaRadio (nt, nome);
                         end;
                end;

            prelido := true;
            if upcase(lido1) in [TAB, 'A'..'Z'] then
                begin
                    repeat
                         nt := nt + 1;
                         extraiCmd (nt);
                    until cmd  = 'T';
                    lido1 := ' ';
                end;
        end

    else
    if (tipo = 'SUBMIT') or (tipo = 'IMAGE') then
        begin
            if valor <> '' then sintWriteln (valor);
            textBackground (RED);
            mensagem ('WBINSUBM', 0);   {'Botão de envio, aperte 'S' para submeter'}
            textBackground (BLACK);
            sintLeTecla (lido1, lido2);
            writeln;
            if upcase (lido1) = 'S' then
                begin
                    submeteu := true;
                    mensagem ('WMSUBMET', 1);   {'Submetendo formulário'}
                end;

            prelido := true;
            if upcase(lido1) in [TAB, 'A'..'Z'] then
                lido1 := ' ';
        end

    else
    ;

    if (lido1 <> BS) and (not (lido1 = #$0) and (lido2 = PGUP)) then
         nt := nt + 1;   {pula input2}
end;

{-------------------------------------------------------------}
{                     trata selecoes
{-------------------------------------------------------------}

procedure trataSelect;
var
    i, numOp: integer;
    indForm: array [1..300] of integer;
    tabOp: array [1..300] of ^string;
    selec: array [1..300] of boolean;
    selecAlguem: boolean;
    lixo, nome, tamanho, ponteiro: string;
    multiplo: boolean;
    ind, indPreenc, erro: integer;
    p: pointer;
    salva: integer;
label sai;
begin
    if wherex <> 1 then writeln;
    textBackground (RED);
    mensagem ('WBSELSET', 0);    {Selecione a opção com as setas depois ENTER ou ESC}
    textBackground (BLACK);
    writeln;

    salva := nt;
    extraiCmd (nt);
    ponteiro := extraiSentenca;
    nome := extraiSentenca;
    tamanho := extraiSentenca;
    multiplo := extraiSentenca = 'MULTIPLE';
    if multiplo then
        mensagem ('WBSEMULT', 1);   {Você pode marcar mais de uma seleção}

    numOp := 0;
    selecAlguem := false;
    repeat
        nt := nt + 1;
        extraiCmd (nt);

        if cmd = 'OPTION' then
            begin
                ponteiro  := extraiSentenca;
                val (ponteiro, indPreenc, erro);
                sentenca := tagsForms^[indPreenc]^;
                numOp := numOp + 1;
                {--ignora cmd--}  extraiSentenca;
                lixo := extraiSentenca;

                selec[numOp] := false;
                if lixo = 'SELECTED' then
                    begin
                        selec[numOp] := true;
                        selecAlguem := true;
                    end;
                new (tabOp[numOp]);
                tabOp[numOp]^ := extraiSentenca;
                indForm [numOp] := indPreenc;
            end;

    until (cmd = '/SELECT') or (nt >= ntags);

    if not selecAlguem then
        selec[1] := true;

    ind := 0;
    repeat
        lido1 := readkey;

        if lido1 = ENTER then
            if (ind > 0) and (ind <= numOp) then
                begin
                    if not multiplo then
                         for i := 1 to numOp do selec[i] := false;
                    selec [ind] := not selec [ind];
                    if not selec [ind] then
                        mensagem ('WBDMARK', 1);  {' desmarcado'}
                end;

        lido2 := #$0;
        if lido1 = #$0 then
            begin
                lido2 := readkey;
                case lido2 of
                    CIMA: begin
                              if ind > 0 then ind := ind - 1;
                          end;
                    BAIX: begin
                              if ind <= numOp then ind := ind + 1;
                          end;
                    PGUP: begin
                              nt := salva;
                              goto sai;
                          end;
                else
                    goto sai;
                end;
            end;

        if (lido1 <> ESC) and (lido1 <> TAB) then
             begin
                if (ind > 0) and (ind <= numOp) then
                    begin
                        gotoxy (1, wherey);
                        sintWrite (tabOp [ind]^);
                        if selec [ind] then
                            mensagem ('WBMARK', 0);  {' marcado'}
                        writeln;
                    end
                else
                    sintbip;
             end;

    until (lido1 = ESC) or (lido1 = TAB) or (lido1 = BS);

sai:
    for ind := 1 to numOp do
        begin
            dispose (tabOp[ind]);
            sentenca := tagsForms^[indForm [ind]]^;
            freeMem (tagsForms^[indForm [ind]], 1+length(tagsForms^[indForm [ind]]^));
            delete (sentenca, 1, 7);
            while sentenca[1] <> '|' do
                delete (sentenca, 1, 1);
            if selec [ind] then
                sentenca := 'OPTION|SELECTED' + sentenca
            else
                sentenca := 'OPTION|' + sentenca;
            getMem (tagsForms^[indForm [ind]], 1+length (sentenca));
            tagsForms^[indForm [ind]]^ := sentenca;
        end;

    preLido := true;
    if lido1 = BS then  nt := salva;
    if lido1 = ESC then lido1 := ' ';
end;

{-------------------------------------------------------------}
{                 trata o comando text area
{-------------------------------------------------------------}

procedure trataTextArea (descendo: boolean);
var
    s, nome, ponteiro: string;
    linhas, colunas: integer;
    posTxt, indOpcoes, erro: integer;
    i: integer;

    {-------------------------------------------------------------}

    function extraiTextArea (ind: integer): string;
    begin
        extraiCmdForm (ind);
        extraiTextArea := sentenca;
    end;

    {-------------------------------------------------------------}

    procedure substituiTextArea (ind: integer; novaCadeia: string);
    begin
        sentenca := tagsForms^[ind]^;
        freeMem (tagsForms^[ind], 1+length(tagsForms^[ind]^));
        delete (sentenca, pos('|', sentenca)+1, 999);
        sentenca := sentenca + novaCadeia;
        getmem (tagsForms^[ind], 1+length (sentenca));
        tagsForms^[ind]^ := sentenca;
    end;

    {-------------------------------------------------------------}

label fim;
begin
    textBackground (RED);
    mensagem ('WBCAMPOD', 0);   {'Campo de digitação, tecle ENTER para editar '}
    textBackground (BLACK);
    lido2 := #$0;
    sintLeTecla (lido1, lido2);
    writeln;

    if lido1 <> ENTER then goto fim;

    while (nt <> 1) and (cmd <> 'TEXTAREA') do
        begin
            nt := nt - 1;     {posiciona no início do comando}
            extraiCmd (nt);
        end;
    if nt = 1 then exit;

    ponteiro := extraiSentenca;
    val (ponteiro, indOpcoes, erro);
    nome := extraiSentenca;
    s := extraiSentenca;
    val (s, colunas, erro);
    s := extraiSentenca;
    val (s, linhas, erro);

    mensagem ('WBPODEDI', 1);   {'Pode editar, use ESC para sair'}

    posTxt := 1;
    repeat
         s := extraiTextArea (indOpcoes+posTxt);
         sintetiza (s);
         lido1 := #$0;
         lido2 := sintEditaCampo (s, 1, wherey, colunas, 80, true);
         substituiTextArea (indOpcoes+posTxt, s);
         case lido2 of
              CIMA:  if posTxt > 1 then
                         begin
                             posTxt := posTxt - 1;
                             gotoxy (1, wherey-1);
                         end
                     else
                         sintBip;
              ENTER,
              BAIX:  if posTxt < linhas then
                         begin
                             posTxt := posTxt + 1;
                             writeln;
                         end
                     else
                         sintBip;
              F7:    begin
                         gotoxy (1, wherex);
                         mensagem ('WBLINREM', 0);   {Linha removida}
                         delLine;
                         for i := posTxt to linhas-1 do
                             begin
                                 s := extraiTextArea (indOpcoes+i+1);
                                 substituiTextArea (indOpcoes+i, s);
                             end;
                         substituiTextArea (indOpcoes+linhas, '');
                     end;
              PGUP:  ;
              TAB:  lido2 := ESC;

         end;
    until lido2 = ESC;

    for i := posTxt to linhas do
        writeln;
    mensagem ('WBOK', 1);

    lido1 := ' ';

fim:
    extraiCmd (nt);
    if lido2 = PGUP then lido1 := BS;
    if (lido1 = BS) or (lido2 = CIMA) then
        begin
            while (nt > 1) and (cmd <> 'TEXTAREA') do
                begin
                    nt := nt - 1;
                    extraiCmd (nt);
                end;
        end
    else
        begin
            while (nt < ntags) and (cmd <> '/TEXTAREA') do
                begin
                    nt := nt + 1;
                    extraiCmd (nt);
                end;
        end;

    preLido := true;
end;

{-------------------------------------------------------------}
{              pega trecho final de um http
{-------------------------------------------------------------}

function trechoFinal (sentenca: string): string;
var i: integer;
begin
    trechoFinal := sentenca;
    for i := length (sentenca) downto 1 do
        if sentenca [i] = '/' then
            begin
                trechoFinal := copy (sentenca, i+1, length(sentenca)-i);
                exit;
            end;
end;

{-------------------------------------------------------------}
{           elimina alguns comandos em modo texto
{-------------------------------------------------------------}

procedure trocasModoTexto (var cmd: string);
begin
    if (cmd = 'IMG') or (cmd = 'MAP') or (cmd = '/MAP') or (cmd = 'AREA HREF') then
        cmd := 'BR'
    else

    if (cmd = 'INPUT') or (cmd = 'INPUT2') or
       (cmd = 'TEXTAREA') or (cmd = 'TEXTAREA2') or (cmd = '/TEXTAREA') or
       (cmd = 'SELECT') or (cmd = '/SELECT') then
        cmd := 'IGNORE';
end;

{-------------------------------------------------------------}
{                  interpreta os tags HTML
{-------------------------------------------------------------}

procedure processaLinha;
var
    p: integer;
    s: string;
label fazInput;
begin
    if modoFala = 'T' then
        trocasModoTexto (cmd)
    else
        somTag (cmd);

    if cmd = 'T' then
        saiLinha (sentenca)

    else
    if cmd = 'TITLE' then
        textBackground (BLUE)

    else
    if cmd = '/TITLE' then
        begin
            textBackground (BLACK);
            writeln; writeln;
        end

    else
    if cmd = 'CENTER' then
        centrando := centrando + 1

    else
    if cmd = '/CENTER' then
        begin
            if centrando > 0 then centrando := centrando - 1;
        end

    else
    if (cmd = 'BR') or (cmd = 'DIV') then
        writeln

    else
    if (cmd = 'P')  or
       (cmd = 'H1') or (cmd = 'H2') or (cmd = 'H3') or
       (cmd = 'H4') or (cmd = 'H5') or (cmd = 'H6') then
        begin
            writeln; writeln;
            if not keypressed then
                begin
                    while sintFalando do;
                    delay (500);
                end;
        end

    else
    if (cmd = 'B') then
        emBold := true

    else
    if (cmd = '/B') then
        emBold := false

    else
    if (cmd = 'I') then
        emItalico := true

    else
    if (cmd = '/I') then
        emItalico := false

    else
    if cmd = 'HR' then
        begin
            if wherex <> 1 then writeln;
            writeln ('----------------------------------------------------------------');
            sintclek;  sintclek; sintclek;  sintclek;
        end

    else
    if (cmd = 'PRE') or (cmd = '/PRE') then
        begin
            if wherex <> 1 then writeln;
        end

    else
    if cmd = 'TABLE' then
        begin
            if not keypressed then delay (300);
            emTabela := true;
            coluna := 1;
            writeln;
        end
    else

    if cmd = '/TABLE' then
        begin
            if wherex <> 1 then writeln;
            {writeln;}
            emTabela := false;
        end

    else
    if cmd = '/CAPTION' then
         begin
             writeln; {writeln;}
         end

    else
    if (cmd = 'TH') or (cmd = 'TD') then
        begin
            while wherex > coluna do
                coluna := coluna + 8;
            while coluna > wherex do write (' ');
            coluna := coluna + 8;
        end

    else
    if (cmd = '/TH') or (cmd = '/TD')  then
        begin
            coluna := coluna - 8;
            if coluna < 1 then coluna := 1;
            if coluna < wherex then writeln;
            while coluna > wherex do write (' ');
        end

    else
    if cmd = 'TR' then
        begin
            writeln;
            if not keypressed then delay (300);
            coluna := 1;
        end

    else
    if cmd = 'IMG' then
        begin
            write ('[');
            s := extraiSentenca;  {ignora primeiro parâmetro}
            if maiusc(copy (s, 1, 5)) = 'FILE:' then extraiSentenca;
            sintWrite (sentenca);
            write ('] ');
        end
    else

    if (cmd = 'UL') or (cmd = 'OL') or (cmd = 'DD') then
        begin
            if wherex <> 1 then writeln;
        end

    else
    if (cmd = '/UL') or (cmd = '/OL') or (cmd = '/DD') then
        begin
            if wherex <> 1 then writeln;
        end

    else
    if cmd = 'DL' then
        begin
            if wherex <> 1 then writeln;
            writeln;
        end

    else
    if (cmd = 'LI') then
        begin
            if wherex <> 1 then writeln;
            saiLinha (sentenca);
        end

    else
    if cmd = 'MAP' then
        begin
            if wherex <> 1 then writeln;
            sintWriteln (MAPACLICAVEL);
        end

    else
    if cmd = '/MAP' then
        begin
            writeln;
            emRefer := false;
        end

    else
    if cmd = 'AREA HREF' then   { processamento parcial de map }
        begin
            sintBip;
            if wherex <> 1 then writeln;
            emRefer := true;
            saiLinha (trechoFinal (sentenca));
            paginaATrazer := sentenca;
        end

    else
    if cmd = 'A HREF' then
        begin
            sintBip;
            emRefer := true;
            paginaATrazer := sentenca;
            nomeRef := sentenca;
        end

    else
    if cmd = '/A' then
        emRefer := false

    else
    if cmd = 'FRAMESET' then
         begin
             if wherex <> 1 then writeln;
             mensagem ('WBFRAMES', 1);   {'Partes divisórias desta página (frames)'}
         end

    else
    if cmd = 'FRAME' then
         begin
             if wherex <> 1 then writeln;
             paginaATrazer := extraiSentenca;
             if copy (paginaATrazer, 1, 5) = 'FILE:' then
                 paginaATrazer := paginaATrazer + extraiSentenca;

             if sentenca = '' then
                if pos ('/', paginaATrazer) <> 0 then
                    sentenca := trechoFinal (paginaATrazer)
                else
                    sentenca := paginaATrazer;

             emRefer := true;
             saiLinha (sentenca);
             emRefer := false;
        end

    else
    if cmd = 'FORM' then
        begin
             if wherex <> 1 then writeln;
             mensagem ('WBINIFRM', 1);     {'--- Início do Formulário ---'}
        end

    else
    if cmd = '/FORM' then
        begin
             if wherex <> 1 then writeln;
             mensagem ('WBFIMFRM', 1);     {'--- Fim do Formulário ---'}
        end

    else
    if cmd = 'INPUT' then
        begin
fazInput:
            emRefer := false;
            trataInput;
        end

    else
    if cmd = 'INPUT2' then
        begin end

    else
    if cmd = 'TEXTAREA' then
        trataTextArea (true)

    else
    if cmd = 'TEXTAREA2' then
        begin end

    else
    if cmd = '/TEXTAREA' then
        trataTextArea (false)

    else
    if cmd = 'SELECT' then
        trataSelect

    else
    if cmd = '/SELECT' then
        begin
            repeat
                nt := nt - 1;
                extraiCmd (nt);
            until (nt = 1) or (cmd = 'SELECT');
            if nt > 1 then nt := nt - 1;
        end

    else
    if cmd = 'OPTION' then
        { nunca processo isso }

    else
    if cmd = '/HTML' then
        begin
            passoAPasso := true;
            if wherex > 1 then writeln;
            textBackground (RED);
            mensagem ('WBFIMPAG', 0);    {'Fim da pagina'}
            textBackground (BLACK);
            writeln;
            sintBip;
        end

    else
        if debug then
            if (cmd <> 'HTML') and (cmd <> 'BODY') then
                 writeln ('Tag ignorado ', cmd)
    ;

end;

{-------------------------------------------------------------}
{                    ajuda da navegação
{-------------------------------------------------------------}

procedure ajudaNaveg;
begin
    writeln;
    textColor (YELLOW);
    textBackground (BLUE);
    mensagem ('WVAJUN1',  0);     {'Os comandos são:'}
    textBackground (BLACK);
    writeln;
    mensagem ('WVAJUN2',  1);     {'CIMA e BAIXO  caminham e leem o texto'}
    mensagem ('WVAJUN3',  1);     {'DIREITA       avança para proximo texto ou elo'}
    mensagem ('WVAJUN4',  1);     {'Espaço/CTLF1  leitura continua'}
    mensagem ('WVAJUN5',  1);     {'ENTER         entra neste elo, ou se for um campo, executa entrada de dados'}
    mensagem ('WVAJUN6',  1);     {'TAB           pula para ler o próximo elo'}
    mensagem ('WVAJUN7',  1);     {'BS            pula para ler o elo anterior'}
    mensagem ('WVAJUN8',  1);     {'PGUP e PGDN   pula parágrafo'}
    mensagem ('WVAJUN9',  1);     {'CTL PGUP      início e fim da página'}
    mensagem ('WVAJUN10', 1);     {'CTL PGDN      início e fim da página'}
    mensagem ('WVAJUN11', 1);     {'HOME          detalha cláusulas HTML'}
    mensagem ('WVAJUN12', 1);     {'F3            Le nome da página atual'}
    mensagem ('WVAJUN13', 1);     {'F4            Configura'}
    mensagem ('WVAJUN14', 1);     {'F5            Busca texto'}
    mensagem ('WVAJUN15', 1);     {'F6            Informa percentual lido da página'}
    mensagem ('WVAJUN19', 1);     {'ESC           termina leitura'}
    textColor (LIGHTGRAY);
    while keypressed do readkey;
    writeln;
end;

{-------------------------------------------------------------}
{                leitura tipo edição
{-------------------------------------------------------------}

procedure editaInfo;
var
    p: integer;
    c: char;

begin
    repeat
        p := pos ('|', tagsPagina^[nt]^);
        cmd := copy (tagsPagina^[nt]^, 1, p-1);
        sentenca := copy (tagsPagina^[nt]^, p+1, length(tagsPagina^[nt]^)-p);

        if cmd <> 'T' then
            begin
                mensagem ('WBTIPO', 0);   {tipo}
                sintWriteln (cmd);
            end;

        if sentenca <> '' then
            begin
                writeln;
                mensagem ('WBSOLET', 1);    {'Soletre ou edite com as setas, ESC termina'}
                c := sintEdita (sentenca, 1, wherey, 80, false);
                writeln;
            end
        else
            c := ESC;

        case c of
            CIMA:    if nt > 1 then nt := nt - 1;
            BAIX:    if nt < ntags then nt := nt + 1;
        end;

    until c = ESC;
end;

{-------------------------------------------------------------}
{       executa leitura até encontrar o fim de um link
{-------------------------------------------------------------}

procedure leEsteLink;
var lendo: boolean;
    nome: string;
begin
    extraiCmd (nt);

    if cmd = 'AREA HREF' then
        processaLinha

    else
    if cmd = 'A HREF' then
        begin
           processaLinha;
           writeln;
           nt := nt + 1;

           lendo := true;
           while lendo do
               begin
                   if nt > ntags then
                       lendo := false
                   else
                       begin
                           extraiCmd (nt);
                           if cmd = '/A' then
                               lendo := false
                           else
                               begin
                                   processaLinha;
                                   nt := nt + 1;
                               end;
                       end;
               end;
        end

    else
    if cmd = 'FRAME' then
        begin
           processaLinha;
           emRefer := true;
        end

    else
    if (cmd = 'INPUT')  or (cmd = 'TEXTAREA') or
       (cmd = 'SELECT') then
        begin
            emRefer := false;
            processaLinha;
        end
    else
    ;
end;

{-------------------------------------------------------------}
{                  avanca para proximo link
{-------------------------------------------------------------}

procedure proximoLink (var nt: integer);
var n: integer;
begin
    textBackGround (BLACK);
    emRefer := false;
    n := nt;
    repeat
        n := n + 1;
        if n <= ntags then
            extraiCmd (n);
    until (n > ntags) or
          (cmd = 'AREA HREF') or
          (cmd = 'A HREF') or
          (cmd = 'FRAME') or
          (cmd = 'INPUT') or
          (cmd = 'TEXTAREA') or
          (cmd = 'SELECT') or
          (cmd = 'FORM') or (cmd = '/FORM');

    if n <= ntags then
        begin
            nt := n;
            if cmd = 'A HREF' then
                leEsteLink;
        end
    else
        begin
            writeln;
            mensagem ('WBNAOLNK', 1);   {'Não há mais referencias nesta página'}
        end;
end;

{-------------------------------------------------------------}
{                  recua para link anterior
{-------------------------------------------------------------}

procedure linkAnterior (var nt: integer);
var n: integer;
begin
    textBackGround (BLACK);
    emRefer := false;
    n := nt;
    repeat
        n := n - 1;
        if n >= 1 then
            extraiCmd (n);
    until (n < 1) or
          (cmd = 'AREA HREF') or
          (cmd = 'A HREF') or
          (cmd = 'FRAME') or
          (cmd = 'INPUT') or
          (cmd = 'TEXTAREA') or
          (cmd = 'SELECT') or
          (cmd = 'FORM') or (cmd = '/FORM');

    if n >= 1 then
        begin
            nt := n;
            if cmd = 'A HREF' then
                leEsteLink;
            nt := n;   { de novo...}
            emRefer := true;
        end
    else
        begin
            writeln;
            mensagem ('WBNAOLNK', 1);   {'Não há mais referencias nesta página'}
            emRefer := false;
        end;
end;

{-------------------------------------------------------------}
{                   executa uma funcao
{-------------------------------------------------------------}

function executa (nt: integer): boolean;     {note: nt não é alterado !}
label traz;
begin
    extraiCmd (nt);
    executa := false;

    if getKeyState (vk_Shift) < 0 then
        begin
            while (nt > 1) and (cmd <> 'IMG') do
                begin
                    nt := nt - 1;
                    extraiCmd (nt);
                end;

            if cmd <> 'IMG' then exit;
            goto traz;
        end;

    if  (cmd <> 'AREA HREF') and
        (cmd <> 'A HREF')    and
        (cmd <> 'FRAME')     and
        (cmd <> 'INPUT')     and
        (cmd <> 'TEXTAREA')  and
        (cmd <> 'SELECT')    then linkAnterior (nt)
    else
        emRefer := true;

    if not emRefer then exit;

    extraiCmd (nt);
    if (cmd = 'AREA HREF') or
       (cmd = 'A HREF')    or
       (cmd = 'FRAME') then
           begin
traz:
                paginaATrazer := extraiSentenca;
                if maiusc(copy (paginaATrazer, 1, 5)) = 'FILE:' then
                    paginaATrazer := paginaATrazer + '|' + extraiSentenca;
                executa := true;
           end;
end;

{-------------------------------------------------------------}
{                     busca um texto
{-------------------------------------------------------------}

procedure buscaTexto (pergunta: boolean);
var n, i: integer;
begin
    if pergunta then
        begin
            if wherex <> 1 then writeln;
            mensagem ('WBQUALTX', 1);   {'Qual o texto a buscar ? '}
            sintReadln (textoBuscado);
            if textoBuscado = '' then exit;
            n := nt;
        end
    else
        n := nt + 1;

    textoBuscado := maiuscAnsi (textoBuscado);
    for i := nt to nTags do
        begin
            extraiCmd (i);
            if cmd = 'T' then
                begin
                    if pos (textoBuscado, maiuscAnsi (sentenca)) <> 0 then
                         begin
                             nt := i;
                             exit;
                         end;
                end;
        end;
    mensagem ('WBNAOACH', 1);    {'Texto não encontrado após esta posição do texto'}
end;

{-------------------------------------------------------------}
{                 trata funções de interação
{-------------------------------------------------------------}

procedure trataFuncoes (c: char);
var n: integer;
begin
    if c <> BAIX then
        begin
            textColor (LIGHTGRAY);    {para evitar mas interpretacoes}
            textBackground (BLACK);
            centrando := 0;
            emBold := false;
            emItalico := false;
            emRefer := false;
            if wherex <> 1 then writeln;
        end;

    case c of
        CTLF1:   begin
                     passoAPasso := false;
                     nt := nt + 1;
                 end;

        F1:      ajudaNaveg;

        F3:      begin
                     writeln;
                     textBackground (RED);
                     sintWrite (nomePagAtual);
                     textBackground (BLACK);
                     repeat until keypressed;
                     while keypressed do readkey;
                     writeln;
                end;

        F4:      configura;

        F5:      buscaTexto (true);
        CTLF5:   buscaTexto (false);

        F6:      begin
                     writeln;
                     textBackground (RED);
                     n := round ((nt / nTags) * 100);
                     sintWriteint (n);
                     sintWriteln (TXTPORCENTO);   { por cento lido }
                     textBackground (BLACK);
                     repeat until keypressed;
                     while keypressed do readkey;
                     writeln;
                 end;


        HOME:    editaInfo;

        CIMA:    begin
                     emRefer := false;
                     if nt > 1 then
                         nt := nt - 1
                     else
                         mensagem ('WBINITXT', 1);   {'Fui para o início do texto'}
                     if wherex <> 1 then writeln;
                 end;

        BAIX :   if nt < ntags then
                    nt := nt + 1;

        DIR:     repeat
                    if nt < ntags then
                        begin
                            nt := nt + 1;
                            extraiCmd (nt);
                        end;
                until (nt >= nTags) or
                      (cmd = 'T') or
                      (cmd = 'AREA HREF') or
                      (cmd = 'A HREF') or
                      (cmd = 'FRAME') or
                      (cmd = 'INPUT') or
                      (cmd = 'TEXTAREA') or
                      (cmd = 'SELECT');

        PGUP:    repeat
                     trataFuncoes (CIMA);
                     extraiCmd (nt);
                 until (nt = 1) or (cmd = 'P');

        PGDN:    repeat
                     trataFuncoes (BAIX);
                     extraiCmd (nt);
                 until (nt = ntags) or (cmd = 'P');

        CTLPGUP: begin
                     nt := 1;
                     mensagem ('WBINITXT', 1);   {'Fui para o início do texto'}
                 end;


        CTLPGDN: begin
                     nt := ntags;
                     mensagem ('WBFIMTXT', 1);   {'Fui para o fim do texto'}
                 end;
    end;
end;

{-------------------------------------------------------------}
{         converte cadeia para o padrao codificado HTTP
{-------------------------------------------------------------}

function converteValorParaHTTP (valor: string): string;
const
    tabHexa: array [0..15] of char = (
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
var s: string;
    i: integer;
begin
    s := '';
    for i := 1 to length (valor) do
        begin
            case valor[i] of
                '@', '*', '.', '_',
                '0'..'9', 'A'..'Z', 'a'..'z':  s := s + valor[i];
                ' ':  s := s + '+';
            else
                s := s + '%' +
                     tabHexa [ord (valor[i]) shr 4] +
                     tabHexa [ord (valor[i]) and $f];
            end;
        end;
    converteValorParaHTTP := s;
end;

{-------------------------------------------------------------}
{           tenta adivinhar o que o Java Script faria
{-------------------------------------------------------------}

function nomeRefAlternativo (nt: integer): string;
var
    i, indPreenc, erro: integer;
    lixo, nome, valor, selec, tamanho, ponteiro: string;
    p: pointer;
label ok1, ok2;
begin
    nome := '';

    for i := nt-1 downto 1 do
        begin
            extraiCmd (i);
            if cmd = 'FORM' then goto ok1;
        end;

ok1:
    for i := i+1 to nTags do
        begin
            extraiCmd (i);
            if cmd = '/FORM' then goto ok2;

            if cmd = 'OPTION' then
                begin
                    ponteiro  := extraiSentenca;
                    val (ponteiro, indPreenc, erro);
                    sentenca := tagsForms^[indPreenc]^;

                    lixo := extraiSentenca;
                    selec := extraiSentenca;
                    nome := extraiSentenca;
                    valor := extraiSentenca;

                    if selec = 'SELECTED' then
                        begin
                            if copy (valor, 1, 7) = 'http://' then
                                begin
                                    nomeRefAlternativo := valor;
                                    exit;
                                end;

                            montaURLrelativa (valor, nomeBase, lixo);
                            nomeRefAlternativo := lixo;
                            exit;
                        end;
                end;
        end;

ok2:

    nomeRefAlternativo := '';
end;

{-------------------------------------------------------------}
{           executa uma submissao de formulario
{-------------------------------------------------------------}

procedure trataSubmissao (var nt: integer; var novoMetodo: char; var nomeRef: string);
var i, n, erro, indPreenc: integer;
    selec, nomeSelec,
    s, altern, lixo, metodo, valor, ponteiro, tipo, nome: string;
    validas, linhas, colunas: integer;
    temSubmit: boolean;
label achou, fim;
begin
    novoMetodo := 'G';
    nomeRef := '';
    dadosPost[0] := #$0;

    for i := nt-1 downto 1 do
        begin
            extraiCmd (i);
            if cmd = 'FORM' then goto achou;
        end;
    exit;

achou:
    lixo := extraiSentenca;
    metodo := extraiSentenca;
    novoMetodo := upcase(metodo [1]);
    nomeRef := extraiSentenca;
    temSubmit := false;

    for n := i to ntags do
        begin
            extraiCmd (n);
            if cmd = '/FORM' then goto fim;

            if cmd = 'INPUT' then
                begin
                    ponteiro := extraiSentenca;
                    val (ponteiro, indPreenc, erro);

                    tipo     := extraiSentenca;
                    nome     := extraiSentenca;
                    valor := '';
                    if (tipo = 'IMAGE') then
                        begin
                            s := nome + '.x=0&' + nome + '.y=0&' + #$0;
                            strCat (dadosPost, @s[1]);
                        end
                    else
                    if (tipo = 'SUBMIT') then
                        begin
                            temSubmit := true;
                            if nome <> '' then
                                 begin
                                     valor := copy (tagsForms^[indPreenc+1]^, 10, 255);
                                     s := nome + '=' +
                                          converteValorParaHTTP (valor) + '&' + #$0;
                                     strCat (dadosPost, @s[1]);
                                 end;
                        end
                    else
                    if (tipo = 'TEXT') or (tipo = 'PASSWORD') or
                       (tipo = 'RADIO') or (tipo = 'CHECKBOX') or (tipo='HIDDEN') then
                         if copy (tagsForms^[indPreenc+1]^, 8, 1) <> 'N' then
                           begin
                               valor := copy (tagsForms^[indPreenc+1]^, 10, 255);
                               s := nome + '=' +
                                    converteValorParaHTTP (valor) + '&' + #$0;
                               strCat (dadosPost, @s[1]);
                           end;
                end
            else
            if cmd = 'SELECT' then
                begin
                    ponteiro := extraiSentenca;
                    val (ponteiro, indPreenc, erro);
                    sentenca := tagsForms^[indPreenc]^;

                    lixo := extraiSentenca;
                    nomeSelec := extraiSentenca;  {é o segundo}
                end
            else
            if cmd = 'OPTION' then
                begin
                    ponteiro := extraiSentenca;
                    val (ponteiro, indPreenc, erro);
                    sentenca := tagsForms^[indPreenc]^;

                    lixo := extraiSentenca;
                    selec := extraiSentenca;
                    nome := extraiSentenca;
                    valor := extraiSentenca;
                    if selec = 'SELECTED' then
                         begin
                             s := nomeSelec + '=' +
                                  converteValorParaHTTP (valor) + '&' + #$0;
                            strCat (dadosPost, @s[1]);
                         end;
                end
            else
            if cmd = 'TEXTAREA' then
                begin
                    ponteiro := extraiSentenca;
                    val (ponteiro, indPreenc, erro);

                    nome := extraiSentenca;
                    s := extraiSentenca;
                    val (s, colunas, erro);
                    s := extraiSentenca;
                    val (s, linhas, erro);

                    validas := 0;
                    for i := 1 to linhas do
                        begin
                            sentenca := tagsForms^[indPreenc+i]^;
                            lixo := extraiSentenca;
                            s := extraiSentenca;
                            if s <> '' then validas := i;
                        end;

                    s := nome + '=' + #$0;
                    strCat (dadosPost, @s[1]);

                    for i := 1 to validas do
                        begin
                            sentenca := tagsForms^[indPreenc+i]^;
                            lixo := extraiSentenca;
                            s := extraiSentenca;
                            if i <> validas then
                                s := converteValorParaHTTP (s + #$0d + #$0a) + #$0
                            else
                                s := converteValorParaHTTP (s) + #$0;
                            strCat (dadosPost, @s[1]);
                        end;

                    s := '&' + #$0;
                    strCat (dadosPost, @s[1]);
                end
            else
                ;
        end;

fim:
    if strlen (dadosPost) > 0 then
        if dadosPost [strlen(dadosPost)-1] = '&' then
            dadosPost [strlen(dadosPost)-1] := #$0;

    if (nomeRef = '') or (not temSubmit) then
        begin
            altern := nomeRefAlternativo (nt);
            if altern <> '' then
                begin
                    writeln;
                    mensagem ('WBJAVA', 1);      {'Simulando Java Script'}
                    novoMetodo := 'G';
                    nomeRef := altern;
                    dadosPost[0] := #$0;
                end;
        end;

    if nomeRef = '' then nomeRef := nomePagAtual;

    if novoMetodo = 'G' then
        begin
            if strLen (dadosPost) <> 0 then
                nomeRef := nomeRef + '?' + strPas (dadosPost);
        end;

    repeat
        nt := nt - 1;
        if nt > 1 then
            extraiCmd (nt);
    until (nt <= 1) or (cmd = 'FORM');
end;

{-------------------------------------------------------------}
{                busca um rotulo nesta página
{-------------------------------------------------------------}

function buscaRotulo (rotulo: string): integer;
var i: integer;
begin
    buscaRotulo := 1;
    for i := 1 to ntags do
        begin
            extraiCmd (i);
            if cmd = 'A NAME' then
                if extraiSentenca = rotulo then
                    begin
                        buscaRotulo := i;
                        exit;
                    end;
        end;
end;

{-------------------------------------------------------------}
{                leitura interativa da pagina
{-------------------------------------------------------------}

procedure leituraInterativa (nomeArqOrig: string;
       var novaPagina: string; var novoMetodo: char);

var salvaPasso, processando: boolean;

label deNovo, fim, execSubmissao;

begin
    if not extraiTagsPagina (nomeArqOrig) then
        begin
            novaPagina := '';
            novoMetodo := 'G';
            exit;
        end;

deNovo:
    if rotuloInicial <> '' then
        linhaAtual := buscaRotulo (rotuloInicial);
    rotuloInicial := '';

    submeteu := false;
    clrscr;
    if not emPortug then
        begin
            textColor (LIGHTGRAY);
            textBackGround (BLUE);
            gotoxy (40, 25);
            mensagem ('WBSETLER', 0);   {'Use setas para ler, F1 ajuda'}
            textBackGround (BLACK);
        end;

    gotoxy (1, 1);
    window (1,1, 80, 24);

    centrando := 0;
    emBold := false;
    emItalico := false;
    emRefer := false;

    nt := linhaAtual;
    processando := true;
    preLido := false;
    lido1 := ' ';

    passoAPasso := not emPortug;
    sintFalaPont := falandoPontuacao;

    while processando do
        begin
            extraiCmd (nt);     { se nt > ntags, a rotina retornará /HTML }
            processaLinha;
            if submeteu then goto execSubmissao;

            salvaPasso := passoAPasso;
            if nt > nTags then
                begin
                    passoAPasso := true;
                    nt := nTags;
                end
            else
                if keypressed then
                     passoApasso := true;

            if not passoAPasso then
                nt := nt + 1
            else
                begin
                    if not prelido then
                        begin
                            lido1 := readkey;
                            if lido1 = #$0 then lido2 := readkey;
                        end;
                    preLido := false;

                    case upcase(lido1) of
                        #$0:   begin
                                   sintFalaPont := true;
                                   trataFuncoes (lido2);
                                   sintFalaPont := falandoPontuacao;
                               end;

                        ENTER: if executa (nt) then
                                   processando := false;

                        TAB:   if getKeyState (vk_Shift) < 0 then
                                   linkAnterior (nt)
                               else
                                   proximoLink (nt);

                        BS:    linkAnterior (nt);

                        ' ':   begin
                                   passoAPasso := not salvaPasso;
                                   nt := nt + 1;
                               end;

                        ESC:   begin
                                   textColor (LIGHTGRAY);
                                   novaPagina := '';
                                   linhaAtual := nt;
                                   novoMetodo := ' ';
                                   goto fim;
                               end;
                    else
                        begin
                            if wherex <> 1 then writeln;
                            textBackGround (RED);
                            mensagem ('WBCMDINV', 0);    {'Comando inválido, F1 ajuda'}
                            textBackGround (BLACK);
                            writeln
                        end;
                    end;
                end;
        end;

execSubmissao:
    novoMetodo := 'G';
    if submeteu then
        trataSubmissao (nt, novoMetodo, novaPagina)
    else
        begin
            novaPagina := paginaATrazer;
            if (novaPagina <> '') and (novaPagina[1] = '#') then
                begin
                    rotuloInicial := copy (novaPagina, 2, length(novaPagina)-1);
                    goto deNovo;
                end;
        end;

fim:
    pilhaPag [topoPilhaPag]^.posicao := nt;
    sintFalaPont := true;
    window (1,1, 80, 25);
    gotoxy (1, 25);
    textBackground (BLACK);
    textColor (LIGHTGRAY);
    clreol;
end;

{-------------------------------------------------------------}
{               chama um dos leitores do webvox
{-------------------------------------------------------------}

procedure chamaLeitor (tipo: string; nomeArq: string);
var nomeProg: string;
    nomeDir: string;
begin
    nomeProg := sintAmbiente ('WEBVOX', tipo);
    if nomeProg = '' then
        begin
            mensagem ('WBTIPNAO', 1);   {'Tipo não processavel, para armazenar use a funcao O'}
            exit;
        end;

    getdir (0, nomeDir);

    writeln (nomeprog);
    writeln (nomedir);
    writeln (nomearq);

    if executaProg (nomeProg, nomeDir, nomeArq) > 32 then
        esperaProgVoltar
    else
        mensagem ('WBNAOEXE', 1);   {'Execução do programa trazido não foi possível'}
end;

{-------------------------------------------------------------}
{            checa se arquivo tipo texto nao é html
{-------------------------------------------------------------}

procedure checaTipoTexto (var tipo: string; nomeArq: string);
var
    s1, s2: string;
    arq: text;
begin
    assign (arq, nomearq);
    {$I-}  reset (arq);  {$I+}
    if ioresult = 0 then
        begin
            {$I-}  readln (arq, s1);  {$I+}   if ioresult <> 0 then;
            {$I-}  readln (arq, s2);  {$I+}   if ioresult <> 0 then;
            close (arq);

            if (maiusc(s1) = '<HTML>') or  (maiusc(s2) = '<HTML>') then
                   begin
                       tipo := 'text/html';
                       exit;
                   end;
        end;
end;

{-------------------------------------------------------------}
{                      executa leitura
{-------------------------------------------------------------}

procedure lerPagina;
var
    nomeArqTexto, novaPagina: string;
    arq: text;
    novoMetodo: char;
    tipo: string;
    p: integer;

label le, fim;

begin
    novoMetodo := 'G';

    tipo := '';
    if nomeTemp = '' then
        begin
             mensagem ('WBNAOCAR', 1);  {'Não existe página carregada'}
             exit;
        end;

    repeat
         tipo := buscaInfoCabec ('Content-type:');

         if tipo = '' then tipo := 'text/html';

         p := pos (';', tipo);
         if p <> 0 then tipo := copy (tipo, 1, p-1);

         if tipo = 'text/plain' then
             checaTipoTexto (tipo, nomeTemp);      { as vezes vem errado, e' realmente html }

         if tipo = 'text/html' then
             begin
                leituraInterativa (nomeTemp, novaPagina, novoMetodo);

                if novaPagina <> '' then
                     begin
                         if wherex <> 0 then writeln;
                         textBackGround (RED);
                         mensagem ('WBTRAPAG', 0);   {'Trazendo página'}
                         textBackGround (BLACK);
                         writeln (' ',  novaPagina);

                         if not trazerPagina (novaPagina, novoMetodo) then
                             novaPagina := ''
                         else
                             begin
                                 linhaAtual := 1;    {faltou verificar se é fragmento}
                                 emRefer := false;
                             end;
                     end;
             end
         else
             chamaLeitor (tipo, nomeTemp);

    until (novaPagina = '') or (tipo <> 'text/html');
    writeln;
end;

end.
