Número da linha - Line number

Na computação , um número de linha é um método usado para especificar uma sequência particular de caracteres em um arquivo de texto . O método mais comum de atribuição de números a linhas é atribuir a cada linha um número exclusivo, começando em 1 para a primeira linha e aumentando em 1 para cada linha sucessiva.

Na linguagem de programação C , o número da linha de uma linha do código-fonte é um número maior de caracteres de nova linha lidos ou introduzidos até aquele ponto.

Os programadores também podem atribuir números de linha a instruções em linguagens de programação mais antigas , como Fortran , JOSS e BASIC . No Fortran, nem todas as instruções precisam de um número de linha, e os números de linha não precisam estar em ordem sequencial. O objetivo dos números de linha era para ramificação e para referência por instruções de formatação.

Tanto o JOSS quanto o BASIC tornaram os números de linha um elemento obrigatório da sintaxe . A principal razão para isso é que a maioria dos sistemas operacionais da época não tinham editores de texto interativos ; uma vez que a interface do programador era geralmente limitada a um editor de linha , os números de linha forneciam um mecanismo pelo qual linhas específicas no código-fonte podiam ser referenciadas para edição e pelo qual o programador podia inserir uma nova linha em um ponto específico. Os números de linha também fornecem um meio conveniente de distinguir entre o código a ser inserido no programa e os comandos de modo direto a serem executados imediatamente quando inseridos pelo usuário (que não têm números de linha).

Em grande parte devido à prevalência da edição de texto interativa em sistemas operacionais modernos , os números de linha não são uma característica da maioria das linguagens de programação, mesmo Fortran e Basic modernos.

História

FORTRAN

Em Fortran , conforme especificado pela primeira vez em 1956, os números de linha eram usados ​​para definir padrões de entrada / saída, para especificar instruções a serem repetidas e para ramificação condicional. Por exemplo:

   DIMENSION ALPHA(25), RHO(25)
1) FORMAT(5F12.4)
2) READ 1, ALPHA, RHO, ARG
   SUM = 0.0
   DO 3 I=1, 25
   IF (ARG-ALPHA(I)) 4,3,3
3) SUM = SUM + ALPHA(I)
4) VALUE = 3.14159*RHO(I-1)
   PRINT 1, ARG, SUM, VALUE
   GO TO 2

Como a linguagem assembler antes dela, o Fortran não presumia que todas as linhas precisassem de um rótulo (número da linha, neste caso). Apenas as declarações mencionadas em outro lugar exigiam um número de linha:

• A linha 1 especifica um padrão de formato para entrada; o READcomando na linha 2 e o PRINTcomando posterior fazem referência a essa linha.
• O DOloop executa a linha 3.
• A instrução aritmética IF desvia para a linha 4 em um valor negativo, linha 3 em zero e novamente a linha 3 em um valor positivo.

Embora os números das linhas sejam sequenciais neste exemplo, no primeiro "programa completo, mas simples [Fortran]" publicado, os números das linhas estão na sequência 1, 5, 30, 10, 20, 2.

Os números de linha também podem ser atribuídos a variáveis ​​de ponto fixo (por exemplo, ASSIGN i TO n ) para referência em instruções GO TO atribuídas subsequentes (por exemplo, GO TO n, (n1, n2, ... nm) ).

COBOL

No COBOL , os números de linha eram especificados nos primeiros seis caracteres (a área do número de sequência ) dos cartões perfurados . Isso foi originalmente usado para facilitar a classificação mecânica de cartões para garantir a sequência de código do programa desejada após o manuseio manual. Os números das linhas foram realmente ignorados pelo compilador.

NARCÓTICO

Em 1962, DOPE (Dartmouth Oversimplified Programming Experiment) tornou-se uma das primeiras linguagens de programação a exigir um número de linha para cada instrução e a usar a ordem sequencial dos números de linha. Os números de linha foram especificados como destinos para dois comandos, C (operação de comparação, um IF aritmético) e T (operação para, um GO TO).

JOSS

Em 1963, o JOSS tornou , de forma independente, os números de linha obrigatórios para cada instrução em um programa e ordenou as linhas em ordem sequencial. O JOSS introduziu a ideia de um único editor de linha de comando que funcionava tanto como uma linguagem interativa quanto como um editor de programa. Os comandos digitados sem um número de linha foram executados imediatamente, no que o JOSS chamou de "modo direto". Se a mesma linha foi prefixada com um número de linha, ele foi copiado para a área de armazenamento do código do programa, que o JOSS chamou de "modo indireto".

Ao contrário do FORTRAN antes dele ou do BASIC depois dele, o JOSS exigia que os números de linha fossem números de ponto fixo consistindo em um par de inteiros de dois dígitos separados por um ponto (por exemplo, 1,1). A parte do número da linha à esquerda do ponto é conhecida como "página" ou "parte", enquanto a parte à direita é conhecida como "linha"; por exemplo, o número da linha 10.12refere-se à página 10, linha 12. Os ramos podem ter como alvo uma página ou uma linha dentro de uma página. Quando o formato posterior é usado, a página e a linha combinadas são conhecidas como "etapa".

As páginas são usadas para definir sub-rotinas , que retornam quando a próxima linha está em uma página diferente. Por exemplo, se uma sub-rotina para calcular a raiz quadrada de um número está na página 3, pode-se ter três linhas de código 3.1, 3.2 e 3.3, e seria chamada usando Do part 3.O código retornaria à instrução após o Do quando chega à próxima linha em uma página diferente, por exemplo, 4.1. Não há necessidade do equivalente a RETURNa no final, embora, se um retorno antecipado for necessário, Doneisso seja feito. Exemplo:

