O desafio

Escreva um programa que produz Hello World, from line X!, onde Xestá o número da linha, no código-fonte, da própria declaração de impressão.

As regras

• Nesse contexto, queremos que o primeiro número da linha da instrução que gera a string seja exibido parastdout
• Você deve evitar simplesmente pesquisar seu código-fonte como uma string (arquivo ou quine) para encontrar o número da linha
• Se qualquer espaço em branco ou instrução adicional (que não interrompa o fluxo do código) for adicionado ao código-fonte, ele deverá ser refletido no tempo de execução (após a compilação, se aplicável)

Recomendações

Se fornecido pelo idioma, você poderá usar exceções / rastreamentos de pilha para atingir esse objetivo. Tente o seu melhor para usar um código portátil em diferentes sistemas / implementações, mas observe que isso não é um requisito. O uso de variáveis ​​definidas como __LINE__, embora permitido pelas regras, é desencorajado.

O vencedor

• Este é um concurso de popularidade (encerrado em 10 de junho de 2014), em que a resposta mais votada pela comunidade será declarada vencedora com base nos votos atuais no momento

• Ao votar, considere a criatividade da resposta de alguém, quão elaborada ou interessante é. e as dificuldades / restrições da linguagem de programação que está sendo usada

Sinclair Basic

10 PRINT "Hello world, from line ";PEEK 23621;"!"

Olá mundo, da linha 10!

Isso funcionará para qualquer linha PEEKinserindo o endereço que armazena o número da linha atual; portanto, o seguinte também funcionará:

341 PRINT "Hello world, from line ";PEEK 23621;"!"

Olá mundo, da linha 341!

BASIC

Eu acho que isso faz tudo o que foi solicitado:

10 PRINT "Hello World, from line 10!"

Java

public class Hello{
    public static void main(String[] args) {
        System.out.println("Hello World, from line "+new Exception().getStackTrace()[0].getLineNumber()+"!");
    }
}

Perl

close STDERR;
open FOOBAR,">",\$_;


print!warn,'Hello World, from line ',/(\d+)\.$/,'!';

Não é tão curto quanto usar __LINE__, mas talvez mais interessante.

warné uma ferramenta de depuração, que emite uma declaração STDERRindicando em qual arquivo e em qual linha o aviso foi emitido ... a menos que STDERR tenha sido fechado anteriormente ou esteja inacessível, caso em que o aviso será emitido para o arquivo aberto mais recentemente handle - esse é um comportamento não documentado. Não tenho certeza se seria melhor classificado como um recurso ou um bug.

Aqui, STDERRé fechado e um novo identificador de arquivo identificado como FOOBARé aberto e roteado para a variável $_. Isso é analisado para recuperar o número da linha do aviso, incorporado na instrução print.

C ++

#include <iostream>
#include <utility>
#include <type_traits>

#define __(A,B,C,...) B##C##A
#define _(A,...) __(__VA_ARGS__, A)
template<unsigned...Is> struct v;
template<unsigned I0, unsigned... Is> struct v<I0, Is...>:v<I0-1,I0-1, Is...> {};
template<unsigned...Is> struct v<0,Is...>:std::integral_constant<unsigned, sizeof...(Is)> {};

int main() {
  std::cout << "Hello world from line " << v<_(EXTRACT,_(Q,_,E,_,$$main$$,),_(@22,,_,_),_(Z,N,L,I,_,,L),__STACK_TRACE__)>::value << "\n";
}

exemplo ao vivo

Lua

print("Hello world, from line "..debug.getinfo(1).currentline.."!")

C #

O C # 5.0 [CallerLineNumber]faz o truque:

using System;
using System.Linq;
using System.Runtime.CompilerServices;
namespace LineNumberConsole
{
    class Program
    {
        public static void Main()
        {
            Console.WriteLine("Hello World, from line {0}!", ToRoman(GetLineNumber()));
            Console.ReadLine();
        }

        private static int GetLineNumber([CallerLineNumber] int sourceLineNumber = 0)
        {
            return sourceLineNumber;
        }

        private static string ToRoman(int number)
        {
            // TODO: Copy some source code from http://pastebin.com/w0hm9n5W
            // Skipped here for brevity
            return number.ToString();
        }
    }
}

