Estou escrevendo um artigo no qual ainda não fiz todas as escolhas estilísticas. Ou seja, ainda não decidi quais palavras longas quero abreviar e como quero abreviá-las, se o autor do artigo é um "eu", um "nós", um "o autor" ou os "autores" etc. Então o que eu quero fazer é definir algumas palavras-chave que serão reutilizadas muitas vezes.
Quero, no topo do meu documento, fazer algo parecido com \newcommand{\auth}{we}e sempre que eu escrever \auth{}no meu documento, a palavra "nós" deve aparecer. Agora, os mais experientes perceberão que o que estou descrevendo aqui realmente fará o que eu quero, então vamos à questão real.
O que eu realmente quero fazer é vincular uma palavra do dicionário de inglês a um comando e, ao passar um argumento para esse comando, poder alterar ligeiramente sua saída. Então, por exemplo, se eu decidir \auth{}cuspir “nós”, quero \auth{upper}cuspir “nós”. Eu também gostaria de poder obter formas possessivas, como "Nosso" e "nosso", ligando \auth{upper, possessive}ou \auth{possessive}algo semelhante. Qual seria a melhor maneira de conseguir isso? Posso criar uma espécie de dicionário ou o que você recomenda?
Muito obrigado!
Responder1
Bem, eu tentei. Aliás, só funciona em LuaLaTeX:
%!TEX program = lualatex
\documentclass{article}
\usepackage{polyglossia}
\usepackage{luacode}
\begin{luacode*}
dofile(kpse.find_file("l-lpeg.lua"))
dofile(kpse.find_file("util-sto.lua"))
dofile(kpse.find_file("util-prs.lua"))
Pronouns = {
["formal"] = {
["possessive"] = "ours",
["nominative"] = "we",
["oblique"] = "us"
},
["informal"] = {
["possessive"] = "mine",
["nominative"] = "I",
["oblique"] = "me"
}
}
function Auth(keywords)
local dummy = utilities.parsers.settings_to_array(keywords)
for i,v in ipairs(dummy) do
if Pronouns[dummy[i]] ~= nil then result = Pronouns[dummy[i]] end
end
for i,v in ipairs(dummy) do
if result[dummy[i]] ~= nil then result = result[dummy[i]] end
end
return result
end
function Upper(string)
return unicode.utf8.upper(unicode.utf8.sub(string,1,1))..unicode.utf8.sub(string,2,utf8.len(string))
end
\end{luacode*}
\def\auth#1{\directlua{tex.print(Auth("#1"))}}
\def\Auth#1{\directlua{tex.print(Upper(Auth("#1")))}}
\begin{document}
\auth{oblique,informal} \Auth{formal,possessive}
\end{document}
Responder2
Isso foi surpreendentemente complexo, mas aqui está uma solução que funciona com qualquer TeX*
\begingroup
\catcode`!=11 % for private macros
\endlinechar=-1
\catcode`\^^M=12 \catcode`\^^?=12\relax
\gdef\!stop{^^?}
\gdef\!fi{\fi}
\newtoks\!before \newtoks\!after
% some convenient shorthands
\gdef\!csnm#1{\csname#1\endcsname}
\gdef\!ecsnm#1#2{\expandafter#1\csname#2\endcsname}
% the main command sets up the catcodes for reading in
% the definitions of the second argument
\gdef\newvarcommand#1{
\begingroup\catcode`\^^M=12 \catcode`\^^?=12\relax
{\escapechar=-1 \xdef\!name{\string#1}}
\!ecsnm\newtoks{toks:\!name}
\gdef#1##1{
{\escapechar=-1 \xdef\!name{\string#1}}
\begingroup
\!processnextkey##1,^^?,
\!ecsnm\the{toks:\!name}
\!result
\endgroup
}
\!newvarcommand
}
% for each modifier in the argument, set the corresponding
% conditional true
\gdef\!processnextkey#1,{\def\arg{#1}
\ifx\!stop\arg\else
\ifx\empty\arg\def\!key{default}\else\def\!key{#1}\fi
\!ecsnm\ifx{ifkey:\!name:\!key}\relax
\errmessage{Unknown key \!key\space for command \!name}
\else\!csnm{key:\!name:\!key true}\fi
\expandafter\!processnextkey\fi
}
% here we read the argument line by line
\gdef\!newvarcommand#1{\!getnext#1^^M^^?^^M}
\gdef\!getnext#1^^M{\def\arg{#1}
\ifx\!stop\arg\endgroup\else
\ifx\empty\arg\else\!parse#1^^M\fi
\expandafter\!getnext\fi
}
% for each entry, new conditionals are created to test whether a
% modifier is present or not, and a token list containing the
% conditionals and the word to be printed is appended to the
% token list read by the command to be defined
\gdef\!parse#1:#2^^M{\!before={}\!after={}\def\arg{#1}
\ifx\empty\arg
{\globaldefs=1 \!ecsnm\newif{ifkey:\!name:default}}
\!before=\expandafter{\csname ifkey:\!name:default\endcsname}
\!after=\expandafter{\!fi}
\else\!setupnextkey#1,^^?,\fi
\edef\!addtoks{\!ecsnm\the{toks:\!name}
\the\!before\def\noexpand\!result{#2}\the\!after}
\global\!csnm{toks:\!name}=\expandafter{\!addtoks}
}
% creating \newifs for each modifier
\gdef\!setupnextkey#1,{\def\arg{#1}
\ifx\!stop\arg\else
{\globaldefs=1 \!ecsnm\newif{ifkey:\!name:#1}}
\!before=\expandafter{\the\expandafter\expandafter
\expandafter\!before\!csnm{ifkey:\!name:#1}}
\!after=\expandafter{\the\expandafter\!after\!fi}
\expandafter\!setupnextkey\fi
}
\endgroup
Você pode então definir seu "dicionário" da seguinte forma:
\newvarcommand\auth{
:we
upper:We
possessive:ours
upper,possessive:Ours
}
Em cada linha, você escreve as palavras separadas por vírgula que deseja usar como argumentos e, depois de dois pontos, a palavra que deve aparecer. O valor padrão pode ser especificado com :valou default:val.Importante:As entradas devem ocorrer em ordem crescente de especificadores (ou seja, você deve ter todas as entradas de uma palavra primeiro, depois aquelas com duas palavras separadas por vírgula, depois três e assim por diante), caso contrário você poderá obter resultados incorretos.
\auth{} \auth{default} % these two are the same, "we"
\auth{upper} % "We"
\auth{possessive} % "ours"
\auth{upper,possessive} \auth{possessive,upper} % both "Ours"
\auth{lower} % this gives an "Unknown key" error
Deixe-me explicar na upper,possessive:Ourslinha como o código funciona. Basicamente, quando a linha é lida, ela primeiro cria condicionais \ifkey:auth:uppere \ifkey:auth:possessive. Então, uma lista de tokens
\ifkey:auth:upper
\ifkey:auth:possessive
\def\!result{Ours}
\fi
\fi
é construído e anexado a uma lista de tokens chamada \toks:auth. Se você usar \auth{upper,possessive}, os argumentos e as condicionais correspondentes serão lidos \ifkey:auth:uppere ifkey:auth:possessivedefinidos como verdadeiros, a toks:authlista de tokens será descompactada e \!resultimpressa.
*Ele assume um não-externo
\newif, como no LaTeX, mas para o TeX simples algumas adaptações seriam necessárias.