*Routine to ask the user for a positive value and repeat until it gets one
01.10 Demand X as "Enter a positive value greater than zero".
01.20 Done if X>0.
01.30 To step 1.1

BASIC

Introduzido em 1964, o Dartmouth BASIC adotou números de linha obrigatórios, como no JOSS, mas os tornou inteiros, como no FORTRAN. Conforme definido inicialmente, o BASIC usava apenas números de linha para GOTOe GOSUB(vá para a sub-rotina e retorne). Alguns BÁSICOS minúsculos implementações suportado expressões numéricas, em vez de constantes, enquanto instruções switch estavam presentes em diferentes dialetos ( ON GOTO; ON GOSUB; ON ERROR GOTO).

Os números das linhas raramente eram usados ​​em outros lugares. Uma exceção era permitir que o ponteiro usado por READ(que iterava por meio de DATAinstruções) fosse definido para um número de linha específico usando RESTORE.

  1 REM RESTORE COULD BE USED IF A BASIC LACKED STRING ARRAYS
  2 DIM M$(9): REM DEFINE LENGTH OF 9 CHARACTERS
  5 INPUT "MONTH #?"; M: IF M<1 OR M>12 THEN 5
  7 RESTORE 10*M: READ M$: PRINT M$
 10 DATA "JANUARY"
 20 DATA "FEBRUARY"
 30 DATA "MARCH"
 ...

Nas primeiras edições do Dartmouth BASIC, THENsó podia ser seguido por um número de linha (para um GOTO implícito ), não - como em implementações posteriores - por uma instrução.

O intervalo de números de linha válidos variou amplamente de implementação para implementação, dependendo da representação usada para armazenar o equivalente binário do número de linha (um ou dois bytes; com ou sem sinal). Enquanto o Dartmouth BASIC suportava 1 a 99999, a implementação típica de microcomputador suportava 1 a 32767 (uma palavra de 16 bits com sinal).

Números de linha e estilo

Era uma questão de estilo de programação , se não de necessidade absoluta, nessas linguagens deixar lacunas entre números de linha sucessivos - ou seja, um programador usaria a sequência (10, 20, 30, ...) em vez de (1, 2, 3, ...). Isso permitiu ao programador inserir uma linha de código posteriormente. Por exemplo, se uma linha de código entre as linhas 20 e 30 foi omitida, o programador pode inserir a linha esquecida na linha número 25. Se nenhuma lacuna foi deixada na numeração, o programador seria obrigado a renumerar a linha 3 e todas as subseqüentes linhas para inserir a nova linha após a linha 2. Claro, se o programador precisasse inserir mais de nove linhas adicionais, a renumeração seria necessária mesmo com a numeração mais esparsa. No entanto, essa renumeração seria limitada à renumeração de apenas 1 linha por dez linhas adicionadas; quando o programador descobre que precisa adicionar uma linha entre 29 e 30, apenas a linha 30 precisa ser renumerada e a linha 40 pode ser deixada inalterada.

Alguns BASICs tinham um comando RENUM , que normalmente percorria o programa (ou uma parte específica dele), reatribuindo números de linha em incrementos iguais. Isso também renumeraria todas as referências a esses números de linha para que continuassem a funcionar corretamente.

Em um grande programa que contém sub-rotinas , cada sub-rotina geralmente começa em um número de linha suficientemente grande para deixar espaço para a expansão do programa principal (e sub-rotinas anteriores). Por exemplo, as sub-rotinas podem começar nas linhas 10000, 20000, 30000, etc.

Números de linha e GOTOs

Em linguagens de programação "não estruturadas", como BASIC , os números de linha eram usados ​​para especificar os destinos das instruções de ramificação . Por exemplo:

1 S=0: N=-1
2 INPUT "ENTER A NUMBER TO ADD, OR 0 TO END"; I
3 S=S+I: N=N+1: IF I<>0 THEN GOTO 2
4 PRINT "SUM="; S: PRINT "AVERAGE="; S/N

A ramificação no estilo GOTO pode levar ao desenvolvimento de código espaguete . (Veja Considerado prejudicial , Programação estruturada .) Mesmo em algumas versões posteriores do BASIC que ainda exigiam números de linha, o uso de GOTOs controlados por número de linha foi eliminado sempre que possível em favor de construções mais limpas, como o loop for e o loop while .

Muitas linguagens modernas (incluindo C e C ++ ) incluem uma versão da instrução GOTO; entretanto, nesses idiomas, o destino de um GOTO é especificado por um rótulo de linha em vez de um número de linha.

Números de linha e erros de sintaxe

Se um programador introduzir um erro de sintaxe em um programa, o compilador (ou interpretador ) informará ao programador que a tentativa de compilar (ou executar) falhou no número de linha fornecido. Isso simplifica o trabalho de encontrar o erro imensamente para o programador.

O uso de números de linha para descrever a localização de erros permanece padrão nas ferramentas de programação modernas, embora os números de linha nunca precisem ser especificados manualmente. É uma questão simples para um programa contar as novas linhas em um arquivo de origem e exibir um número de linha gerado automaticamente como a localização do erro. Em IDEs como Microsoft Visual Studio , Eclipse ou Xcode , em que o compilador costuma estar integrado ao editor de texto, o programador pode até clicar duas vezes em um erro e ser levado diretamente para a linha que contém esse erro.

Veja também

• Etiqueta de linha
• Listagem (computador)

Referências