Quoting constructs: Difference between revisions

The following uses VASM syntax for quoting constructs. There is no built-in support for interpolation, escape characters, etc. What constitutes as an escape character depends on the code that is using embedded strings. A function that needs this embedded data can take as an argument a pointer to the data, which can easily be obtained by loading the low byte and high byte of the label into consecutive zero page RAM locations.

MyString: db "Hello World!",0 ;a null-terminated string

Most 6502 assemblers use Motorola syntax, which uses the following conventions:

6502 Assembly uses <code>db</code> or <code>byte</code> for 8-bit data and <code>dw</code> or <code>word</code> for 16-bit data. 16-bit values are written by the programmer in big-endian, but stored little-endian. For example, the following two data blocks are equivalent. You can write it either way, but the end result is the same.

Most assemblers support "C-like" operators, and there are a few additional ones:

These two operators are most frequently used with labeled memory addresses, like so:

byte <Table00,<Table01,<Table02

lookup_table_hi:

* Multiple values can be put on the same line, separated by commas. <code>DC._</code> only needs to be before the first data value on that line. Or, you can put each value on its own line. Both are valid and have the same end result when the code is assembled. You should always follow byte data with EVEN which will add an extra byte of padding if the total number of bytes before it was odd. This is necessary for your code to comply with the CPU's alignment rules.

DC.B $01,$02,$03,$04,$05

even

MyString:

DC.B "Hello World!",0 ;a null terminator will not be automatically placed.

<code>DS._</code> represents a sequence of space. The number after it specifies how many bytes/words/longs' worth of zeroes to place. Some assemblers support values besides zero, others do not.

DS.W 16 ;16 words, each equals zero

In addition to constants, a label can also be specified. If a label is defined with an <code>EQU</code> statement, the label will be replaced with the assigned value during the assembly process.

MOVE.W (MyData),D0

MyData

Code labels, on the other hand, get replaced with the memory address they point to. This can be used to make a lookup table of various data areas, functions, etc. Since there is no "24-bit" data constant directive, you'll have to use <code>DC.L</code> for code labels. The top byte will always be zero in this case.

;insert your code here

FunctionTable:

Most constants can be derived from compile-time expressions, which are useful for explaining what the data actually means. The expressions are evaluated during the assembly process, and the resulting object code will have these calculations already completed, so your program doesn't have to waste time doing them. Most "C-like" operators are supported, but as always the exact syntax depends on your assembler. Parentheses will aid the assembler in getting these correct, but sometimes it still doesn't do what you expect.

DC.W 4+5 ;evaluates to $0009

DC.W (40*30)-1 ;evaluates to $1199

We can use this technique to get the length of a region of data, which the assembler can calculate for us.

DC.B $11,$11,$11,$11,$11,$11,$11,$11,$11,$11

DC.B $10,$00,$00,$00,$00,$00,$00,$00,$00,$01

;gets the length of this region of memory, minus 1, into D0.

; Again, even though the "operands" of this expression are longs,

=== Quoted constructs within expressions ===

The literal HELLO is interpreted as a variable name, and it's value 0 is printed.

{{out}}

</pre>

=== Quoted constructs within DATA statements ===

20 READ A%: PRINT A%: READ A: PRINT A: READ A$: PRINT A$: READ A$: PRINT A$: READ A$: PRINT A$

30 DATA AB"C

{{out}}

<pre>

* Character

'b'

<code>@</code> is a symbol that represents the null character. Characters can contain a newline(<code>@+10</code> is recommended, however).

* Number

1.23

123E5

¯1234

∞

<code>∞</code>, <code>¯∞</code> and <code>π</code> are constants which represent infinity, negative infinity and pi.

* Array: consists of any of the above.

=={{header|FreeBASIC}}==

{{trans|Ring}}

'Function taken fron the https://www.freebasic.net/forum/index.php

Print !"quoted text:\n"; substr(text(n),"'",""); !"\n"

Next n

{{out}}

<pre>Same as Ring input.</pre>

=={{header|Go}}==

import (

}

fmt.Println(os.Expand("There are ${NUMBER} quoting ${TYPES} in Go.", mapper))

{{out}}

* A sequence of numbers, for example <tt>1 2 3</tt>

* A sequence of characters, for example <tt>'1 2 3'</tt>

1 2 3

4 5 6

1 2 3

4 5 6

Note that a multiline <code>{{)n</code> construct discards the leading newline, but the construct can also be used for single line strings (more concise than <code>'</code> delimited strings when <code>'</code> appears multiple times in the string). For example <code><nowiki>{{)n1 2 3}}</nowiki></code> is the same value as <code>'1 2 3'</code>.

The multiline scripts are special cases of the mechanisms for defining verbs, adverbs and conjunctions (what might be called functions or macros or operators or procedures in other languages) which instead provide the raw characters of the definition. The old form (beginning with <tt>0 : 0</tt> and ending with a line containing a single right parenthesis and no other displayable characters) is different from the new form (beginning with <tt>{{)n</tt> and ending with a line which has <tt>}}</tt> and no other characters preceding it) in the way that any following part of a surrounding sentence is arranged. These values of <tt>A</tt> would be equivalent:

A=: '1 2 3'

A=: {{)n

1 2 3

Also, the <nowiki>{{}}</nowiki> forms are nestable. So, for example, this would also define an equivalent value for <tt>A</tt>:

{{

A=: {{)n

}}-.LF

}}''

Here, we are defining verbs inline and immediately evaluating them (by providing an argument (which is ignored because it is not referenced)).

of such values. Such data can be included in a jq program wherever an expression is allowed, but

in a jq program, consecutive JSON values must be specified using "," as a separator, as shown in this snippet:

"A string", 1, {"a":0}, [1,2,[3]]

;

"This is not such a"

"Raw data", such as character strings that are not expressed as JSON strings,

cannot be included in jq programs textually but must be "imported" in some manner, e.g. from

* String literals are delimited by double quotes or triple double quotes:

julia> str = "Hello, world.\n"

"Hello, world.\n"

a newline"""

"Contains \"quote\" characters and \na newline"

* Both single and triple quoted strings are may contain interpolated values. Triple-quoted strings are also dedented to the level of the least-indented line. This is useful for defining strings within code that is indented. For example:

julia> str = """

Hello,

"""

" Hello,\n world.\n"

* Julia allows interpolation into string literals using $:

julia> "$greet, $whom.\n"

"Hello, world.\n"

* The shortest complete expression after the $ is taken as the expression whose value is to be interpolated into the string. Thus, you can interpolate any expression into a string using parentheses:

julia> "1 + 2 = $(1 + 2)"

"1 + 2 = 3"

* Julia reserves the single quote ' for character literals, not for strings:

julia> 'π'

'π': Unicode U+03C0 (category Ll: Letter, lowercase)

* Julia requires commands sent to functions such as run() be surrounded by backticks. Such expressions create a Cmd object, which is used for running a child process from Julia:

julia> mycommand = `echo hello`

`echo hello`

julia> run(mycommand);

hello

* Julia uses the colon : in metaprogramming for quoting symbols and other code:

julia> a = :+

:+

julia> eval(c)

5

=={{header|Lua}}==

Lua has three string definition syntaxes: single- and double-quotes, which are equivalent; and long-bracket pairs [[ ]] which may span multiple lines. Long-bracket pairs may be specified to an arbitrary depth, which may be useful for quoting Lua source code itself (which might use long-brackets). Lua strings are variable-length arrays of bytes, not 0-terminated (as in C), so may contain aribitrary raw binary data. Commonly escaped characters and octal\hexadecimal notation are supported.

s2 = 'This is a single-quoted "string" with embedded double-quotes.'

s3 = "this is a double-quoted \"string\" with escaped double-quotes."

print(s8)

print(s9) -- with audible "bell" from \7 if supported by os

{{out}}

<pre>This is a double-quoted 'string' with embedded single-quotes.

Tuples literals are defined as a list of values between parentheses. Field names may be specified by preceding a value by the name followed by a colon.<br/>

echo "A simple string."

echo "A simple string including tabulation special character \\t: \t."

# Tuples.

echo ('a', 1, true) # Tuple without explicit field names.

{{out}}

Back-ticks and triple-quotes are used for multi-line strings, without backslash interpretation, eg

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

one

three

`</span>

or (entirely equivalent, except the following can contain back-ticks which the above cannot, and vice versa for triple quotes)

<span style="color: #008080;">constant</span> <span style="color: #000000;">t123</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""

one

three

"""</span>

Both are also equivalent to the top double-quote one-liner. Note that a single leading '\n' is automatically stripped.<br>

You can also declare hexadecimal strings, eg

<span style="color: #000000;">x</span><span style="color: #008000;">"1 2 34 5678_AbC"</span> <span style="color: #000080;font-style:italic;">-- same as {0x01, 0x02, 0x34, 0x56, 0x78, 0xAB, 0x0C}

-- note however it displays as {1,2,52,86,120,171,12}

-- whereas x"414243" displays as "ABC" (as all chars)</span>