Saída

Hello World, from line X!

C

#include <stdio.h>
main(){
printf("Hello World, from line %d!", __LINE__);
}

Python

Exemplo (10 linhas, 213 caracteres):

import sys
import traceback
lineno = None
while True:
    try:
        print 'Hello World, from line %d!' % lineno
        break
    except:
        lineno = traceback.tb_lineno(sys.exc_info()[2])
        continue

Experimente online aqui . Código e espaço em branco que não alteram o fluxo podem ser adicionados e o programa exibirá a contagem de linhas atualizada e, da mesma forma, esse trecho de código também pode ser usado em qualquer lugar de um programa existente. Saída esperada:

Hello World, from line 6!

Outro exemplo (tente online aqui) para mostrar que funciona quando código / espaço em branco é adicionado. Saída esperada:

Down we go...
Gotta catch 'em all.
Down we go...
Hello World, from line 11!
Awesome!

Javascript

function getLine(n) {
   try {
      to
   } catch (dat) {
      var stack = dat.stack.split('\n');
       for (var i = 0; i < stack.length; i++) {
           if (~stack[i].indexOf ('getLine')) break;          
       }
      return dat.stack.split ('\n')[i + ~~n].match (/:(\d+)/)[1] - ~~window.hasOwnProperty ('__commandLineAPI')
   }
}
//Line 12
console.log ('Hello World, from line ' + getLine(1) + ' !')

Nota: As expressões avaliadas no console do desenvolvedor do chrome serão agrupadas em uma withinstrução Portanto, precisamos diminuir a linha por um, se for esse o caso

Python 3

import hashlib
with open(__file__) as f:
    line_num = 0
    for line in f.readlines():
        line = line.rstrip() # make it work with or without newline at the end
        line_num += 1
        if hashlib.sha256(bytes(line, "UTF-8")).hexdigest()[0:6] == 'cc46f7':
            print('Hello world, from line {}!'.format(line_num)) # cc46f7

Olá mundo, da linha 8!

Esse código de leitura automática contém um hash de referência própria. A soma SHA256 da última linha (com o espaço em branco inicial e sem espaço em branco à direita) começa com cc46f7... . Quando faz o hash da printlinha, descobre que o hash corresponde ao valor mágico que está procurando.

GNU COBOL

Bem, eles disseram que não poderia ser feito. Na verdade, fui eu quem disse que não poderia ser feito. Agora está pronto e um recurso de linguagem obsoleta reimplementado usando o método aplicado.

A pergunta afirma:

Se qualquer espaço em branco ou instrução adicional (que não interrompa o fluxo do código) for adicionado ao código-fonte, ele deverá ser refletido no tempo de execução (após a compilação, se aplicável).

Qualquer quantidade de material pode ser inserida antes dos três DISPLAYs que causam o início da saída e qualquer coisa após os DISPLAY"interromperia o fluxo do código", então tudo bem.

O COBOL costumava ter um TRACEverbo (instrução) que simplesmente listava os números das linhas de origem conforme eram executados (sem acesso ao número da linha no programa). Embora de uso limitado, incluí uma implementação do TRACE.

   ID Division.
   Program-ID. HIWHERE.
   ENVIRONMENT DIVISION.
   configuration section.
          source-computer. TinkerToy with debugging mode.
   Procedure Division.
   Declaratives.
   Debug-Declaratives Section.
       Use For Debugging on a b
       .
   Debug-Declaratives-Paragraph.
       Display Debug-Line "!"
       .
   End Declaratives
       .
   Main-Program Section.
       DISPLAY "Perform"
       Display "Hello World, from line " no advancing Perform b
       display "GO TO"
       Display "Hello World, from line " no advancing GO TO a
       .
   a.
       dISPLay "Fall through"
       Display "Hello World, from line " no advancing. b.
   The-Last-bit-OF-the-PROGRAM.
       GOBACK
       .

A saída é

Perform
Hello World, from line     18!
GO TO
Hello World, from line     20!
Fall through
Hello World, from line     23!

Como uma demonstração do poder e da flexibilidade de escrever a linguagem, este exemplo usa letras maiúsculas, minúsculas e totalmente maiúsculas, tudo ao mesmo tempo. Não importa, pois quando processado, tudo é "dobrado" para MAIÚSCULAS.

