Long literals, with continuations: Difference between revisions

{{trans|Python}}

V elements =

print(‘Last revision date: ’revdate)

print(‘Number of elements: ’items.len)

{{out}}

There is no need for continuation codes, as the language interprets a contiguous data block as a single entity, whether you intended it to be or not. If you had two consecutive strings embedded in the code and you forgot the null terminator on the first one, trying to print just the first string would print both. For example:

db "Hello World" ;no null terminator

GoodbyeString:

db "Goodbye World!",0

The output would be as follows, assuming the <code>PrintString</code> routine uses a null terminator to know when a string ends:

<pre>

Since each string is of variable length, it is much easier to make a lookup table of the elements ordered by atomic number, with each element in the lookup table being a pointer to the actual string consisting of that element's name.

dw nullString

; a constant value that cannot change at runtime.

; This counts the number of bytes between the two labels, and automatically adjusts when the size of the list changes.

The required output can be obtained like so:

STA z_L ;store it in z_L, a zero page memory address

LDA #>RevisionDate ;get the high byte

LDA ElementNull+1,x

STA z_H

This routine can be expanded as new elements are discovered, but once the 128th element is discovered it will need to be reprogrammed since you can't offset more than x=255. This is actually a very simple fix, and can be accomplished by splitting the table as such:

db <hydrogen,<helium,<lithium,<beryllium,<boron,<carbon,<nitrogen,<oxygen,<fluorine,...

Elements_Hi:

Note that < and > are unary operators that mean "the low byte of" and "the high byte of", respectively. By storing the halves of each pointer in two separate tables, sharing a common index, we can index up to 256 elements rather than 128, without increasing the total data size of the tables.

There is no need for continuation codes, as the language interprets a contiguous data block as a single entity, whether you intended it to be or not. If you had two consecutive strings embedded in the code and you forgot the null terminator on the first one, trying to print just the first string would print both. For example:

DC.B "Hello World" ;no null terminator

GoodbyeString:

EVEN

The output would be as follows, assuming the <code>PrintString</code> routine uses a null terminator to know when a string ends:

<pre>

Since each string is of variable length, it is much easier to make a lookup table of the elements ordered by atomic number, with each element in the lookup table being a pointer to the actual string consisting of that element's name.

DC.L nullString

Elements:

; a constant value that cannot change at runtime.

; This counts the number of bytes between the two labels, and automatically adjusts when the size of the list changes.

The required output can be obtained like so:

JSR PrintString ; unimplemented printing routine

JSR NewLine ; unimplemented new line routine

MOVEA.L (A2,D1),A3

;dereference the pointer, offsetting by D1. This retrieves the address of the desired element in the list.

This routine can easily be expanded for more elements. With a maximum offset of 16,383, it's unlikely that the table will get too large to properly index anytime soon.

===Using concatenations===

elementString:

print ["Last revision date:" revDate]

print ["Number of elements:" size elements]

{{out}}

===Using string blocks===

elementString: {

print ["Last revision date:" revDate]

print ["Number of elements:" size elements]

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f LONG_LITERALS_WITH_CONTINUATIONS.AWK

BEGIN {

revised = "30JUN2020"

}

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

ultimaRevision$ = "2021-11-12"

arraybase 1

print "Last element : "; elemento$[elemento$[?]]

end

{{out}}

<pre>

=={{header|Crystal}}==

Crystal's <code>%w</code> literals create a whitespace-delimited array of strings at compile time

last_revision = Time.utc year: 2021, month: 2, day: 25

puts last_revision.to_s "last revised %B %e, %Y"

puts "number of elements: #{element_list.size}"

=={{header|Delphi}}==

{{libheader| System.StrUtils}}

{{Trans|Free Pascal}}

program Long_literals_with_continuations;

writeln(words[high(words)]);

readln;

{{out}}

<pre>Last update: 2020-11-11

The convention in Factor is to limit lines to 64 characters wide if possible. This constraint is sometimes waived for large literals, but it was easy enough to accommodate here.

{{works with|Factor|0.99 2020-03-02}}

qw{

"Last revision: %s\n" printf

[ length ] [ last ] bi

{{out}}

<pre>

ANSI strings are pointers to sequences of characters.

The data type includes a reference count and a (4-Byte long) <tt>length</tt> field.

program longStringLiteralDemo(output);

elementString, stdWordDelims));

end.

{{out}}

<pre>

=={{header|FreeBASIC}}==

Dim As String ultimaRevision = "2021-11-12"