Literal [http://phix.x10.mx/docs/html/sequences.htm sequences] are represented with curly braces, and can be nested to any depth, eg

{1, 2, {3, 3, 3}, 4, {5, {6}}}

{{"John", "Smith"}, 52389, 97.25}

=={{header|Raku}}==

The different types (or styles) of incorporating quoted constructs are a largely matter of style.

a= 'This is one method of including a '' (an apostrophe) within a string.'

b= "This is one method of including a ' (an apostrophe) within a string."

/*the variable L (with an */

/*intervening blank between each */

=={{header|Ring}}==

{{incomplete|Ring|<u>Explain</u> where they would likely be used, what their primary use is, what limitations they have and why one might be preferred over another. Is one style interpolating and another not? Are there restrictions on the size of the quoted data? The type? The format?}}

text = list(3)

see "quoted text:" + nl + str + nl + nl

next

{{out}}

text for quoting: <br>

====Characters====

Character literals are prefixed by a "$". Conceptionally, they are the elements of strings, although effectively only the codePoint is stored in strings. But when accessing a string element, instances of Character are used. Characters can be asked for being uppercase, lowercase, etc.

$Å

====Strings====

String literals are enclosed in single quotes. Conceptionally, they holde instances of Character as element, but actually the underlying storage representation is chosen to be space effective. Typically, underneath are classes like SingleByteString, TwoByteString and FourByteString, but this is transparent to the programmer. Strings can hold any Unicode character; UTF8 is only used when strings are exchanged with the external world (which is good, as it makes operations like stringLength much easier).

Traditional Smalltalk-80 does not support any escapes inside strings, which is inconvenient, occasionally.<br>Smalltalk/X supports an extended syntax for C-like strings:

{{works with|Smalltalk/X}}

and also embedded expressions:

====Arrays====

Literal arrays are written as #(...), where the elements are space separated; each literal array element can be any type of literal again, optionally omitting the '#'-character:

Here, the third element is a fraction, followed by the symbol #'foo', two arrays, a character, another string, the boolean true, a byteArray and the boolean false.

====ByteArrays====

A dense collection of byte valued integers is written as #[..]. Conceptionally, they are arrays of integer values in the range 0..255, but use only one byte per element of storage. They are typically used for bulk storage such as bitmap images, or when exchanging such with external functions.

====Symbols====

These are like symbol atoms in Lisp/Scheme, written as #'...' (i.e. like a string with hash prefix).

If the characters do not contain special characters or are of the form allowed for a message selector, the quotes can be omitted. Symbols are often used as key in dictionaries, especially for message selectors and global/namespace name bindings. They can be quickly compared using "==", which is. a pointer compare (identity) instead of "=" which is compares the contents (equality).

#'foo bar baz'

#foo. " same as #'foo' "

#'++'

#++ " same as #'++' "

====Blocks====

Blocks thus represent a piece of code which can be stored in an instance variable, passed as argument or returned from a method.

<br>Block syntax is very compact:

or for a block with arguments:

Blocks are one of the fundamental building blocks of Smalltalk (no pun here), as the language (Compiler) does not specify any syntax for control structures. Control structures like if, while, etc. are all implemented as library functions, and defined eg. in the Boolean, Block or Collection classes.

<br>

If you have a block at hand, it can be evaluated by sending it a "value"message:

The most basic implementation of such a control structure is found in the Boolean subclasses True and False, which implement eg. "<tt>ifTrue:arg</tt>" and "<tt>ifFalse:</tt>". Here are those two as concrete example:

ifTrue: aBlock

^ aBlock value "I am true, so I evaluate the block"

in the False class:

ifTrue: aBlock

Thus, the expression <tt>"someBoolean ifTrue:[ 'hello print' ]"</tt> will either evaluate the lambda or not, depending on the someBoolean receiver.

Obviously, you can teach other objects on how to respond to "value" messages and then use them as if they where blocks.

====Inline Object====

{{works with|Smalltalk/X}}

foo: <someConstant>

bar: <someConstant>

Generates a literal constant instance of an anonymous class, with two instance vars: foo and bar.

The object is dumb in that it only provides getter and setter functions. These are used eg. when returning structured multiple values from a method.

Similar to byteArrays, there are dense arrays of ints, floats, doubles or bits (i.e. they use much less memory compared to regular arrays, which hold pointers to their elements). They are also perfect when calling out to C-language functions. The syntax is analogous to the Scheme language's syntax:

{{works with|Smalltalk/X}}

#u32( 1 2 3 ). " an array of unsigned int32s "

#u64( 1 2 3 ). " an array of unsigned int64s "

#f64( -1 2.0 3 ). " an array of float64s "

#b( 1 0 1 1 0 0 ). " an array of bits "

=={{header|Wren}}==

Here are some examples of all this.

// simple string literal

"""

System.print(r)

{{out}}

the null terminator is the only way the CPU knows it will end (assuming that your "putS" routine uses a null terminator.)

byte "Hello World",0 ;a null-terminated string

LookupTable:

byte &03,&06,&09,&0C ;a pre-defined sequence of bytes (similar in concept to enum in C)

TileGfx:

For most Z80 assemblers, the following are standard:

Z80 Assembly uses db or byte for 8-bit data and dw or word for 16-bit data. 16-bit values are written by the programmer in big-endian, but stored little-endian. For example, the following two data blocks are equivalent. You can write it either way, but the end result is the same.

Most assemblers support "C-like" operators, and there are a few additional ones:

* > or HIGH() means "The high byte of." For example, <$78AB evaluates to 78.

These two operators are most frequently used with labeled memory addresses, like so:

byte <Table00,<Table01,<Table02

lookup_table_hi:

The <code>incbin</code> directive can be used for embedding raw graphics data, text, or music.

A #<<<" beginning tag prepends a " to the block.

For example:

text:=

"

A

";

is parsed as text:="\nA\n";