A única maneira padrão de COBOL de obter um número de linha de origem no programa em execução, a partir do programa em execução, é com a DEBUGGING DECLARATIVE. Dentro de SECTION, estritamente dentro de um parágrafo dentro de SECTION, de um declarativo, você tem acesso ao registro especial DEBUG-LINE. Contém o número da linha de origem do verbo (instrução) que causou a transferência do controle para um nome de procedimento específico (parágrafo ou SECTION).

Portanto, com PERFORM, ou GO TO, ou "falha", o parágrafo nos declarativos de depuração SECTIONé executado.

OK, mas DISPLAYnão causa transferência de controle.

Sem problemas. Coloque-o na mesma linha da transferência de controle.

Problema, pois se "qualquer espaço em branco ou instrução adicional (que não interrompa o fluxo do código) for adicionado ao código-fonte, ele deverá ser refletido no tempo de execução (após a compilação, se aplicável)".

Portanto, coloque-o na mesma linha, mas na frente de uma transferência de controle, divida o conteúdo do arquivo DISPLAYem duas partes (lembre-se: "Nesse contexto, queremos o primeiro número da linha da instrução que gera a string a ser exibida" ) e produza a primeira parte antes da transferência do controle e a segunda parte do DEBUG-LINE, uma vez dentro do procedimento de depuração.

O truque final é para o "fall through" ("procedures" podem ser PERFORMeditados, podem ser o alvo de um GO TOou podem ser inseridos simplesmente sendo a próxima linha). Nesse caso, coloque o DISPLAY na linha que define o procedimento, mas na frente da definição .

Os nomes dos "procedimentos" ( ae b) foram severamente abreviados para permitir que eles se ajustem à mesma linha de origem que a DISPLAY. Estritamente, um nome de procedimento COBOL deve começar em algum lugar da coluna oito à coluna 11. No entanto, atualmente, a sintaxe é muito mais tranqüila quanto a isso. Na medida em que eu possa definir um nome de procedimento na mesma linha que algum código. Inclusive incorporado no código. É necessário cuidado e um ponto final ocasional.

Em PROCEDURE DIVISIONcada ponto final mostrado é necessário, e não mais.

Compilar:

cobc -x -g hiwhere.cbl

Para executar (linux):

COB_SET_DEBUG=Y ./hiwhere

Finalmente, o retorno do TRACE (sem READY / RESET).

   ID Division.
   Program-ID. tRacE.
   ENVIRONMENT DIVISION.
   configuration section.
          source-computer. TinkerToy with debugging mode.
   Procedure Division.
   Declaratives.
   Debug-Declaratives Section.
       Use For Debugging on a
       .
   Debug-Declaratives-Paragraph.
       Display Debug-Line
       .
   End Declaratives
       .
   Main-Program Section.
  *    Just append "perform a" to a single-line statement.
       DISPLAY "1" . perform a
       Display "2" . perform a
       display "3" . perform a
  *    Or prepend "perform a." for a multi-line statement, or a
  *    statement which won't "come back". 
       perform a. GOBACK
       .
   a.
       CONTINUE
       .

A saída é:

1
    17
2
    18
3
    19
    20

Onde 1, 2 e 3 são emitidos pelas três instruções DISPLAY, e 17, 18, 19 e 20 são os números de linha das linhas "executáveis" (sem depuração).

Java

Usando o comportamento do rastreamento de pilha do Exception para obter a linha atual. contanto que a declaração de impressão não seja mutilada em várias linhas ou o arquivo de classe seja mutilado, deve funcionar

public class PrittLnbr
{
    public static void main(String[] args)
    {
        System.out.println("Hello World, from line "+new Error().getStackTrace()[0].toString().split(":")[1]+"!");
    }
}

Python

import traceback, inspect
frame = inspect.currentframe()
print("Hello World, from line "+traceback.format_stack(frame)[0].split()[3][:-1]+"!")  

Perl

print 'Hello World, from line '.__LINE__.'!';

Java

public class HelloFrom {
    public static void main(String[] args) {
        System.out.println("Hello World, from line " + Thread.currentThread().getStackTrace()[1].getLineNumber() + "!");
    }
}

