# Referência de criação do ExpandaEVE O ExpandaEVE é a forma legível da linguagem EVE. É o que se escreve num ficheiro de filtro `.eve`. Cada construção aqui é traduzida para [CompactaEVE](page:eve/compacta) e depois compilada. Esta página documenta cada construção com exemplos reais retirados dos ficheiros de filtro fornecidos. Para as diretivas ao nível do documento (`DEFINE`, `LET`, `REALM`, as instruções de regra) consulte [A linguagem EVE](page:eve/language). Esta página é sobre o corpo de uma regra difusa: o próprio padrão. ## A forma do corpo de uma regra O corpo de uma regra difusa tem sempre uma raiz e pode adicionar qualquer número de construções à sua volta. A raiz é a palavra radical sobre a qual a regra é construída. Tudo o resto a refina: sufixos, tratamento de plural, exclusões, contexto, e assim por diante. ```text HEAR rule AS fuck(WHOLE) suffix(NONE OR er OR ers OR ing OR ed OR s) FLAG(pf YES) ``` Aqui `fuck(WHOLE)` é a raiz, `suffix(...)` adiciona terminações permitidas, e `FLAG(pf YES)` marca a categoria. As construções podem aparecer em qualquer ordem que se leia naturalmente; o tradutor reconhece cada uma por palavra-chave. ## A raiz e os seus marcadores de fronteira A raiz é a âncora de uma regra. Exatamente um marcador de raiz define quão estritamente a correspondência é delimitada na raiz: | Marcador | Significado | |--------|---------| | `(WHOLE)` | A raiz tem de corresponder como palavra inteira. O candidato começa com o radical da raiz e todo o percurso corre até uma fronteira de palavra. Escreve-se `[^^]` no CompactaEVE. | | `(ROOT)` | A raiz é um radical sobre o qual sufixos e grupos se constroem. Não precisa de ser uma palavra inteira por si só. Escreve-se `[*^]` no CompactaEVE. | Utilize `(WHOLE)` quando a palavra nua é ela própria a ofensa: ```text spic(WHOLE) PLURAL ``` Utilize `(ROOT)` quando vai anexar terminações ou grupos finais: ```text ni(ROOT) suffix(g OR ga OR gga OR gger OR gl LETTER t) PLURAL ``` !!! warning "Cada regra difusa precisa de um marcador de raiz" Um corpo de regra sem marcador `(WHOLE)` ou `(ROOT)` não pode compilar. O marcador é o que separa o radical da raiz do resto do padrão. ### A correspondência difusa é automática Uma raiz difusa não é um teste de string literal. O correspondente já tolera a evasão comum: as vogais são intercambiáveis através do conjunto de vogais, as letras podem ser esticadas, e as lacunas (consulte [GAP](#gap-and-letter)) deixam passar caracteres inseridos onde as permite. Não ativa isto; é assim que as regras difusas correspondem. Para apanhar um leque mais amplo de erros ortográficos deliberados, adicione [aliases](#alias-alternate-spellings) e [esqueletos](#skeleton-exact-spellings). ## suffix: terminações permitidas `suffix(...)` lista as terminações que a palavra pode assumir após a raiz. Os braços são separados por `OR`. Só é necessário um grupo de sufixos, mas pode empilhar vários; cada um adiciona um segmento opcional por ordem. ```text bitch(WHOLE) suffix(NONE OR es OR ed OR ing OR y OR ier OR iest OR fest OR fests) ``` `NONE` significa que a terminação é opcional: a palavra pode terminar logo na raiz. Sem um braço `NONE`, o sufixo é obrigatório. Os grupos de sufixos compõem-se da esquerda para a direita, por isso vários seguidos constroem uma cadeia de segmentos opcionais: ```text fa(ROOT) suffix(g OR gg OR NONE) suffix(ggot OR NONE) suffix(ggie OR NONE) ``` Um braço de sufixo pode ele próprio conter `GAP` ou `LETTER` (consulte [GAP e LETTER](#gap-and-letter)): ```text suffix(g OR ga OR gga OR gger OR gl LETTER t) ``` ```text suffix(my GAP OR NONE) ``` ### PLURAL `PLURAL` adiciona um conjunto rico de terminações de plural e flexão numa só palavra. Expande-se para a classe incorporada `s` de terminações, por isso uma regra marcada `PLURAL` também apanha `-s`, `-z`, `-es`, `-ing`, `-ed`, `-er`, `-y` e os outros membros declarados na função `s`. ```text dyke(WHOLE) PLURAL ``` `PLURAL` lê a classe chamada `s`. O filtro inglês fornecido declara-a como: ```text LET function(s) BE s OR z OR es OR ez OR ies OR iez OR y>ies OR y>iez OR ing OR ings OR ed OR er OR ers OR y OR ys ``` Um braço escrito `from>to` é uma terminação de reescrita: corresponde a uma palavra que termina em `to` testando a raiz com a terminação `from` em vez disso. `y>ies` apanha uma palavra que termina em `ies` como se terminasse em `y`, que é como `baby` e `babies` são ambos alcançados a partir de uma raiz. Consulte [Sufixos de reescrita](page:eve/compacta#rewrite-suffixes) para a mecânica. ## NEVER: exclusões `NEVER(...)` lista frases que não devem aparecer na linha circundante. Se alguma frase listada estiver presente, a regra não dispara, mesmo que o padrão corresponda de outra forma. É assim que uma raiz agressiva é impedida de apanhar palavras inocentes. ```text wop(WHOLE) PLURAL NEVER(doowop OR doo wop OR doowap OR doo wap OR dowap OR do wap OR do wop) ``` ```text gook(WHOLE) PLURAL NEVER(600k OR 900k OR 60ok OR 90ok OR 6ook OR 9ook OR 600ks OR 900ks) ``` Uma verificação `NEVER` é um teste de subcadeia simples contra a linha inteira, em minúsculas. Se a frase estiver algures na mensagem, a regra é vetada. ## ALIAS: grafias alternativas `ALIAS(...)` adiciona uma grafia alternativa da raiz. Cada alias é uma variante de raiz separada que reutiliza o resto da regra (os seus sufixos, grupos, exclusões). Liste um alias por linha para cobrir erros ortográficos deliberados e trocas de letras. ```text ALIAS(phuck) ALIAS(fuk) ALIAS(fukk) ALIAS(fucc) ALIAS(fck) ALIAS(fk) fuck(WHOLE) suffix(NONE OR er OR ers OR ing OR ed OR s) ``` Cada alias aqui corresponde com o mesmo conjunto de sufixos que `fuck`. Um alias pode carregar o seu próprio marcador `(WHOLE)` ou `(ROOT)`; sem um, herda a fronteira da raiz. Um alias pode referenciar uma função, caso em que cada membro dessa função se torna um alias: ```text ALIAS(function(selfharmverb)) kill(ROOT) ``` Um alias também pode ser uma palavra segmentada ou um fragmento de várias partes; é normalizado da mesma forma que a raiz é. ## ALSO: fragmentos aditivos `ALSO(...)` adiciona um fragmento que pode aparecer algures após a raiz em vez de em ordem fixa. É utilizado quando uma palavra extra necessária pode flutuar em relação ao radical. ```text kill(ROOT) GAP suffix(yo OR ur OR your OR yor) suffix(self) ALSO(wrists OR wrist OR throat) ``` `ALSO` reduz-se a um grupo flutuante que se anexa em qualquer posição alcançável após a raiz e os grupos normais. Consulte [Grupos plus](page:eve/compacta#plus-groups-floating) para saber como um grupo flutuante é correspondido. ## GAP e LETTER Estas abreviaturas controlam o que pode ficar entre partes de um padrão. | Construção | Significado | CompactaEVE | |-----------|---------|-------------| | `GAP` | Uma sequência opcional de quaisquer caracteres (letras ou não letras), por isso espaços inseridos, pontuação ou enchimento são tolerados. | `(#*)` | | `LETTERS` | Uma sequência opcional apenas de letras. | `($^)` | | `LETTER` | Exatamente um carácter de material de palavra. | `@` | `GAP` entre uma raiz e um sufixo deixa uma frase espalhar-se por várias palavras: ```text moon(ROOT) GAP suffix(cricket) PLURAL ``` Isto apanha `moon cricket`, `mooncricket` e grafias com enchimento entre as duas partes. `LETTER` corresponde a um único carácter, útil dentro de um braço de sufixo para permitir uma posição curinga: ```text suffix(m LETTER GAP OR NONE) ``` `LETTERS` corresponde a uma sequência apenas de letras, por isso para num espaço: ```text my(ROOT) GAP LETTERS GAP suffix(hit) ``` !!! note "O que conta como letra" Material de palavra é uma letra ASCII ou qualquer byte de um glifo não ASCII, por isso uma sequência de emoji ou símbolo também conta como material de palavra para fronteiras e para o curinga `LETTER`. O texto ASCII simples não é afetado. ## OR e NONE `OR` separa alternativas dentro de uma construção como `suffix(...)`, `NEVER(...)`, `ALSO(...)`, `BEFORE(...)` e `AFTER(...)`, e separa membros de classe numa declaração `LET`. Tem de ficar como palavra inteira. `NONE` é uma alternativa vazia. Num sufixo torna a terminação opcional; numa lista de membros de função deixa a classe contribuir com uma correspondência vazia: ```text LET function(quantifier) BE NONE OR some OR any OR a OR an OR the ``` ## BEFORE e AFTER: condicionamento por contexto Estas condicionam uma regra por texto noutro sítio da linha. São utilizadas para fazer com que um termo de outra forma amplo ou ambíguo dispare apenas num contexto revelador. | Construção | Significado | CompactaEVE | |-----------|---------|-------------| | `BEFORE(...)` | Uma verificação prévia. A regra só ativa quando uma das frases listadas aparece na linha circundante. | `{pre:...}` | | `AFTER(...)` | Uma condição posterior. Terminações permitidas que deixam a regra disparar na própria palavra mesmo sem uma frase de verificação prévia presente. | `{post:...}` | ```text BEFORE(function(seeking)) cp AFTER(mega OR pack OR packs OR nz OR db OR dropbox OR folder OR vids OR pics) (WHOLE) ``` Uma frase `BEFORE` é uma verificação de subcadeia simples contra a linha inteira, em minúsculas. Quando uma regra tem um condicionamento `BEFORE`, permanece inerte a menos que uma das frases esteja presente, ou a menos que a palavra satisfaça a condição posterior `AFTER` por conta própria. `AFTER` aceita um `s` plural final nas suas terminações. Consulte [Condicionamento](page:eve/compacta#precheck-and-post-gating) para a regra exata. ## SWAP: conjunto de substituição inline `SWAP(...)` corresponde a qualquer um de vários pequenos fragmentos numa posição, com controlo sobre as fronteiras de palavra. É utilizado onde uma peça curta intercambiável fica dentro de uma frase. ```text kill(ROOT) GAP SWAP(my* OR me*) suffix(self) ``` Cada braço pode carregar asteriscos que libertam uma fronteira: - Um `*` inicial liberta o início (o braço não precisa de começar numa fronteira de palavra). - Um `*` final liberta o fim. - Sem asterisco, ou um duplo `**` inicial, ancora ambos os lados a uma fronteira de palavra. Assim `my*` corresponde a `my` com uma fronteira necessária antes mas não necessariamente depois, deixando-o correr para `self`. Consulte [Swaps](page:eve/compacta#swaps) para as regras de fronteira na íntegra. ## SKELETON: grafias exatas `SKELETON(...)` lista formas de palavra exatas que a regra também corresponde diretamente, contornando o correspondente difuso. É utilizado para fixar grafias ofuscadas específicas usando listas de escolha inline. ```text ni(ROOT) suffix(g OR ga OR gga OR gger OR gl LETTER t) PLURAL NEVER(snigger OR sniggers OR sniggered) SKELETON(n[a,e,i,o,u]gg[a,e,i,o,u]r OR n[a,e,i,o,u]gg[a,e,i,o,u]h) ``` Um esqueleto é expandido no conjunto completo de palavras concretas que pode soletrar, e qualquer candidato igual a uma dessas palavras corresponde imediatamente. A expansão toma o produto cruzado de cada escolha, por isso `n[a,e,i,o,u]gg[a,e,i,o,u]r` produz `naggar`, `neggar`, `niggar`, e assim por diante para cada par de vogais. ### Listas de escolha inline Dentro de um esqueleto, `[a,e,i,o,u]` é uma lista de escolha inline: uma posição de carácter que pode ser qualquer um dos membros separados por vírgula. Os membros podem ter mais de um carácter. Os espaços em branco à volta de um membro são retirados. Um esqueleto também pode referenciar uma função com `&name`, que se expande para os membros dessa função. ```text SKELETON(r[e,i]t[a,e,i]rd) ``` ```text SKELETON(m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t OR m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t[a,e,i,o,u]) ``` O resultado é em minúsculas. Os esqueletos correspondem à grafia exata, por isso são complementares à raiz difusa, que trata das variantes mais soltas. ## FUNCTION: classes nomeadas Uma função é uma classe nomeada declarada com `LET` (consulte [A linguagem EVE](page:eve/language#let-defining-a-function-named-class)). É referenciada com `function(name)`, e a referência expande-se para os membros da classe. As funções têm vários papéis dependendo de onde aparecem. Como um grupo inteiro de alternativas num corpo de regra: ```text groom(ROOT) suffix(NONE OR ing OR ed) GAP MAYBE function(declarative) GAP function(vulnerable) ``` Como um alias, onde cada membro se torna uma raiz alternativa: ```text ALIAS(function(genderword)) internal GAP condom(WHOLE) ``` Dentro de uma lista `suffix`, `NEVER`, `ALSO`, `BEFORE` ou `AFTER`, onde os membros se juntam às alternativas: ```text suffix(function(article) OR box of OR a box of OR internal OR function(genderword) OR NONE) ``` ### Modificadores de função Uma referência `function(...)` pode carregar modificadores, unidos com `+`: | Modificador | Efeito | CompactaEVE | |----------|--------|-------------| | `ADDITIVE` | A referência é uma adição flutuante à correspondência em vez de um requisito de ordem fixa. | envolve como grupo plus `[+[...]]` | | `GAP` | A referência corresponde de forma solta, permitindo uma lacuna depois dela. | acrescenta `(#*)` | ```text function(subject + ADDITIVE + GAP) function(desire + ADDITIVE + GAP) function(quantifier + ADDITIVE + GAP) rap(ROOT) suffix(e OR ist OR ed OR ing OR eable OR able) PLURAL ``` Cada função aditiva aqui flutua para dentro da correspondência onde quer que caiba, por isso as palavras de sujeito, desejo e quantificador podem aparecer em ordem variável antes da raiz. ## MAYBE FUNCTION: função opcional `MAYBE FUNCTION(name)` torna uma referência de função opcional: a correspondência tem êxito quer um dos seus membros esteja presente ou não. ```text rap(ROOT) suffix(NONE OR e OR es OR ed OR ing OR eing OR in OR ist OR ists) GAP MAYBE function(declarative) GAP function(vulnerable) ``` Aqui `function(declarative)` (palavras como `a`, `the`, `my`) pode ou não aparecer entre o verbo e a palavra de pessoa vulnerável. ## FLAG: regras condicionais e etiquetagem de categoria `FLAG(name YES)` marca a regra com uma flag declarada. Quando a regra dispara, essa flag é definida, que é como o filtro reporta uma categoria como automutilação ou abuso em vez de um bloqueio comum. ```text kms(WHOLE) FLAG(sh YES) ``` O valor pode ser escrito `YES`, `Y` ou `TRUE` para ligado, e qualquer outra coisa para desligado. O nome da flag tem de ser declarado com `DEFINE` (consulte [A linguagem EVE](page:eve/language#define-declaring-flag-ids)), ou o documento não carrega. Nos bastidores uma flag envolve o padrão num condicionamento condicional; consulte [Invólucros de flag](page:eve/compacta#flag-wrappers). ## NOTE: comentários `NOTE(...)` anexa um comentário inline. É removido antes da compilação e não afeta a correspondência, por isso é uma forma de anotar um padrão no lugar. Os comentários de linha inteira continuam a utilizar um `#` inicial. ## ALIAS com marcadores WHOLE ou ROOT Um alias pode terminar em `(WHOLE)` ou `(ROOT)` para definir a sua própria fronteira, independente da raiz: ```text ALIAS(dike) dyke(WHOLE) ``` Sem um marcador final o alias herda o marcador de fronteira da raiz. ## Raízes segmentadas Uma raiz pode ser escrita como várias peças entre parênteses e nuas para marcar parte dela como flexionável. Quando estão presentes pelo menos duas peças e pelo menos uma está entre parênteses, dobram-se numa única raiz com pontos de entrada alternativos. ```text re[tard] (WHOLE) suffix(NONE OR d OR ded OR ted OR t OR der OR ders OR ing OR ed OR s) ``` A peça entre parênteses marca o segmento flexionável. Consulte [Raízes segmentadas](page:eve/compacta#segmented-roots) para saber exatamente que alternativas são geradas. ## Juntando tudo Uma regra realista combina várias construções: ```text HEAR rule AS ALIAS(masterb) masturb(ROOT) suffix(ate OR ating OR ation OR ated OR ates OR at) SKELETON(m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t OR m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t[a,e,i,o,u]) ``` Esta regra tem um alias para um erro ortográfico comum, uma raiz com um conjunto de sufixos fixo e esqueletos para as grafias em leetspeak que o correspondente difuso poderia falhar. Leia [CompactaEVE](page:eve/compacta) para ver como cada uma destas se reduz e corresponde.