Scanf.jl
v0.5.4
O SCANF digitaliza fluxos de entrada codificados por UTF8 ou strings e cria dados de saída de acordo com uma sequência de formato. Ele imita o comportamento da função C com o mesmo nome.
Julia> Usando Scanf
Julia> r, a, b = @scanf ("13 Este é um número primo", "%d%[a-za-z]", int, string)
(2, 13, "Este é um número primo")# Colete dados em um feliz tuplejulia> r, t ... = @scanf "1 2 -inf 4 u4119" "%d%u%e%x%s" 0 UINT 0.0 Int "" (5, 1, 0x000000000000000002, -inf, 4, "䄙")# SCAN DAT -TEMPER STRING -Observe que as peças S e Ms usam os valores padrãojulia> f = scanf.format "%d.% 2d.%2d%*1 [t]%2d:%2d:%2d.%3d ";
Julia> r, y, m, d, h, m, s, ms = scanf ("2021.07.04t15: 53", f, int, zeros (int8, 5) ..., int16)
(5, 2021, 7, 4, 15, 53, 0, 0) Scanf fornece a macro r, a,... = @scanf([io, ] "format_string", args...) e a função r, a,... = scanf(io, f::Scanf.Format, args...) .
A sequência do formato deve ser uma string literal, que é avaliada uma vez no tempo de expansão da macro.
Alternativamente, f = Scanf.format"format_string" ou f = Scanf.Format(::AbstractString) Crie um objeto de formato, que pode ser usado na chamada de função.
Os argumentos são valores padrão dos tipos Real , AbstractChar , AbstractString , Ptr , AbstractVector{Char} .
Eles também podem ser subtipos de concreto de Real , AbstractChar , AbstractString , Ptr .
Os especificadores de formato numérico são compatíveis com argumentos numéricos e String . Erros de conversão podem acontecer (float => int).
Se o tipo Arg numérico não for largo o suficiente para o valor, os valores de limite com o sinal correto serão armazenados (por Inf , -0.0 ).
Especificadores de formato c , s , [ são todos compatíveis com argumentos Char , Char[] e String . No caso de Char o primeiro caractere de uma string é levado.
Todos os dados de saída são retornados como uma tupla, incluindo o número de valores atribuídos como o primeiro elemento. Se um valor não puder ser analisado, o valor padrão será atribuído. No caso de nenhum valor está no elemento correspondente do arg , o valor padrão é derivado do formulário T .
Se o argumento padrão for um objeto Vector , os valores de saída serão adicionalmente armazenados nele.
As cadeias de formato seguem a definição de referência C ++-Scanf C ++ com algumas adaptações:
Todos os caracteres Unicode são suportados em cadeias de formatos e dados de entrada.
Em cordas de formato, os especificadores de espaço em branco são apenas os caracteres espaciais ASCII em " nrtfv" .
Nos dados de entrada, todos os caracteres x com isspace(x) == true são ignorados por qualquer especificador de espaço em branco na sequência do formato.
A forma %n$... de especificações de formato não é suportada.
Modificadores de tipo opcional como h , l , L etc. são ignorados; O tipo de destino é derivado do argumento padrão correspondente.
Para o especificador de tipo %c , sem width especificada, o argumento correspondente deve ter Char ou String do tipo.
Para o especificador de tipo %Nc , com um campo de largura N , o argumento deve ter String ou Vector{Char} . Esse vetor é reutilizado e redimensionado para o número de caracteres realmente lidos.
O especificador de tipo %n , retorna um valor inteiro, que é o deslocamento do caractere nos dados de entrada, consumido por esse scanf até agora.
O especificador de tipo %p requer um argumento padrão Ptr .
O valor de retorno de ambas as chamadas é a quantidade de argumentos de saída, seguidos por todos os dados de saída, os valores padrão talvez. Em contraste com C e C ++, também os argumentos para %n são contados.
Se o fluxo de entrada estiver esgotado antes que um caractere seja lido, o EOF -Indicator -1 será retornado no lugar do número de valores atribuídos.
Para especificadores de formato "WhiteSpace", qualquer número de caracteres (também zero) x com isspace(x) == true são consumidos a partir do fluxo de entrada.
Para um caráter literal especificador de formato, o próximo caractere é lido e comparado com o caráter literal. Se for igual, é consumido, caso contrário, o processo falha.
Se o especificador de formato "caractere" %c for processado, pelo menos um caractere será lido e atribuído ao argumento de saída. Se nenhum caractere estiver disponível, o processo falhará.
Se o especificador de formato %n for processado, nenhum dado será consumido (e nenhum EOF retornado), mas a posição de leitura atual será retornada.
Como derivado da referência C ++
A função scanf lê a entrada do fluxo apontado por io , sob controle do format da string que especifica as seqüências de entrada admissíveis e como elas devem ser interpretadas, usando argumentos subsequentes para definir o tipo de entrada convertida. O número de argumentos deve corresponder ao número de especificadores de formato exigidos pelo formato.
O formato é composto por zero ou mais diretivas: um ou mais caracteres (ASCII) em espaço branco, um caractere comum (UTF8) (nem '%' nem um caractere de espaço branco (ASCII)) ou uma especificação de conversão. Cada especificação de conversão é introduzida pelo caractere '%' . Após o '%' , o seguinte aparece em sequência:
Um caractere opcional de supressão de atribuição '*' .
Um número inteiro decimal opcional maior que zero que especifica a largura máxima do campo (em caracteres).
Um modificador de comprimento opcional que não é usado por esta implementação.
Um caractere especificador de conversão que especifica o tipo de conversão a ser aplicado.
A função scanf executa cada diretiva do formato por sua vez. Quando todas as diretivas foram executadas, ou se uma diretiva falhar (conforme detalhado abaixo), a função retorna. As falhas são descritas como falhas de entrada (devido à ocorrência de um erro de codificação ou à indisponibilidade de caracteres de entrada) ou falhas correspondentes (devido a entrada inadequada).
Uma diretiva composta por caracteres de espaço em branco é executado pela leitura de entrada até o primeiro caractere não-branco-branco (que permanece não lido) ou até que não haja mais caracteres. A diretiva nunca falha.
Uma diretiva que é um personagem comum é executada lendo o próximo personagem do fluxo. Se esse caractere difere da diretiva, a diretiva falhará e os caracteres diferentes e subsequentes permanecem não lidos. Da mesma forma, se o fim do arquivo, um erro de codificação ou um erro de leitura impede que um caractere seja lido, a diretiva falha.
Uma diretiva que é uma especificação de conversão define um conjunto de sequências de entrada correspondentes, conforme descrito abaixo para cada especificador. Uma especificação de conversão é executada nas seguintes etapas:
Os caracteres de espaço em branco de entrada (conforme especificado pela função isspace ) são ignorados, a menos que a especificação inclua um especificador '[' , 'c' ou 'n' . Esses caracteres de espaço branco não são contados contra uma largura de campo especificada.
Um item de entrada é lido no fluxo, a menos que a especificação inclua um especificador 'n' . Um item de entrada é definido como a sequência mais longa dos caracteres de entrada que não excede nenhuma largura de campo especificada e que é, ou é um prefixo de uma sequência de entrada correspondente.
O primeiro caractere, se houver, após o item de entrada permanecer não lido. Se o comprimento do item de entrada for zero, a execução da diretiva falhará; Essa condição é uma falha correspondente, a menos que o final do arquivo, um erro de codificação ou um erro de leitura impedisse a entrada do fluxo; nesse caso, é uma falha de entrada.
Exceto no caso de um especificador '%' , o item de entrada (ou, no caso de uma diretiva '%n' , a contagem de caracteres de entrada) é convertida em um tipo apropriado ao especificador de conversão e ao argumento correspondente. Se o item de entrada não for uma sequência correspondente, a execução da diretiva falhará: esta condição é uma falha correspondente. A menos que a supressão de atribuição tenha sido indicada por A * , o resultado da conversão é empurrado para a tupla de OPUT.
Se o resultado da conversão não puder ser representado no tipo de saída, um erro de conversão será lançado.
Modificadores de comprimento opcional l , ll , h , hh , L , j , z , t são aceitos antes de todos os caracteres especificadores de tipo, mas de outra forma ignorados.
Os especificadores de conversão e seus significados são:
d corresponde a um número inteiro decimal opcionalmente assinado, cujo formato é o mesmo esperado para a sequência do sujeito da função parse(T, _, base=10) , onde T é o tipo inteiro do argumento.
i corresponde a um número inteiro assinado opcionalmente, cujo formato é o mesmo esperado para a sequência de sujeitos da função parse(T, _, base=nothing) .
o corresponde a um número inteiro octal opcionalmente assinado, cujo formato é o mesmo esperado para a sequência de sujeitos da função parse(T, _, base=8) .
u corresponde a um número inteiro decimal opcionalmente assinado, cujo formato é o mesmo esperado para a sequência de sujeitos da função parse(T, _, base=10) .
x corresponde a um número inteiro hexadecimal assinado opcionalmente, cujo formato é o mesmo esperado para a sequência de sujeitos da função parse(T, _, base=16) .
a , e , f , g corresponde a um número de ponto flutuante opcionalmente assinado, infinity ou NaN , cujo formato é o mesmo esperado para o
Sequência de sujeitos da função parse(T, _) , onde T é um tipo de ponto flutuante.
c corresponde a uma sequência de caracteres exatamente do número especificado pela largura do campo ( 1 se nenhuma largura de campo estiver presente na diretiva). O tipo de argumento deve ser String , Char ou Vector{Char} , se a largura do campo for maior que 1 e um tipo Char for fornecido, apenas o primeiro caractere será armazenado.
s corresponde a uma sequência (não vazia) de caracteres não-brancos. Os tipos de argumento são como para c .
[ Corresponde a uma sequência não vazia de caracteres de um conjunto de caracteres esperados (o scannset). Os tipos de argumento são como para c . O especificador de conversão inclui todos os caracteres subsequentes na sequência do formato, até e incluindo o suporte direito correspondente ( ] ). Os caracteres entre os colchetes (o scanlist) compõem o scannset, a menos que o caractere após o suporte esquerdo seja um circunflexo ( ^ ), caso em que o scannset contém todos os caracteres que não aparecem no scanlist entre o circunflexo e o suporte direito. Se o especificador de conversão começar com [] ou [^] , o caractere do suporte direito estará no scanlist e o próximo caractere de suporte direito a seguir é o suporte direito correspondente que termina a especificação; Caso contrário, o primeiro caractere de suporte direito a seguir é aquele que termina a especificação. Se - caractere está na lista de scan e não é o primeiro, nem o segundo em que o primeiro caractere é A ^ , nem o último caractere, ele define o intervalo entre o caractere deixado de - e o caráter direito de - . A ordem que define o intervalo é o intervalo inteiro de pontos de código Unicode dos caracteres. As faixas vazias (como ba ) são ignoradas.
p corresponde a um conjunto de seqüências, as mesmas do conjunto de seqüências que podem ser produzidas pela conversão %p da função printf . O argumento correspondente deve ser do tipo Ptr{T} onde t pode ser qualquer tipo. O item de entrada é convertido em um valor de ponteiro de maneira definida pela implementação. Se o item de entrada for um valor convertido anteriormente durante a mesma execução do programa, o ponteiro que os resultados deve comparar igual a esse valor; Caso contrário, o comportamento da conversão %p é indefinido.
n Nenhuma entrada é consumida. O argumento correspondente deve ser um tipo inteiro, no qual é convertido o número de caracteres lidos no fluxo de entrada até agora por essa chamada para a função scanf . A execução de uma diretiva %n também incrementa a contagem de atribuições retornada na conclusão da execução da função scanf . Se a especificação de conversão incluir um caractere supressor de atribuição, nenhum argumento será consumido. Um campo de largura opcional é ignorado.
% Corresponde a um único caractere '%' ; nenhuma conversão ou atribuição ocorre. A especificação completa de conversão é %% . (Com outras palavras, %% é tratado como um único caráter comum % .
Se uma especificação de conversão for inválida, o comportamento será indefinido.
Os especificadores de conversão A , E , F , G e X também são válidos e se comportam da mesma forma que, respectivamente, a , e , f , g e x
O espaço branco à direita (incluindo caracteres de linha novo) é deixado sem lido, a menos que corresponda por uma diretiva. O sucesso de correspondências literais e atribuições suprimidas não é diretamente determinável, exceto na diretiva %n .