Python

import inspect
print ("Hello world from line %d!" % (inspect.getlineno(inspect.currentframe())))

Saída

Hello World from line 2!

Befunge

Feito apenas por diversão.

>00g1+:00p"v"\10v  
    v-*45g00p\g <  
#v+1_$10g1vv,,,,<  
^<p000p01+<#>,,,^  
>" enil morf ,oll"v
@.,,,,,,,,,<^,"He"<

Condicional: o canto superior esquerdo do código deve ser 0 <x <20 e 0 <= y <62; e as duas primeiras células precisam estar vazias.

exemplo:

                         v                  

                         0                  
                         0                  
                         0                  
                         p                  
                         0                  
                         1                  
                         0                  
                         p                  
                         >00g1+:00p"v"\10v  
                             v-*45g00p\g <  
                         #v+1_$10g1vv,,,,<  
                         ^<p000p01+<#>,,,^  
                         >" enil morf ,oll"v
                         @.,,,,,,,,,<^,"He"<

Saída:

Olá, da linha 10

C

Usando uma macro variável, podemos criar uma função de impressão que adiciona automaticamente o número da linha ao final de uma instrução arbitrária printf, e sempre imprime no stdout.

test.c:

#include <stdio.h>

#define printfl(format, ...) fprintf(stdout, format " From line %d\n", ##__VA_ARGS__, __LINE__)

int main() {
    printfl("Hello World! I have %d argument(s).", 1);
    return 0;
}

saídas:

% ./test
Hello World! I have 1 argument(s). From line 6

Nota: Eu me desviei do padrão para demonstrar que printfl ainda é uma função variável válida; se você realmente se importa com o formato da saída, sempre pode alterar os literais que eu uso.

Bater

#
# some comments to fill some lines...
#
echo "Hello World, from line $LINENO!"

Saída

Hello World, from line 4!

D

void main ()
{
    import std.stdio;
    writefln("Hello World, from line %d", __LINE__);
}

C ou C ++ e AWK

lineno.c:

// code or comments
// ....
#error Hello World, from line
// other code or comments

Uso:

gcc lineno.c 2>&1 | awk '{ split($0,a,":"); ; printf("%s %s!\n", gensub(".*#error ","",1), a[2]); exit; }'

Saída:

Olá Mundo, da linha 3

Notas:

• Nenhum código gravado pelo usuário pesquisa o arquivo.
• O g ++ funcionará em um arquivo c ++.

Tipo de chato em Ruby:

puts "Hello World, from line #{__LINE__}!"

Isso não é trapaça, certo?

Javascript

Uma linha usando rastreamento de pilha.

(function (o) { console.log("Hello World, from line " + (Error.captureStackTrace(o) || o.stack.match(/\d+/)[0] - !!__commandLineAPI) + "!"); })({});

Cobra

class Program
    def main
        print 'Hello World, from line [System.Diagnostics.StackFrame(true).getFileLineNumber]!'

Rubi

File.write "hello.rb", "x=2\n"+"x+=1\n"*rand(rand(100))+'puts "Hello World, from line #{x}!"'
system "ruby hello.rb"
File.delete "hello.rb"

PowerShell

Movimento barato

Function LemmeGetDatError() {
    "Too busy chuggin along"
    "Then all of a sudden, I meet a new programmer"
    "And he's all like"
    Write-Output "$(Try {"Hello World from"; Throw "error" } Catch {$_.ScriptStackTrace.Split(":")[1]})"
}

LemmeGetDatError

Powershell

$l=(Get-PSCallStack | ForEach{$_.Location})[0].split(' ')[-1]; "Hello World, from line $l!"

E:

try{ I AM ERROR. } catch { $l=$error[0].InvocationInfo.ScriptLineNumber; "Hello World, from line $l!" }

Ambos funcionam assim:

PS C:\MyFolder> .\helloworld.ps1
Hello World, from line 1!

Python

import traceback

print 'Hello World, from line %i!' % traceback.extract_stack()[0][1]

Curto e grosso.

Perl

Outro Perl:

use warnings;

$SIG{__WARN__} = sub { ($line = shift) =~ s/\D//g; };

$x=$x+1; print "Hello World, form line $line!\n";