Dim As String elemento(0 to ...) => { _

Print "Last element : "; elemento(Ubound(elemento))

Sleep

{{out}}

<pre>

=={{header|Go}}==

import (

lix := strings.LastIndex(elements2, " ") // get index of last space

fmt.Println("Last element : ", elements2[lix+1:])

{{out}}

=={{header|Haskell}}==

\ fluorine neon sodium magnesium \

\ aluminum silicon phosphorous sulfur \

\ meitnerium darmstadtium roentgenium copernicium \

\ nihonium flerovium moscovium livermorium \

<pre>*Main> length elements

=={{header|jq}}==

# To add chemical elements, modify the CHEMICAL_ELEMENTS function,

# ensuring that the date is updated properly and that there is at least one

"Last element in list: \($a[-1])";

Invocation: jq -nrf program.jq

{{out}}

The task does not as of the current revision mention lower versus upper case, but the below is corrected per a request anyway.

The task does ask to comment on which column code may start. The start column for code does not matter to Julia, or to most modern computer language compilers, other than in some cases (not string data) Python.

# FOR FUTURE EDITORS:

report()

<pre>

File last revised (formatted as dateTtime): 2020-03-24T02:48:55.421 GMT

Kotlin has raw string literals with <code>"""</code>. It does not (yet) have a native date/time library, so we use Java’s here.

const val elementsChunk = """

println("Last element : ${elementsList.last()}")

println("The elements are : ${elementsList.joinToString(" ", limit = 5)}")

{{out}}

=={{header|Lua}}==

-- the long literal string is delimited by double square brackets: [[...]]

-- each word must be separated by at least one whitespace character

-- then, if still required, produce a single-space-between string version:

{{out}}

<pre>revised date: February 2, 2021

===Using concatenations===

const RevDate = "2021-02-05"

echo "Last revision date: ", RevDate

echo "Number of elements: ", ElementList.len

{{out}}

===Using a long literal string===

const RevDate = "2021-02-05"

echo "Last revision date: ", RevDate

echo "Number of elements: ", ElementList.len

{{out}}

=={{header|Perl}}==

Mostly pointless...

use strict; # https://rosettacode.org/wiki/Long_literals,_with_continuations

element count: $count

last element: $last

{{out}}

<pre>

You could also, like Julia, use get_file_date(command_line()[2]) instead of the hand-written last_updated constant. Phix code is free-format, indent things however you like, there is no specific maximum line length.

<span style="color: #008080;">constant</span> <span style="color: #000000;">last_updated</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"March 24th, 2020"</span><span style="color: #0000FF;">,</span>

<span style="color: #000000;">elements_text</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">`

"""</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">last_updated</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">elements</span><span style="color: #0000FF;">),</span><span style="color: #000000;">elements</span><span style="color: #0000FF;">[$]})</span>

{{out}}

=={{header|PureBasic}}==

"nitrogen oxygen fluorine neon sodium magnesium " +

"aluminum silicon phosphorous sulfur chlorine argon " +

~"\nLast element: "+result$(nbf-1))

Input()

{{out}}

<pre>Last revision: 2020-11-11

=={{header|Python}}==

revision = "October 13th 2020"

if __name__ == "__main__":

report()

{{out}}

=={{header|Quackery}}==

[ stack ] is last-revision ( --> $ )

$ "6 Jun 2021" last-revision put

say "Number of elements: " elementcount echo cr

say "Last element: " finalelement echo$ cr

{{out}}

Not really sure I understand the point of this task. Seems to be load some list into memory and manipulate it somehow. Exceptionally boring to just read it in and then read it back out again. Perform some more interesting manipulations. Use < > quoting construct for literal string; unlimited (memory limited) characters, spaces don't matter, new-lines don't matter, blank lines don't matter.

%periodic<revision-date> = Date.new(2020,3,23);

%periodic<table> = |<

put 'Symbols for elements whose name starts with "P": ', %periodic<table>.grep( *.<name>.starts-with('P') )».<symbol>;

put "Elements with molecular weight between 20 & 40:\n ",%periodic<table>.grep( {+.<weight> ~~ Numeric and 20 < .<weight> < 40} )».<name>;

{{out}}

<pre>Revision date: 2020-03-23

Most modern REXXes have no practical limit for a clause length.

/*──────────────────────── ordered by their atomic number) in a list format. */

#= words(elements) /*the number of elements " " " */

say 'number of elements in the list: ' # /*show " " " " " " */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

The REXX version uses concatenation (also called abutment) to build the list.

/*──────────────────────── ordered by their atomic number) in a list format. */

#= words(elements) /*the number of elements " " " */

say 'number of elements in the list: ' # /*show " " " " " " */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ruby}}==

hydrogen helium lithium beryllium

boron carbon nitrogen oxygen

number of elements: #{elements.size}

last element: #{elements.last}"

{{out}}

<pre>Last mutation 2021-08-30 17:14:16 +0200

=={{header|Standard ML}}==

val elements = "\

\last element:\t" ^ List.last lst ^ "\n")

{{out}}

<pre>revision date: 2021-02-25

=={{header|Tcl}}==

Using the neatly formatted table from other languages (can be reformatted easily using the non-standard utility column with option -t).

set elements {

hydrogen helium lithium beryllium

puts "Last modification time: $mtime"

puts "Number of elements: [llength $elements]"

{{out}}

<pre>Last modification time: 2021-05-10 16:11:50

are sufficient to extend it across as many lines as needed:

main() {

elements=(

printf 'Latest element: %s\n' "${elements[-1]}"

}

{{Out}}

The rows can begin in any column though, for a tidy display, we begin them all here in column 5.

var elementStr =

System.print("Last updated : %(lastUpdate)")

System.print("Number of elements : %(elements.count)")

{{out}}

(by default). To turn that into one string with one space between each item,

use: elements.concat(" ")

elements:=

#<<<"

#<<<

println("Revision date: ",revisionDate);

{{out}}

<pre>