aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data update

Browse source
This commit is contained in:
Ingy döt Net 2025-02-27 18:35:13 -05:00
parent 8e4e15fa56
commit 72eb4943cb
1853 changed files with 35514 additions and 9441 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Lang/4D/00-LANG.txt
View file

@ -1,3 +1,6 @@
{{stub}}{{language|4D}}{{IDE}}'''4D''' (or '''4th Dimension''') is a database management system and [[:Category:Integrated Development Environments|integrated development environment]] authored by Laurent Ribardière in 1984.
{{stub}}
{{language|4D
|site=https://us.4d.com/
}}{{IDE}}'''4D''' (or '''4th Dimension''') is a database management system and [[:Category:Integrated Development Environments|integrated development environment]] authored by Laurent Ribardière in 1984.
==Citations==
*[[wp:4th_Dimension_%28Software%29|Wikipedia:4th Dimension (Software)]]

125
Lang/68000-Assembly/00-LANG.txt
View file

@ -3,31 +3,36 @@
{{language}}
68000 assembly is the assembly language used for the Motorola 68000, or commonly known as the 68K. It should not be confused with the 6800 (which predates it). The Motorola 68000 is a big-endian processor with full 32-bit capabilities (despite most systems that use it being considered 16-bit.) It was used in many computers such as the Amiga or the Canon Cat, as well as game consoles such as the Sega Genesis and Neo Geo.
==Architecture Overview==
===Big-Endian===
The 68000, unlike most processors of its era, is big-endian. This means that bytes are stored from left to right. The example below illustrates this concept:
<lang 68000devpac>MOVE.L #$12345678,$100000 ;store the hexadecimal numeral #$12345678 at memory address $100000
<syntaxhighlight lang="68000devpac">
MOVE.L #$12345678,$100000 ;store the hexadecimal numeral #$12345678 at memory address $100000
</syntaxhighlight>
<pre>
;hexdump of $100000:
;$100000 = $12
;$100001 = $34
;$100002 = $56
;$100003 = $78</lang>
;$100003 = $78
</pre>
On a little-endian processor such as in [[x86 Assembly]], the order of the bytes would be reversed, i.e.:
<lang asm>;hexdump of $100000
<pre>
;hexdump of $100000
;$100000 = $78
;$100001 = $56
;$100002 = $34
;$100003 = $12</lang>
;$100003 = $12
</pre>
This difference isn't usually relevant in the majority of situations, so don't concern yourself too much. It's much more important when doing [[6502 Assembly]] where registers are smaller than the address space.
The main difference is that if you wanted to access this value as a byte or word it would be at a different address, whereas with a little endian architecture it is at the same address.
===Notation Conventions===
How you write the source code depends on your assembler and the syntax it uses. This page is written using Motorola syntax but there is also Milo syntax which has different conventions.
How you go about defining numbers or text in your code varies wildly between assemblers. I'm using VASM and these are the rules I have to follow, but your assembler may be different.
How you go about defining numbers or text in your code varies wildly between assemblers.
* A number with a # in front represents a constant, literal value. For example, the 3 in <code>MOVE.B #3,D0</code> represents the number 3.
@ -45,72 +50,88 @@ How you go about defining numbers or text in your code varies wildly between ass
* The operand before the comma is the "source", and the operand after is the "destination." For example, <code>MOVE.L D3,D2</code> takes the value in D3 and stores it into D2, not the other way around. This is the opposite of x86 and ARM, which have the source on the right and the destination on the left.
Data blocks, on the other hand, begin with <code>DC.B</code>, <code>DC.W</code>, or <code>DC.L</code> and each represents a constant numeric value. Strangely, you do NOT prefix these with # to signify them as constants (doing so will cause an error on most assemblers). However, you can use the $ or % modifiers to denote hexadecimal or binary.
Data blocks, on the other hand, begin with <code>DC.B</code>, <code>DC.W</code>, or <code>DC.L</code> and each represents a constant numeric value. You do NOT prefix these with # to signify them as constants (doing so will cause an error on most assemblers). However, you can use the $ or % modifiers to denote hexadecimal or binary.
Keep in mind that there is no requirement to use hexadecimal, decimal, or binary in your source code. It all gets converted to binary anyway. However, it is recommended to use the notation that is appropriate for how your data is meant to be interpreted, for readability purposes.
===Data Registers===
There are eight 32-bit data registers on the 68000, numbered D0-D7. As the name implies, these are designed to hold data. Much like in [[ARM Assembly]], each one is identical in terms of which commands it can use. A command that can be used for D0 can be used for any other D-register.
<lang 68000devpac>MOVE.B #$FF,D0 ;move the hexadecimal value 0xFF into the bottom byte of D0.
ADD.W #$8000,D4 ;add hexadecimal 0x8000 to the value stored in D4.</lang>
<syntaxhighlight lang="68000devpac">
MOVE.B #$FF,D0 ;move the hexadecimal value 0xFF into the bottom byte of D0.
ADD.W #$8000,D4 ;add hexadecimal 0x8000 to the value stored in D4.
</syntaxhighlight>
===Address Registers===
There are eight of these as well, numbered A0-A7. A7 is reserved as the stack pointer, and is commonly referenced as SP in assemblers. The others are free to use for any purpose. Although these registers are 32-bit, the 68000's address space is 24-bit (ranges from 0x000000 to 0xFFFFFF), so the leftmost byte is ignored. You can do simple math involving these registers but more complicated commands like multiply or divide can only be used with data registers. Address registers are used to contain addresses and extract the values stored within.
====Loading From Memory====
<lang 68000devpac>MOVEA.L #$200000,A2 ;usually these are loaded from a label.
<syntaxhighlight lang="68000devpac">
MOVEA.L #$200000,A2 ;usually these are loaded from a label.
;The hex dump of address $200000: 44 55 66 77
MOVE.L #$00000000,D0
MOVE.B (A2),D0 ;load the byte stored at $200000 into D0. D0 = #$00000044
MOVE.W (A2),D0 ;load the word stored at $200000 into D0. D0 = #$00004455
MOVE.L (A2),D0 ;load the long stored at $200000 into D0. D0 = #$44556677
MOVE.L D2,(A5) ;store the contents of D2 into the memory address pointed to by A5.</lang>
MOVE.L D2,(A5) ;store the contents of D2 into the memory address pointed to by A5.
</syntaxhighlight>
Note that it's also possible to transfer values to/from memory directly, without involving address registers at all. For constant memory locations, this is fine. However, the real strength of the address registers is in their pre-decrement and post-increment modes, which constant memory locations cannot use.
<lang 68000devpac>MOVE.L ($00FF0000),D0
<syntaxhighlight lang="68000devpac">
MOVE.L ($00FF0000),D0
MOVE.W D1,($00FFFFFE)
MOVE.W ($00FF0000),($00FF1000)</lang>
MOVE.W ($00FF0000),($00FF1000)
</syntaxhighlight>
The use of parentheses is not required on most assemblers, but can be used as a reminder to someone reading your code that these represent the values stored at the specified memory locations rather than literal numbers.
====Post-Increment====
The post-increment mode is specified by adding a + to the end of parentheses. This means that after the command is done, the address stored in the <b>address register</b> (not the value stored at that address) is increased by the byte length of the command (1 for <code>.B</code>, 2 for <code>.W</code>, 4 for <code>.L</code>).
<lang 68000devpac>MOVEA.L #$00240000,A4 ;load the address $240000 into A4
<syntaxhighlight lang="68000devpac">
MOVEA.L #$00240000,A4 ;load the address $240000 into A4
MOVE.W (A4)+,D0 ;move the word stored at $240000 into D0, then increment to #$240002
MOVE.L (A4)+,D1 ;move the long stored at $240000 into D1, then increment to #$240006
MOVE.L (SP)+,D3 ;pop the top value of the stack into D3</lang>
MOVE.L (SP)+,D3 ;pop the top value of the stack into D3
</syntaxhighlight>
====Pre-Decrement====
The pre-decrement mode is specified by typing a - before the parentheses. This means that before the command is done, the address stored in the address register is decreased by the byte length of the command.
<lang 68000devpac>MOVEA.L #$0024000A,A4 ;load the address $24000A into A4
<syntaxhighlight lang="68000devpac">MOVEA.L #$0024000A,A4 ;load the address $24000A into A4
MOVE.W -(A4),D0 ;move the word stored at $240008 into D0
MOVE.L -(A4),D1 ;move the long stored at $240004 into D1
MOVE.L D2,-(SP) ;push the contents of D2 onto the stack</lang>
MOVE.L D2,-(SP) ;push the contents of D2 onto the stack</syntaxhighlight>
====Address Offsets====
A memory address can be offset by a data register, an immediate value, or both. If a data register is used, only the bottom 2 bytes are considered. In either case, the contents of the data register and/or the immediate value are added to the value stored in the address register, and the value is read from that address at the specified length. The offsets are applied during the calculation only; the actual contents in the address register after the move are unchanged. Using a post-increment or pre-decrement with this addressing mode will only update the address by the specified length, not by the offsets.
<lang 68000devpac>MOVE.B (4,A0,D0),D1 ;The byte at A0+D0+4 is loaded into D1.</lang>
<syntaxhighlight lang="68000devpac">
MOVE.B (4,A0,D0),D1 ;The byte at A0+D0+4 is loaded into D1.
</syntaxhighlight>
It's possible to use the same data register as the offset and the destination. This does not cause any problems whatsoever, as the data register offset is "locked in" before the move, and is only updated after the command fully executes. Using the same command again immediately afterwards will offset based on the new value of that register.
<lang 68000devpac>MOVE.W (6,A0,D0),D0 ;The word at A0+D0+6 is read, then loaded into D0.</lang>
<syntaxhighlight lang="68000devpac">
MOVE.W (6,A0,D0),D0 ;The word at A0+D0+6 is read, then loaded into D0.
</syntaxhighlight>
A very important note is that when using this method with words and longs, the resulting address <b><i>must be even!</i></b> Otherwise the CPU will crash. For <code>MOVE.B</code> it doesn't matter.
====Effective Address====
A calculated offset can be saved to an address register with the <code>LEA</code> command, which stands for "Load Effective Address." [[x86 Assembly]] also has this command, and it serves the same purpose. The syntax for it can be a bit misleading depending on your assembler.
<lang 68000devpac>LEA myData,A0 ;load the effective address of myData into A0
<syntaxhighlight lang="68000devpac">
LEA myData,A0 ;load the effective address of myData into A0
LEA (4,A0),A1 ;load into A1 the effective address A0+4. This looks like a dereference operation but it is not!
MOVE.W (A1),D1 ;dereference A1, loading the value it points to into D1.</lang>
MOVE.W (A1),D1 ;dereference A1, loading the value it points to into D1.
</syntaxhighlight>
This can get confusing, especially if you have tables of pointers. Just remember that <code>LEA</code> cannot dereference an address.
If you don't want to store the effective address in an address register, you can use <code>PEA</code> (push effective address) to put it onto the stack instead.
<lang 68000devpac>LEA myData,A0 ;load the effective address of myData into A0
PEA (4,A0) ;store the effective address of A0+4 onto the stack.</lang>
<syntaxhighlight lang="68000devpac">
LEA myData,A0 ;load the effective address of myData into A0
PEA (4,A0) ;store the effective address of A0+4 onto the stack.
</syntaxhighlight>
====The Stack====
The 68000's stack is commonly referred to as <code>SP</code> but it is also address register <code>A7</code>. This register is handled differently than the other address registers when pushing bytes onto the stack. A byte value pushed onto the stack will be padded to the <b>right</b>. The stack needs to pad byte-length data so that it can stay word-aligned at all times. Otherwise the CPU would crash as soon as you tried to use the stack for anything other than a byte!
@ -124,48 +145,48 @@ The 68000 can work with 8-bit, 16-bit, or 32-bit values. Some commands only work
If you don't specify a length with your command, it usually defaults to word length, but ultimately it depends on the command you are using. (Some commands cannot be used at word length.)
Bytes and words moved into a register are always stored on the right-hand side. For example:
<lang 68000devpac>MOVE.L #$FFFFFFFF,D7
<syntaxhighlight lang="68000devpac">
MOVE.L #$FFFFFFFF,D7
MOVE.B #$00,D7 ;D7 contains #$FFFFFF00
MOVE.W #$2222,D7 ;D7 contains #$FFFF2222</lang>
MOVE.W #$2222,D7 ;D7 contains #$FFFF2222
</syntaxhighlight>
As you can see, the rest of the register is unchanged. (On the ARM, it would turn to zeroes.) This is very important to remember. If your code is doing something unexpected it might be due to the "old" value of the register corrupting another function.
If the given constant is smaller than the length provided, the value is padded to the left with zeroes.
<lang 68000devpac>MOVE.W #$FF,D3 ;D3 = #$xxxx00FF, where x is the previous value of D3.
MOVE.L #0,D3 ;D3 = #$00000000</lang>
<syntaxhighlight lang="68000devpac">
MOVE.W #$FF,D3 ;D3 = #$xxxx00FF, where x is the previous value of D3.
MOVE.L #0,D3 ;D3 = #$00000000
</syntaxhighlight>
Loading immediate values into address registers is different. You can only move words or longer into address registers, and if you move a word, the value is sign-extended. This means that if the top nibble of the word is 8 or greater, the value gets padded to the left with Fs, and is padded with zeroes if the top nibble is 7 or less. If you're adding a constant value less than 7FFF to an address, it's usually safe to use the word length operation, which takes less bytes to encode than the long length version.
<lang 68000devpac>MOVEA.W #$8000,A4 ;A4 = #$FFFF8000. Remember the top byte is ignored so this is the same as #$00FF8000.
MOVEA.W #$7FFF,A3 ;A3 = #$00007FFF</lang>
<syntaxhighlight lang="68000devpac">
MOVEA.W #$8000,A4 ;A4 = #$FFFF8000. Remember the top byte is ignored so this is the same as #$00FF8000.
MOVEA.W #$7FFF,A3 ;A3 = #$00007FFF
</syntaxhighlight>
==The Flags==
The flags are stored in the Condition Code Register, also known as the <code>CCR</code>. The 68000 has no built-in commands like <code>CLC</code> for clearing/setting individual flags. Rather, you can alter them directly with <code>MOVE</code>,<code>AND</code>,<code>OR</code>, and <code>EOR</code>. Unfortunately, this means you'll have to remember which bits represent which flags. Or, if your assembler supports macros, you can define a macro that handles this for you.
The flags update automatically after most operations, and take into consideration the operand sizes when doing so. Check out this example:
<lang 68000devpac>
<syntaxhighlight lang="68000devpac">
MOVE.L #$12FF,D0
ADD.B #1,D0
</lang>
</syntaxhighlight>
Since we used <code>ADD.B</code>, D0 now contains $1200, and the extend, carry, and zero flags are all set. Had we done <code>ADD.W</code>, we would get $1300 in D0 with none of those flags set. The flags are based on what the actual instruction "sees", not the entire register at all times.
* X: The eXtend flag is bit 4 of the CCR, and is similar to the carry flag. It gets set and cleared often for the same reasons and is used with the <code>ADDX</code>, <code>SUBX</code>, <code>NEGX</code>, <code>ROXL</code>, and <code>ROXR</code> commands. Why the 68000 has both this and the carry flag, I still don't know.
* N: The negative flag is bit 3 of the CCR, and is set when the last operation resulted in a "negative" value. What constitutes a negative value depends on the size of the last operation - for <code>.B</code> instructions, $80-$FF. For <code>.W</code> instructions, $8000-$FFFF, and for <code>.L</code> instructions, $80000000-$FFFFFFFF.
* Z: The zero flag is bit 2 of the CCR and works like you would expect - it's set whenever an operation results in zero. Unlike x86 Assembly, this also includes moving 0 directly into a register, clearing a register <b>or memory</b> with <code>CLR</code>, etc.
* V: The overflow flag is bit 1 of the CCR. It is set whenever a math operation results in a value crossing the $7F-$80 boundary. (Wraparound from 00 to FF doesn't count as overflow, but it does set the carry flag.)
* C: The carry flag is bit 0 of the CCR. It is set when a math operation results in a carry or borrow. Rolling over from FF to 00, or a 1 getting "pushed out" via a bit shift or rotate, set the carry flag. When using <code>CMP</code>, the carry flag determines the unsigned magnitude comparison. Carry set is less than, carry clear is greater than or equal.
In truth, the flags are a 16-bit register, of which the CCR is just the "low half". The SR (status register) is the full 16-bit register.
There are a few additional flags in the upper half, which are used by the operating system. You can read these but for the most part you won't need to write to them.
@ -189,13 +210,15 @@ The 68000 supports 7 different interrupts, often called IRQs or Interrupt Reques
==Alignment==
The 68000 can only read or write words and longs at even addresses. Doing so at an odd address will result in the CPU crashing. (Note that reading byte data will not cause a crash regardless of whether it's located at an odd or even address.) This isn't usually a problem, but it can be if the programmer is not careful with the way their data is organized. Consider the following example:
<lang 68000devpac>TestData:
<syntaxhighlight lang="68000devpac">
TestData:
DC.B $02
DC.W $0345
LEA TestData,A0 ;load effective address of TestData into A0.
MOVE.B (A0)+,D0 ;load $02 into D0, increment A0 by 1
MOVE.W (A0)+,D1 ;this crashes the CPU since A0 is now odd</lang>
MOVE.W (A0)+,D1 ;this crashes the CPU since A0 is now odd
</syntaxhighlight>
How was it known that the address was odd at the second instruction? Simple. All instructions take an even number of bytes to encode. So there are only a few ways improper alignment can occur:
* An odd value is loaded into an address register.
@ -205,18 +228,23 @@ How was it known that the address was odd at the second instruction? Simple. All
If the programmer is smart with the way they encode byte-length data they can avoid this problem entirely with little effort.
One way is to separate byte-length data into its own table.
<lang 68000devpac>ByteData:
<syntaxhighlight lang="68000devpac">
ByteData:
DC.B $20,$40,$60,$80
WordData:
DC.W $1000,$2000,$3000,$4000</lang>
DC.W $1000,$2000,$3000,$4000
</syntaxhighlight>
Another way is to pad the data with an extra byte, so that there is an even number of entries in the table. This becomes impractical with large data tables, so the <code>EVEN</code> directive can be placed after a series of bytes. If the byte count is odd, <code>EVEN</code> will pad the data with an extra byte. If it's already even, the <code>EVEN</code> command is ignored. This saves you the trouble of having to count a long series of bytes without worrying about wasting space.
<lang 68000devpac>MyString: DC.B "HELLO WORLD 12345678900000",0
EVEN ;some assemblers require this to be on its own line</lang>
<syntaxhighlight lang="68000devpac">
MyString: DC.B "HELLO WORLD 12345678900000",0
EVEN ;some assemblers require this to be on its own line
</syntaxhighlight>
A third way is to perform a "dummy read." This is when a value is read from an address using pre-decrement or post-increment, with the sole purpose of moving the pointer, and the value being read is of zero interest. This method lets you work with mixed data types in the same table, but it requires the programmer to know in advance where the byte-length data begins and ends.
<lang 68000devpac>TestData:
<syntaxhighlight lang="68000devpac">
TestData:
DC.B $02,$03,$04
DC.W $0345
@ -227,7 +255,8 @@ MOVE.B (A0)+,(A1)+ ;copy $04 to a new memory location
;if we did MOVE.W (A0)+,(A1)+ now we'd crash. First we need to adjust the pointers.
MOVE.B (A0)+,D7 ;dummy read to D7. Now A0 is word aligned.
MOVE.B (A1)+,D7 ;dummy read to D7. Now A1 is word aligned.
MOVE.W (A0)+,(A1)+ ;copy $0345 to a new memory location</lang>
MOVE.W (A0)+,(A1)+ ;copy $0345 to a new memory location
</syntaxhighlight>
Using <code>ADDA.L #1,A0</code> and <code>ADDA.L #1,A1</code> would have worked also, instead of the dummy read. The 68000 gives the programmer a lot of different ways to do a task.

1
Lang/68000-Assembly/Musical-scale Symbolic link
View file

@ -0,0 +1 @@
../../Task/Musical-scale/68000-Assembly

1
Lang/8080-Assembly/Align-columns Symbolic link
View file

@ -0,0 +1 @@
../../Task/Align-columns/8080-Assembly

16
Lang/ABAP/00-LANG.txt
View file

@ -1,2 +1,14 @@
{{stub}}{{language|site=http://www.sdn.sap.com/irj/sdn/abap}}
ABAP (Advanced Business Application Programming) is a programming language developed by the german software vendor SAP. It is mainly used to build high performance business applications.
{{stub}}{{language
|site=http://www.sdn.sap.com/irj/sdn/abap
|safety=safe
|strength=strong
|compat=nominative
|checking=static
|tags=abap}}
ABAP (Advanced Business Application Programming) is a programming language developed by the german software vendor SAP. It is mainly used to build high performance business applications.
==Citation==
*[https://en.wikipedia.org/wiki/ABAP]
[[Category:Programming paradigm/Object-oriented]]
[[Category:Programming paradigm/Imperative]]

1
Lang/ABC/Arithmetic-derivative Symbolic link
View file

@ -0,0 +1 @@
../../Task/Arithmetic-derivative/ABC

1
Lang/ALGOL-60/Even-or-odd Symbolic link
View file

@ -0,0 +1 @@
../../Task/Even-or-odd/ALGOL-60

1
Lang/ALGOL-60/Harmonic-series Symbolic link
View file

@ -0,0 +1 @@
../../Task/Harmonic-series/ALGOL-60

1
Lang/ALGOL-60/Nth-root Symbolic link
View file

@ -0,0 +1 @@
../../Task/Nth-root/ALGOL-60

1
Lang/ALGOL-60/Square-free-integers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Square-free-integers/ALGOL-60

1
Lang/ALGOL-60/Sum-of-a-series Symbolic link
View file

@ -0,0 +1 @@
../../Task/Sum-of-a-series/ALGOL-60

1
Lang/ALGOL-68/100-prisoners Symbolic link
View file

@ -0,0 +1 @@
../../Task/100-prisoners/ALGOL-68

1
Lang/ALGOL-68/Bitmap-B-zier-curves-Quadratic Symbolic link
View file

@ -0,0 +1 @@
../../Task/Bitmap-B-zier-curves-Quadratic/ALGOL-68

1
Lang/ALGOL-68/Burrows-Wheeler-transform Symbolic link
View file

@ -0,0 +1 @@
../../Task/Burrows-Wheeler-transform/ALGOL-68

1
Lang/ALGOL-68/Chernicks-Carmichael-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Chernicks-Carmichael-numbers/ALGOL-68

1
Lang/ALGOL-68/Determinant-and-permanent Symbolic link
View file

@ -0,0 +1 @@
../../Task/Determinant-and-permanent/ALGOL-68

1
Lang/ALGOL-68/Display-an-outline-as-a-nested-table Symbolic link
View file

@ -0,0 +1 @@
../../Task/Display-an-outline-as-a-nested-table/ALGOL-68

1
Lang/ALGOL-68/Elementary-cellular-automaton-Random-number-generator Symbolic link
View file

@ -0,0 +1 @@
../../Task/Elementary-cellular-automaton-Random-number-generator/ALGOL-68

1
Lang/ALGOL-68/Four-is-magic Symbolic link
View file

@ -0,0 +1 @@
../../Task/Four-is-magic/ALGOL-68

1
Lang/ALGOL-68/IBAN Symbolic link
View file

@ -0,0 +1 @@
../../Task/IBAN/ALGOL-68

1
Lang/ALGOL-68/Jaro-similarity Symbolic link
View file

@ -0,0 +1 @@
../../Task/Jaro-similarity/ALGOL-68

1
Lang/ALGOL-68/Longest-increasing-subsequence Symbolic link
View file

@ -0,0 +1 @@
../../Task/Longest-increasing-subsequence/ALGOL-68

1
Lang/ALGOL-68/Partition-function-P Symbolic link
View file

@ -0,0 +1 @@
../../Task/Partition-function-P/ALGOL-68

1
Lang/ALGOL-68/Pentagram Symbolic link
View file

@ -0,0 +1 @@
../../Task/Pentagram/ALGOL-68

1
Lang/ALGOL-W/Calculating-the-value-of-e Symbolic link
View file

@ -0,0 +1 @@
../../Task/Calculating-the-value-of-e/ALGOL-W

1
Lang/ALGOL-W/McNuggets-problem Symbolic link
View file

@ -0,0 +1 @@
../../Task/McNuggets-problem/ALGOL-W

1
Lang/ALGOL-W/Square-free-integers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Square-free-integers/ALGOL-W

1
Lang/ANSI-BASIC/Angle-difference-between-two-bearings Symbolic link
View file

@ -0,0 +1 @@
../../Task/Angle-difference-between-two-bearings/ANSI-BASIC

1
Lang/ANSI-BASIC/Leonardo-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Leonardo-numbers/ANSI-BASIC

1
Lang/ANSI-BASIC/Luhn-test-of-credit-card-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Luhn-test-of-credit-card-numbers/ANSI-BASIC

1
Lang/ANSI-BASIC/Nth-root Symbolic link
View file

@ -0,0 +1 @@
../../Task/Nth-root/ANSI-BASIC

1
Lang/ANSI-BASIC/Temperature-conversion Symbolic link
View file

@ -0,0 +1 @@
../../Task/Temperature-conversion/ANSI-BASIC

1
Lang/APL/Arithmetic-derivative Symbolic link
View file

@ -0,0 +1 @@
../../Task/Arithmetic-derivative/APL

1
Lang/ARM-Assembly/Pancake-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Pancake-numbers/ARM-Assembly

1
Lang/ASIC/Dragon-curve Symbolic link
View file

@ -0,0 +1 @@
../../Task/Dragon-curve/ASIC

1
Lang/ASIC/Luhn-test-of-credit-card-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Luhn-test-of-credit-card-numbers/ASIC

1
Lang/ASIC/Temperature-conversion Symbolic link
View file

@ -0,0 +1 @@
../../Task/Temperature-conversion/ASIC

1
Lang/Action-/Arithmetic-derivative Symbolic link
View file

@ -0,0 +1 @@
../../Task/Arithmetic-derivative/Action-

3
Lang/ActionScript/00-LANG.txt
View file

@ -4,7 +4,8 @@
|strength=strong
|safety=safe
|checking=static
|LCT=yes}}
|LCT=yes
|tags=actionscript, as}}
{{Language programming paradigm|Distributed}}
{{Language programming paradigm|Imperative}}

2
Lang/Ada/00-LANG.txt
View file

@ -8,7 +8,7 @@
|strength=strong
|safety=safe
|LCT=yes
|bnf=http://www.adaic.org/standards/1zrm/html/RM-P.html}}'''Ada''' is a structured, statically typed [[imperative programming|imperative]] computer programming language. Ada was initially standardized by [[ANSI]] in 1983 and by [[ISO]] in 1987. This version of the language is commonly known as [[Ada 83]]. The next version was standardized by ISO in 1995 (ISO/IEC 8652:1995) and is commonly known as [[Ada 95]]. Following that ISO published ISO/IEC 8652:1995/Amd 1:2007 in 2007, which is commonly known as [[Ada 2005]]. Most recently ISO published [http://www.ada-auth.org/standards/12rm/html/RM-TTL.html ISO/IEC 8652:2012(E)], commonly known as [[Ada 2012]]. Formally only the most recent version of the language is known as '''Ada'''.
|bnf=http://www.ada-auth.org/standards/22rm/html/RM-P-1.html}}'''Ada''' is a structured, statically typed [[imperative programming|imperative]] computer programming language. Ada was initially standardized by [[ANSI]] in 1983 and by [[ISO]] in 1987. This version of the language is commonly known as [[Ada 83]]. The next version was standardized by ISO in 1995 (ISO/IEC 8652:1995) and is commonly known as [[Ada 95]]. Following that ISO published ISO/IEC 8652:1995/Amd 1:2007 in 2007, which is commonly known as [[Ada 2005]]. Afterwards they published ISO/IEC 8652:2012(E), also known as [[Ada 2012]]. Most recently ISO published [http://www.ada-auth.org/standards/22rm/html/RM-TTL.html ISO/IEC 8652:2023], commonly known as [[Ada 2022]]. Formally only the most recent version of the language is known as '''Ada'''.
The language is named after [[wp:Ada_Lovelace|Augusta Ada King, Countess of Lovelace]] thought to be the first ever programmer. Initially it was designed for [http://www.defense.gov U.S. Department of Defense]. The language is used for large and mission-critical systems. See [[wp:Ada_(programming_language)|also]].
==Grammar==

1
Lang/Ada/Arithmetic-derivative Symbolic link
View file

@ -0,0 +1 @@
../../Task/Arithmetic-derivative/Ada

1
Lang/Ada/Blum-integer Symbolic link
View file

@ -0,0 +1 @@
../../Task/Blum-integer/Ada

1
Lang/Ada/Chaos-game Symbolic link
View file

@ -0,0 +1 @@
../../Task/Chaos-game/Ada

1
Lang/Ada/Lah-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Lah-numbers/Ada

1
Lang/Ada/Left-factorials Symbolic link
View file

@ -0,0 +1 @@
../../Task/Left-factorials/Ada

1
Lang/Ada/Sierpinski-pentagon Symbolic link
View file

@ -0,0 +1 @@
../../Task/Sierpinski-pentagon/Ada

1
Lang/Ada/Smallest-number-k-such-that-k+2^m-is-composite-for-all-m-less-than-k Symbolic link
View file

@ -0,0 +1 @@
../../Task/Smallest-number-k-such-that-k+2^m-is-composite-for-all-m-less-than-k/Ada

1
Lang/AmigaBASIC/Chaos-game Symbolic link
View file

@ -0,0 +1 @@
../../Task/Chaos-game/AmigaBASIC

1
Lang/Applesoft-BASIC/00-LANG.txt
View file

@ -7,4 +7,5 @@
* [[wp:Applesoft BASIC|Wikipedia: Applesoft BASIC]]
* [http://www.landsnail.com/a2ref.htm Apple II Programmer's Reference] from ][ In a Mac, via [http://www.landsnail.com/ Landsnail.com]
* [http://www.hoist-point.com/applesoft_basic_tutorial.htm AppleSoft BASIC tutorial for absolute beginners]
* [https://www.calormen.com/jsbasic/ Applesoft BASIC in Javascript] On-line interpreter
* ''[[Tasks not implemented in Applesoft BASIC|Tasks not implemented in Applesoft BASIC]]''

1
Lang/Applesoft-BASIC/Dragon-curve Symbolic link
View file

@ -0,0 +1 @@
../../Task/Dragon-curve/Applesoft-BASIC

35
Lang/Aquarius-BASIC/00-LANG.txt
View file

@ -2,4 +2,37 @@
|exec=interpreted
|tags=basic,aquariusbasic
}}
{{Implementation|BASIC}}'''Aquarius BASIC''' refers to the more or less stripped-down releases of Microsoft BASIC for the Mattel/Radofin Aquarius. The built-in ROM BASIC was seriously restricted since the system only included 4K of RAM and 8K of ROM by default. Minus the RAM used for video and system management, only about 1.7K or RAM were usable by default; the optionally available Extended Microsoft BASIC that came on ROM cartridge was somewhat more generous, and RAM expansion cartridges were available.
{{Implementation|BASIC}}'''Aquarius BASIC''' refers to the more or less stripped-down releases of Microsoft BASIC for the Mattel/Radofin Aquarius, a home computer released in 1983.
The built-in ROM BASIC was seriously restricted since the system only included 4K of RAM and 8K of ROM by default. Minus the RAM used for video and system management, only about 1.7K of RAM were usable by default; the optionally available Extended Microsoft BASIC that came on ROM cartridge was somewhat more generous, and RAM expansion cartridges were available.
BASIC lines can be a maximum of 72 characters long. Only the first two characters of a variable name are significant, so e.g. ABC and ABBA will contain the same value:
<syntaxhighlight lang="basic">
10 ABC=3
20 ABBA=5
30 PRINT ABC;ABBA
RUN
5 5</syntaxhighlight>
The Aquarius features a text-mode screen of 40x25 characters with 16 colors. BASIC only uses 38x24 characters, i.e. the row at the top and the two outermost columns on each side are not accessible when editing, PRINTing, or LISTing. However, all 40x25 characters can be modified via POKEs from BASIC to screen memory.
Screen character memory starts at 0x3000 (12288); color RAM (with high nibble = foreground color; low nibble = background color) starts at 0x3400 (12288 + 1024 = 13312). Border color can be set by POKEing to the top left character, e.g. <code>POKE 13312,7</code> will turn the border color to white. BASIC programs start at 0x3901.[https://www.vdsteenoven.com/aquarius/malloc.html]
BASIC can set and unset 80x72-resolution pixels on the Aquarius with the PSET and PRESET commands (each text character consists of 2x3 pixels). This program for instance draws an ellipsis:
<syntaxhighlight lang="basic">10 PRINT CHR$(11);
20 PI=3.141593 : R=30
30 FOR I=0 TO 360
40 X=R*SIN(I*PI/180)
50 Y=R*COS(I*PI/180)
60 PSET(39+X,35+Y)
70 NEXT</syntaxhighlight>
The Aquarius character set cannot be redefined.
By default, the total space for string variables is only 50 bytes! This can be increased with CLEAR, e.g. <code>CLEAR 200</code> will reserve 200 bytes for strings. You can check with <code>PRINT FRE("a")</code> how much unused string space is still available.
Emulators of the Mattel Aquarius include MAME and [https://aquarius.je/aqualite/ AquaLite].
==See Also==
* [[wp:Mattel Aquarius|Mattel Aquarius]] at Wikipedia
* [https://archive.org/search?query=mattel+aquarius Aquarius manuals at the Internet Archive]

1
Lang/Aquarius-BASIC/Archimedean-spiral Symbolic link
View file

@ -0,0 +1 @@
../../Task/Archimedean-spiral/Aquarius-BASIC

1
Lang/Aquarius-BASIC/Colour-bars-Display Symbolic link
View file

@ -0,0 +1 @@
../../Task/Colour-bars-Display/Aquarius-BASIC

1
Lang/Aquarius-BASIC/Mandelbrot-set Symbolic link
View file

@ -0,0 +1 @@
../../Task/Mandelbrot-set/Aquarius-BASIC

1
Lang/Aquarius-BASIC/Matrix-digital-rain Symbolic link
View file

@ -0,0 +1 @@
../../Task/Matrix-digital-rain/Aquarius-BASIC

1
Lang/Aquarius-BASIC/Musical-scale Symbolic link
View file

@ -0,0 +1 @@
../../Task/Musical-scale/Aquarius-BASIC

1
Lang/Aquarius-BASIC/Terminal-control-Display-an-extended-character Symbolic link
View file

@ -0,0 +1 @@
../../Task/Terminal-control-Display-an-extended-character/Aquarius-BASIC

4
Lang/Arturo/00-LANG.txt
View file

@ -16,8 +16,8 @@ The language has been designed following some very simple and straightforward pr
<syntaxhighlight lang="arturo">
factorial: function [n][
if? n > 0 -> n * factorial n-1
else -> 1
switch n > 0 -> n * factorial n-1
-> 1
]
loop 1..19 [x]->

1
Lang/Arturo/Abstract-type Symbolic link
View file

@ -0,0 +1 @@
../../Task/Abstract-type/Arturo

1
Lang/Arturo/Bitmap-Bresenhams-line-algorithm Symbolic link
View file

@ -0,0 +1 @@
../../Task/Bitmap-Bresenhams-line-algorithm/Arturo

1
Lang/Arturo/Inheritance-Single Symbolic link
View file

@ -0,0 +1 @@
../../Task/Inheritance-Single/Arturo

1
Lang/Arturo/Number-names Symbolic link
View file

@ -0,0 +1 @@
../../Task/Number-names/Arturo

1
Lang/Arturo/Radical-of-an-integer Symbolic link
View file

@ -0,0 +1 @@
../../Task/Radical-of-an-integer/Arturo

1
Lang/Arturo/Reflection-List-methods Symbolic link
View file

@ -0,0 +1 @@
../../Task/Reflection-List-methods/Arturo

1
Lang/Arturo/Rosetta-Code-Find-unimplemented-tasks Symbolic link
View file

@ -0,0 +1 @@
../../Task/Rosetta-Code-Find-unimplemented-tasks/Arturo

1
Lang/Arturo/Spelling-of-ordinal-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Spelling-of-ordinal-numbers/Arturo

1
Lang/Arturo/Taxicab-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Taxicab-numbers/Arturo

1
Lang/Arturo/Weird-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Weird-numbers/Arturo

1
Lang/Arturo/Zumkeller-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Zumkeller-numbers/Arturo

21
Lang/Atari-BASIC/00-LANG.txt
View file

@ -3,6 +3,23 @@
|tags=basic,ataribasic
}}
{{Implementation|BASIC}}
'''Atari BASIC''' refers to the BASIC that shipped with Atari 8-bit micros.
'''Atari BASIC''' refers to the BASIC that shipped with Atari 8-bit micros. Revision A was released on cartridge for early models like the Atari 400 and 800 (1979), while revision B was included in ROM on later models such as the 800XL (1983). (Revision A is considered superior because revision B has more bugs!) Revision C was released on cartridge to address the bugs introduced in revision B. It was also in ROM on later 800XL computers and the XE range.
See Wikipedia: https://en.wikipedia.org/wiki/Atari_BASIC
Emulators for Atari 8-bit computers include:
*[https://atari800.github.io/ Atari800] (Windows, Mac, Linux, etc.)
*[https://www.virtualdub.org/altirra.html Altirra] (Windows)
Downloading the original Atari ROMs is not necessary for Atari800 or Altirra because they include the open source Altirra ROMs, which also feature Altirra BASIC, a fully compatible replacement for Atari BASIC. Altirra BASIC and OS are also better optimized than the original Atari ROMs; especially FOR loops and floating point functions are much quicker.
To start Atari800 in BASIC mode, run it as <code>atari800 -basic</code>. Some important keys in Atari800 are F1=Settings, F5=Reset, F7=Break, F9=Quit, F10=Screenshot; see [https://github.com/atari800/atari800/blob/master/DOC/USAGE DOC/USAGE] for more. Lowercase characters in strings can be entered by first pressing Caps Lock in Atari800.
In Atari800, folders on the host computer can be mounted in ''Emulator Configuration ⇨ Host Device Settings'', so then you can e.g. use <code>LOAD "H1:MYPROG.BAS"</code> to load a program from local disk. By default, folders are mounted read-only.
BASIC programs in tokenized form are loaded and saved with LOAD and SAVE; in ASCII/ATASCII format you load them with ENTER and save them with LIST, e.g. <code>LIST “H1:PROGRAM.LST”</code>.
After 9 minutes of inactivity, a screen saver (called attract mode by Atari) will activate and cycle colors. This can be stopped by an occasional <code>POKE 77,0</code> to reset the timer.
Like in Palo Alto Tiny BASIC, commands can be abbreviated by their first (unique) letters and a period, e.g. <code>L.</code> for <code>LIST</code> or <code>GR.</code> for <code>GRAPHICS</code>.
==See Also==
*[https://en.wikipedia.org/wiki/Atari_BASIC Atari BASIC] in Wikipedia

1
Lang/Atari-BASIC/Archimedean-spiral Symbolic link
View file

@ -0,0 +1 @@
../../Task/Archimedean-spiral/Atari-BASIC

1
Lang/Atari-BASIC/Chaos-game Symbolic link
View file

@ -0,0 +1 @@
../../Task/Chaos-game/Atari-BASIC

1
Lang/Atari-BASIC/Color-of-a-screen-pixel Symbolic link
View file

@ -0,0 +1 @@
../../Task/Color-of-a-screen-pixel/Atari-BASIC

1
Lang/Atari-BASIC/Colour-bars-Display Symbolic link
View file

@ -0,0 +1 @@
../../Task/Colour-bars-Display/Atari-BASIC

1
Lang/Atari-BASIC/Draw-a-clock Symbolic link
View file

@ -0,0 +1 @@
../../Task/Draw-a-clock/Atari-BASIC

1
Lang/Atari-BASIC/Mandelbrot-set Symbolic link
View file

@ -0,0 +1 @@
../../Task/Mandelbrot-set/Atari-BASIC

1
Lang/Atari-BASIC/Musical-scale Symbolic link
View file

@ -0,0 +1 @@
../../Task/Musical-scale/Atari-BASIC

1
Lang/Atari-BASIC/Random-number-generator-device- Symbolic link
View file

@ -0,0 +1 @@
../../Task/Random-number-generator-device-/Atari-BASIC

1
Lang/Atari-BASIC/Reverse-a-string Symbolic link
View file

@ -0,0 +1 @@
../../Task/Reverse-a-string/Atari-BASIC

1
Lang/Atari-BASIC/System-time Symbolic link
View file

@ -0,0 +1 @@
../../Task/System-time/Atari-BASIC

1
Lang/Atari-BASIC/Terminal-control-Hiding-the-cursor Symbolic link
View file

@ -0,0 +1 @@
../../Task/Terminal-control-Hiding-the-cursor/Atari-BASIC

1
Lang/Atari-BASIC/Terminal-control-Inverse-video Symbolic link
View file

@ -0,0 +1 @@
../../Task/Terminal-control-Inverse-video/Atari-BASIC

1
Lang/Atari-BASIC/Terminal-control-Positional-read Symbolic link
View file

@ -0,0 +1 @@
../../Task/Terminal-control-Positional-read/Atari-BASIC

1
Lang/Atari-BASIC/Terminal-control-Ringing-the-terminal-bell Symbolic link
View file

@ -0,0 +1 @@
../../Task/Terminal-control-Ringing-the-terminal-bell/Atari-BASIC

1
Lang/AutoHotKey-V2/00-LANG.txt
View file

@ -1 +0,0 @@
{{stub}}{{language|AutoHotKey V2}}

2
Lang/AutoHotKey-V2/00-META.yaml
View file

@ -1,2 +0,0 @@
---
from: http://rosettacode.org/wiki/Category:AutoHotKey_V2

1
Lang/AutoHotKey-V2/Hello-world-Graphical
View file

@ -1 +0,0 @@
../../Task/Hello-world-Graphical/AutoHotKey-V2

16
Lang/Autohotkey-V2/00-LANG.txt Normal file
View file

@ -0,0 +1,16 @@
{{stub}}AutoHotkey V2 is an [[open source]] programming language for Microsoft [[Windows]].
AutoHotkey v2 is a major update to the AutoHotkey language, which includes numerous new features and improvements.
== Citations ==
* [https://www.autohotkey.com/docs/v2/ Documentation]
* [http://autohotkey.com/download Downloads]
* [http://autohotkey.com/docs/scripts/ Script Showcase]
* [http://autohotkey.com/boards/ New Community forum]
* [http://www.autohotkey.com/forum/ Archived Community forum]
* [http://ahkscript.org/foundation AutoHotkey Foundation LLC]
* [[wp:AutoHotkey|AutoHotkey on Wikipedia]]
* <span class="external text" rel="mw:ExtLink nofollow">#ahk</span> on [http://webchat.freenode.net/?channels=%23ahk Freenode Web interface]
* [[:Category:AutoHotkey_Originated]]
{{language|Ayrch}}

2
Lang/Autohotkey-V2/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Category:Autohotkey_V2

1
Lang/Autohotkey-V2/Hello-world-Graphical Symbolic link
View file

@ -0,0 +1 @@
../../Task/Hello-world-Graphical/Autohotkey-V2

1
Lang/BASIC/00-LANG.txt
View file

@ -37,6 +37,7 @@ BASIC became popular, with many different implementations for various computers.
***[[wp:Applesoft BASIC]]
***[[wp:Atari Microsoft BASIC]]
***[[wp:Commodore BASIC]]
***[[wp:Extended Color BASIC]]
***[[wp:IBM BASIC]]
***[[wp:MS BASIC for Macintosh]]
***[[wp:MSX BASIC]]

1
Lang/BASIC/Arithmetic-derivative Symbolic link
View file

@ -0,0 +1 @@
../../Task/Arithmetic-derivative/BASIC

1
Lang/BASIC/Temperature-conversion
View file

@ -1 +0,0 @@
../../Task/Temperature-conversion/BASIC

1
Lang/BQN/Bell-numbers Symbolic link
View file

@ -0,0 +1 @@
../../Task/Bell-numbers/BQN

1
Lang/BQN/Call-an-object-method Symbolic link
View file

@ -0,0 +1 @@
../../Task/Call-an-object-method/BQN

1
Lang/BQN/I-before-E-except-after-C Symbolic link
View file

@ -0,0 +1 @@
../../Task/I-before-E-except-after-C/BQN

4
Lang/Basic09/00-LANG.txt
View file

@ -1 +1,3 @@
{{language|Basic09}}Basic09 is a dialect of BASIC created by Microware Systems Corporation in 1978 for use on the OS-9 operating system designed for the Motorola 6809 microporcessor. There is a version for OS-9/68000, "Microware BASIC", identical save that the INTEGER type is a four-byte signed integer instead of two-byte and REAL is IEEE 754 double precision rather than the five-byte format in the original version.
{{language|Basic09}}
{{implementation|BASIC}}
Basic09 is a dialect of BASIC created by Microware Systems Corporation in 1978 for use on the OS-9 operating system designed for the Motorola 6809 microporcessor. There is a version for OS-9/68000, "Microware BASIC", identical save that the INTEGER type is a four-byte signed integer instead of two-byte and REAL is IEEE 754 double precision rather than the five-byte format in the original version.

22
Lang/Blade/00-LANG.txt
View file

@ -6,25 +6,13 @@
|parampass=value
|LCT=yes}}{{language programming paradigm|Object-oriented}}{{language programming paradigm|functional}}
'''Blade''' is a simple, fast, clean and dynamic language that allows you to develop complex applications quickly. Blade emphasises algorithm over syntax and for this reason, it has a very small but powerful syntax set with a very natural feel.
'''Blade''' is a modern general-purpose programming language focused on enterprise Web, IoT, and secure application development. '''Blade''' offers a comprehensive set of tools and libraries out of the box leading to reduced reliance on third-party packages.
If you’ve ever had experience with a compiled language (e.g. [[C]]/[[C++]], [[Java]], etc), then one thing you’ll quickly notice (at least I did) was how much the whole process of write-compile-run-debug can be tedious and get in the way of creative programming and sometimes you even forget that mind-blowing algorithm you were going to write and take over the world in the whole process of compiling.
'''Blade''' comes equipped with an integrated package management system, simplifying the management of both internal and external dependencies and a self-hostable repository server making it ideal for private organisational and personal use. Its intuitive syntax and gentle learning curve ensure an accessible experience for developers of all skill levels. Leveraging the best features from JavaScript, Python, Ruby, and Dart, '''Blade''' provides a familiar and robust ecosystem that enables developers to harness the strengths of these languages effortlessly.
Sometimes, you just want to automate a few tasks, for example, I have a simple program to always remind me to get away from my laptop and eat something (you know how it is) and yet another one to suggest food for me. Do you find yourself needing this often? Do you know why you haven’t written it? Get out of your head, you are writing a compiled language! Compiling takes longer than the time it will take you to convince yourself that you need to eat.
At other times, you have written this amazing program and you want users to be able to control it using a simple scripting language. I know… I know… there are many interpreted languages out there that will do the job just fine. Well… you still have one problem. Your users aren’t going to remember all the crazy going on in many of them (Yes [[Lua]]! I’m staring at you. What you gonna do about it?)
Other times, we kind of find a very good solution to our problem in languages like [[Python]] (I must confess, even '''Blade''' did learn a lot of things from it), but the structure of such languages usually creates a new overhead in writing complex programs. It’s really difficult keeping a tab of indentations in such languages especially when you are not in a GUI IDE environment. I tried to work [[Python]] in nano, but man… it wasn’t easy.
If you are feeling me, then Blade is just right for you.
Blade is a simple language that has tried very much to learn from the mistake and successes of its predecessors.
Blade is interpreted and simple like [[Python]] but with a more generic [[C]]-like syntax and a ridiculously simple Object-orientation similar to [[Dart]] and the granularity of [[JavaScript]] while still maintaining a very minimal syntax and keywords when compared to all of them.
'''Blade is designed to be a memorizable language and the entire “language” can be learned in one sitting. However, Blade is as complete and powerful as any language can be and can be applied in the field of web, mobile, desktop, scientific, academic and research engineering to mention a few.'''
While '''Blade''' focuses on Web and IoT, it is also great for general software development.
==Links==
* [https://bladelang.com https://bladelang.com]
* [https://bladelang.org https://bladelang.org]
* [https://github.com/blade-lang/blade https://github.com/blade-lang/blade]
* [https://bladelang.com/quick-learn.html Quick Language Introduction]
* [https://bladelang.org/quick-learn.html Quick Language Introduction]

1
Lang/C-sharp/Periodic-table Symbolic link
View file

@ -0,0 +1 @@
../../Task/Periodic-table/C-sharp

1
Lang/CLU/Arithmetic-derivative Symbolic link
View file

@ -0,0 +1 @@
../../Task/Arithmetic-derivative/CLU

Some files were not shown because too many files have changed in this diff Show more