CPCWiki - THE Amstrad CPC encyclopedia! - User contributions [en]

Talk:Locomotive BASIC

2007-03-02T11:41:55Z

C2r:

Thanx a lot, Zilogmonkey, for your contributions. Hope, we will get the command descriptions finished at one day. -- [[User:Prodatron|Prodatron]] 17:54, 26 February 2007 (CET)

== Splitting article into smaller pieces ==
Well, after I added subcategories (which are necessary in my opinion to jump to a command easily and from other articles) you can see that the whole index blowed up :(. I guess that this was the reason in the C64 wiki to add an article for each command and I fear we will end up like they did, because you then have the possibility to add a category and let the wiki create a alphabetical index. Another point is, that if you want to describe a command more in detail you need the space for a short example routine which will make this article very, very big in the future. --[[User:Octoate|Octoate]] 09:46, 14 September 2006 (CEST)
: Yes, I agree. I must admit, that it makes much more sense to have one article for each command. -- [[User:Prodatron|Prodatron]] 11:39, 14 September 2006 (CEST)
:Well, imagine that... sucks! Then again, nobody prohibits you from collapsing the contents, no? [[User:Gryzor|Gryzor]] 13:16, 14 September 2006 (CEST)
::Yes, that's right, but I don't want to do something which is cancelled some days later, because this a lot of work to do (I already had the experience). --[[User:Octoate|Octoate]] 13:36, 14 September 2006 (CEST)
:Yep, that seems reasonable, as the contents table is not usable now... We should only keep list of commands here(with links), and move the explanation, examples of usage and all that to diffrent articles... Only then, I fear that things like article on "BORDER" would be quite short...--[[User:Torn|Torn]] 14:22, 14 September 2006 (CEST)

:: Yes it would make sense to split this article into articles on each keyword! Maybe we could group the the links in the main article into: Keywords, Functions, Graphics... etc! --[[User:Ygdrazil|Ygdrazil]] 14:39, 14 September 2006 (CEST)

:: Why not have this page including a list of commands and short examples.... and then have longer ones that require with their own pages... Like Border and Goto would be fairly obvious so wouldn't require it, but some of the others could have longer articles. [[User:C2r|C2r]] 21:47, 26 February 2007 (CET)

:::Well, it goes without saying that this would be the ultimate guide to Basic. A new article for some of the commands that will expand on their use with examples and tweaks... Unfortunately my Basic is VERY rusty, I wouldn't trust myself to write anything :( [[User:Gryzor|Gryzor]]

:::: Hehe, mine too. Something which might be an idea is to move the Basic commands reference from this page to another, e.g. [[List of Locomotive BASIC commands]], and link to that page from the main Locomotive Basic page. This would separate those people wanting information about basic including the history and general information from the people using the page as a reference with examples etc. All the pages could be grouped together via a Category:Basic, for example. just some thoughts....! [[User:C2r|C2r]] 22:25, 1 March 2007 (CET)

::::: Well, I don't know, because just a list of the commands sounds like pointless... It would only be of use if complimented by something more detailed, not by itself?? [[User:Gryzor|Gryzor]] 09:25, 2 March 2007 (CET)

:::::: Perhaps list of commands for the title of the page doesn't quite sell the idea... What I mean is to move the existing command list from the Locomotive Basic Page to a new one, with the new page containing the information about the names of the commands, their use, and short examples, with links to more detailed individual pages with longer examples and uses only for those that require it. [[User:C2r|C2r]] 12:41, 2 March 2007 (CET)

Talk:Locomotive BASIC

2007-03-01T21:25:36Z

C2r: /* Splitting article into smaller pieces */ added some thoughts

Amstradbladet

2007-03-01T21:17:06Z

C2r: spellings

[[Image:Amstradbladet.JPG|right|thumb|250px|Amstradbladet Frontpage]]

'''Amstradbladet''' was a Danish CPC magazine running from 1984 to 1988.

The Amstrad CPC was a late entry to the Danish computing scene. Commodore
was already established (since 1982), when the Amstrad CPC arrived in Denmark in October 1984.

Other than Commodore, Amstrad was the most successful manufacturer of home computers for the Danish market in the 1980s. After the closure of Amstradbladet the dominance of Commodore was apparent in Denmark.

A dedicated group of people left when Amstradbladet closed, and started
[[Amstrad Bruger Bladet]]. Amstrad Bruger Bladet published its last issue in November 1989.

[[Category:CPC Press]] [[Category:Magazines]]

INPUT

2007-03-01T20:49:00Z

C2r: sp.

Short-lived danish magazine

This magazine specialized in typeins.

Running from 1986 - 1987

Four issues were published.

<gallery caption="INPUT">
Image:INPUT8601001 small.jpg|Issue 1 1986
Image:INPUT8602001 small.jpg|Issue 2 1986
Image:INPUT8701001 small.jpg|Issue 1 1987
</gallery>

Amstrad Bruger Bladet

2007-03-01T20:47:44Z

C2r: sp (o:

[[Image:ABBladet880102001 small.jpg|300px|thumb|Amstrad Bruger Bladet]]

After the closure of [[Amstradbladet]] a group of people continued to support Amstrad computers and started Amstrad Bruger Bladet.

Talk:Locomotive BASIC

2007-02-26T20:47:13Z

C2r:

Locomotive BASIC

2007-02-26T20:43:15Z

C2r: /* LET */

{{stub}}

[[Image:Screenshots-CPC_Start_screen.jpg|thumb|CPC Start Screen showing Locomotive copyright and BASIC version]]

Locomotive BASIC was a [http://en.wikipedia.org/wiki/BASIC_programming_language BASIC] interpreter for the Amstrad CPC range of computers.

== Description ==

Locomotive BASIC, was one of the best and fastest BASIC implementations of the era. The language benefited both from a clean, well-thought out implementation of the core language by Locomotive, and by the excellent [[firmware]] of the CPC, which lent most of its advanced features to the BASIC.

Unlike the competing Commodore 64, it featured a comprehensive graphic capabilities with its PLOT, DRAW, PAPER, INK, PEN, BORDER and (in BASIC 1.1) FILL commands. It had extensive sound commands, granting control of the [[AY-3-8912]] via the firmware's volume and tone envelope system. With the SOUND command, you could select channels, set envelopes, pitch, noise and volume. That was something unmatched by other computers of that era.

Also there was simple interface for memory management, with MEMORY and LOAD commands. The latter allowed for loading of raw screen data, thus providing easy picture showing. Both through this (combined with CALL, PEEK and POKE) and the firmware's [[RSX]] system, it was easy to mix BASIC and assembly code, thereby speeding up programs by coding the slowest parts directly in machine code. Many successful programs, including games such as [[Radzone]] and applications such as [[PowerPage]], made use of this technique.

With DEF FN, ON variable GOTO and ON variable GOSUB, Locomotive BASIC provided the rudiments of "structured programming", though nowhere near the extent of the PROCedures of [[BBC BASIC]].

All in all, if you compare BASIC interpreters of that era, the Locomotive's seems to be the best 'all-rounder' regarding the combination of speed and complexity, and still some of its features were unmatched by others.

== History ==

The CPC implementation of Locomotive BASIC was developed directly from [[Locomotive Software]]'s existing Z80 BASIC. The existence of this is cited as one of the reasons Locomotive requested that [[Amstrad]] change the CPC's processor from a 6502 to a [[Z80]].

The 464 shipped with BASIC 1.0 on ROM.

The language was revised and debugged for the 664, 6128 and Plus machines to become BASIC 1.1. Changes were minor but significant for the programmer, and included:

* DEC$ bug removed (in BASIC 1.0, it required two opening brackets and was undocumented)
* Better handling of string arguments to RSXs (|DIR,"*.BAS" rather than a$="*.BAS":|DIR,@a$)
* DATA statements can appear anywhere within a line; in BASIC 1.0, they had to be at the end of a line
* FILL command (fill area with solid colour)
* COPYCHR$ function (fetch character from screen)
* Better garbage collection
* Some number-handling bugs removed (e.g. in FOR loops with negative start/end values)
* FRAME (CALL &BD19)
* Extra, optional 'plotting mode' parameter for DRAW/PLOT commands (supported only through control codes on BASIC 1.0)
* GRAPHICS PAPER, GRAPHICS PEN commands
* ON BREAK CONT (disable ESCape)
* CLEAR INPUT (flush keyboard buffer)
* The AUTO command show the whole line if it exist, it only printed a * on the 464

Some parts of 'BASIC' were actually housed in the firmware ROM, but were not officially accessible to other programs. This included the line editor.

The 'pure BASIC' parts of Locomotive BASIC - i.e. those not concerned with CPC-specific firmware and hardware features - were upgraded to become Mallard BASIC, the CP/M language shipped with the [[PCW]]. This also featured exceptionally advanced random-access file handling, a feature missing from the CPC.

== Command list ==

=== Commands and operators ===

==== AFTER I[,t] GOSUB Ln ====
: Waits for i/50 seconds and then jumps to the subruotine at line Ln.

==== AUTO [Ln, i] ====
: Automaticaly generates line numbers starting at line Ln with increment i between line numbers.
: Use [ESC to leave AUTO mode. Default value for Ln and i is 10.
: Example:

<pre>
AUTO 100,5 - generates line numbers 100, 105, 110...
</pre>

==== BORDER color ====
: Changes the color of the border.

==== CALL add[,list of parameters] ====
: Allows an externally developed subroutine to be called by BASIC
::''Example:''
::CALL 0 - resets the computer completely

==== CAT ====
: Displays the names of all existing programes on the tape or disk.
::'''Examples:'''
::CAT [ENTER] - lists all disk files in alpha-numeric order
::TAPE [ENTER]
::CAT [ENTER] - lists names of all tape files in their storage order

==== CHAIN "filename"[,ln]====

:Enables the specified program to be loaded and RUN automatically. If the optional parameters ln is specified, the program execution will commence from line ln.

==== CHAIN MERGE "filename"[,ln][,DELETE1 nl - 1n2]====

:Loads the specified program from tape or disk, merges it into the program in memory, and starts execution of the merged program. The parameter DELETE1n1 - 1n2 is used to delete part of the original program before running it, if required.

==== CLEAR ====
: Clears all variables from memory, leaving the program in memory unchanged. All open files are abandoned.

==== CLG [ink] ====
: Clears the graphics screen to colour specified by ink. If parameter ink is not specified them the graphics screen is cleared to the colour specified by the GRAPHICS PAPER statement.

==== CLOSEIN ====
: Closes any input file (tape or disk).

==== CLOSEOUT ====
: Closes any output file (tape or disk).

==== CLS ====
: Clears the screen. The text cursor is moved to the upper left corner.

==== CONT ====
: [...]

==== CURSOR ====
: [...]

==== DATA x1[,x2,x3...]====
: Defines a data ''section'' to be used by <tt>READ</tt> calls.
: Data values can be of any type (integer, real or string) as long as the corresponding <tt>READ</tt> calls use a variable of the right type.

:Example:

<pre>
10 DATA "Hello, world!", 42
20 READ message$:PRINT message$
30 READ answer:PRINT "The answer is:";answer
</pre>

:''See also:'' <tt>READ</tt>, <tt>RESTORE</tt>

==== DEF ====
: [...]

==== DEFINT ====
: [...]

==== DEFREAL ====
: [...]

==== DEFSTR ====
: [...]

==== DEG ====
: Switch to degrees mode for trigonometric functions (<tt>SIN</tt>, <tt>COS</tt>...).

''See also:'' <tt>RAD</tt>

==== DELETE [line] ====
: Deletes the current program completely (without argument) or only the given line.

==== DI ====
: Disables interrupts (but not[ESC]) until re-enabled by EI command or by RETURN at end of an interrupts service routine.

==== DIM v[$](i1[,i2]) ====

: Specifies storage space to be allocated for list or table v[$]. i1 is number of rows, i2 is number of columns. If a list or a table is not specified by DIM, i1 and i2 default to 10.

==== DRAW x,y [,[i1][,i2]] ====
: Draws a line from the current cursor position to position x,y. i1 specifies colour, i2 is the logical colour.
<pre>
i2 = 0 normal colour i2 = 2 AND colour
i2 = 1 XOR colour i2 = 3 OR colour
</pre>
::''Example:''
::CLG 2
::DRAW 500,400,0 - draws a line from 0,0 to 500,400

==== DRAWR xr, yr, [[i1][,i2]] ====

: Draws a line from current graphics cursor position to current cursor x position + xr, current cursor y position + yr. i1 and i2 as DRAW.
:Example:

<pre>
Move 200,200
DRAWR 100,100,0 - draws a line from 200,200 to 300,300
</pre>

==== EDIT line ====
: Copies one program line to screen in edition mode.

==== EI ====
: Enable interrupts which have been disabled by DI

==== END ====
: Indicates end of program

==== ENT ====
: [...]

==== ENV ====
: [...]

==== ERASE v[$(i1[,i2]) ====
: Clears the contents of an array that is no longer required.

==== ERL ====
: [...]

==== ERROR i ====
: Returns the error message whose error code number is i.

==== EVERY ====
: [...]

==== FILL i ====
: Fills an area of a graphics screen i colour i (0-15). Default value of i is the current graphics pen colour. Only available in Basic 1.1.

==== FN ====
: [...]

==== FOR TO STEP NEXT ====
: [...]

==== FRAME ====
: Smooths character and graphics movement and reduces flicker (waits for a VSYNC signal). Only available in Basic 1.1. On a CPC 464 you can use CALL &BD19 instead.

==== GOSUB i ====

: Jumps to subroutine which is given as argument.
: ''Example:''

<pre>
10 PRINT "Calling subroutine"
20 GOSUB 100
30 PRINT "Back from subroutine"
40 END
100 REM Begin of the subroutine
110 PRINT "Subroutine started"
120 RETURN
</pre>

==== GOTO i ====
: Jumps to the line number which is given as argument.
: ''Example:''
<pre>
10 GOTO 100
20 REM not executed
30 REM not executed
100 PRINT "Hello World!"
</pre>

==== GRAPHICS ====
: [...]

==== IF THEN ELSE ====
: [...]

==== INK ====
: [...]

==== INPUT ====
: [...]

==== KEY ====
: [...]

==== LET ====
: Used to define variables.
: ''Example:''
<pre>
10 LET a$ = "hello world"
20 PRINT a$
</pre>

==== LINE ====
: [...]

==== LIST ====
: [...]

==== LOAD ====
: [...]

==== LOCATE x,y ====

: Moves the text cursor to the x,y location.

: x starts at 1 on the left and goes up to 20 (in mode 0), 40 (in mode 1) or 80 (in mode 2).

: y starts at 1 at the top and ends at 25 at the bottom.

==== MASK [i1][,i2]====

: Sets bits in each adjacent group of 8 pixel on (1) or off (0) according to binary value of i1 (0-255). i2 determines whether the first point of the line is to plotted (1) or not (0).

:Example:

<pre>
10 CLG 2:MASK 1:MOVE 0,0:DRAW 500,400
20 MASK 15:MOVE 0,0:DRAW 500,400
</pre>

==== MEMORY ====
: [...]

==== MERGE ====
: [...]

==== MID$ ====
: [...]

==== MODE ====
: Changes the screen mode: MODE 0 is 160x200 in 16 colors, MODE 1 is 320x200 4 colors and MODE 2 is 640x200 2 colors.

==== MOVE ====
: [...]

==== MOVER ====
: [...]

==== NEW ====
: [...]

==== ON BREAK ====
: [...]

==== ON ERROR ====
: [...]

==== OPENIN "datafile" ====

: Opens the specified data file for reading.

==== OPENOUT "datafile" ====
: Opens the specified data file for writing.

==== ORIGIN ====
: [...]

==== OUT ====
: [...]

==== PAPER ====
: [...]

==== PEN ====
: [...]

==== PLOT ====
: [...]

==== PLOTR ====
: [...]

==== POKE ====
: [...]

==== PRINT ====
: [...]

==== RAD ====
: Switch to radians mode for trigonometric functions (<tt>SIN</tt>, <tt>COS</tt>...).

: ''See also:'' <tt>DEG</tt>

==== RANDOMIZE [seed] ====

: Resets the pseudo-random generator to the given seed. What is strange is that if no seed is given, one is interactively prompted for.

: A common idiom to have a ''random'' random seed is to do:

<pre>
RANDOMIZE TIME
</pre>

==== READ variable ====
: Gets the next data item (from <tt>DATA</tt> commands), stores it in the given variable and moves to the next item.
The variable must be of the correct type.

''See also:'' <tt>DATA</tt>, <tt>RESTORE</tt>

==== RELEASE ====
: [...]

==== REM [any text]====
: Introduces a comment.

==== RENUM [newLine],[oldLine],[step] ====
: Renumbers the lines of the current program.

: By default, the whole program is renumbered starting at line 10 with multiples of ten. It is important to note that ''jumps'' (<tt>GOTO</tt>, <tt>GOSUB</tt> and the like) are automatically converted to the new line numbers.

: The whole set of parameters can be used to renumber only the last part of a program.

: Example:

<pre>
10 GOTO 20
20 GOTO 30
30 GOTO 10
</pre>

: becomes, after calling <tt>RENUM 100,20,5</tt>

<pre>
10 GOTO 100
100 GOTO 105
105 GOTO 10
</pre>

==== RESTORE [line] ====

: Resets the data pointer used by <tt>READ</tt>. When used without parameters, resets the pointer to the first data in the program. Otherwise, resets the pointer to the given line number.

: Example:

<pre>
10 DATA 10,11,12,13,14
20 DATA 20
READ i:PRINT i
10
Ready
READ i:PRINT i
11
Ready
RESTORE
Ready
READ i:PRINT i
10
Ready
RESTORE 20
Ready
READ i:PRINT i
20
Ready
</pre>

: ''See also:'' <tt>DATA</tt>, <tt>READ</tt>

==== RESUME ====
: [...]

==== RETURN ====
: [...]

==== RUN [line] ====
: Runs the current program, optionally starting at a given line. If no line number is given, starts at the first line.

==== SAVE ====
: [...]

==== SOUND ====
: [...]

==== SPC ====
: [...]

==== SPEED ====
: [...]

==== SQ ====
: [...]

==== STOP ====

: Breaks program execution at line containing the STOP statement. The message '''BREAK in''' is output with the line number.

==== SUB ====
: [...]

==== SWAP ====
: [...]

==== SYMBOL n,i1[,i2,i3,i4,i5,i6,i7,i8] ====

: Redefines the appearance of the character at index n.
: Each of the following eight integers defines the contents of one pixel row, starting at the top of the character.
: Each character fits in an 8x8 pixel grid.
: Missing lines are considered as empty.

: Example:

<pre>
SYMBOL 255,255,129,129,129,129,129,129,255
PRINT CHR$(255)
</pre>

: Defines character 255 to look like an empty square and prints it.

: Initially, only characters with indices ranging from 240 to 255 can be redefined.
: See also <tt>SYMBOL AFTER</tt> to allow redefinition of arbitrary characters.

==== SYMBOL AFTER n ====
: Allows the redefinition of character symbols from index n included.

: Symbol redefinitions are made using the SYMBOL command above.
: Initially, only symbols from index 240 to 255 can be redefined. This initial situation can be restored with <tt>SYMBOL AFTER 240</tt>. Symbol previously redefined are restored to their original appearance.

==== TAB ====
: [...]

==== TAG ====
: [...]

==== TAGOFF ====
: [...]

==== TROFF ====
: [...]

==== TRON ====
: [...]

==== USING ====
: [...]

==== WAIT add, i1[,i2] ====

: Waits until the I/O port at add returns a value (0-255). The value returned is XORed with i2 and the ANDed with i1. This is repeated until a non-zero result occurs.

==== WHILE WEND ====
: [...]

==== WIDTH ====
: [...]

==== WINDOW ====
: [...]

==== WRITE [#st,] v[$], v[$] ====

: Writes the values of the specified variable to the specified stream.

: Example:

<pre>
10 OPENOUT "DUMMY"
20 INPUT A$,A
30 WRITE #9,A$,A
40 CLOSEOUT
</pre>

==== ZONE i====

: Changes the width of the print zone. Default is 13.

=== Operators ===

==== AND ====
: [...]

==== MOD ====
: [...]

==== NOT ====
: [...]

==== OR ====
: [...]

==== XOR ====
: [...]

=== Functions ===

==== ABS (n) ====
: Returns the absolute value of n by ignoring the sign value.

: Example

<pre>
PRINT ABS(-3.5) - prints 3.5
</pre>

==== ASC ====
: [...]

==== ATN (n) ====
: Returns the arctangent of n.

==== BIN$ (i1,[i2]) ====
: Returns binary representation of i1 between -32768 and 65535. The number of binary digits (0s and 1s) is specified by i2 (0-16)
: Example:

<pre>
PRINT BIN$(66,8) - prints 01000010
</pre>

==== CHR$ (n)====
: Returns the character for a given index n. For instance CHR$(65) returns the character 'A'. Valid indices range from 0 (zero) to 255.

: As an example, try the following basic program :

<pre>10 print chr$(208+rnd(2));:goto 10</pre>

: It will draw a random maze with characters 208 and 209, which are an horizontal and a vertical bar.

==== CINT ====
: [...]

==== COPYCHR$ ====
: [...]

==== COS ====
: [...]

==== CREAL ====
: [...]

==== DEC$ ====
: [...]

==== DERR ====

: Gives the most recent error code number returned by [[Amsdos]].

==== EOF ====
: [...]

==== ERR ====
: [...]

==== EXP ====
: [...]

==== FIX ====
: [...]

==== FRE ====
: [...]

==== HEX$ ====
: [...]

==== HIMEM ====
: [...]

==== INKEY ====
: [...]

==== INKEY$ ====
: [...]

==== INP ====
: [...]

==== INSTR ====
: [...]

==== INT ====
: [...]

==== JOY ====
: [...]

==== LEFT$ ====
: [...]

==== LEN ====
: [...]

==== LOG ====
: [...]

==== LOG10 ====
: [...]

==== LOWER$ ====
: [...]

==== MAX ====
: [...]

==== MIN ====
: [...]

==== PEEK ====
: [...]

==== PI ====
: [...]

==== POS ====
: [...]

==== REMAIN ====
: [...]

==== RIGHT$ ====
: [...]

==== RND [(n)] ====
: Generates the next random number in the current squence if n is positive or omitted. If n = 0, the random number generated will be the same as the last random number generated.

==== ROUND (n[,i1]) ====
: Rounds n to a number of decimal places or to the power of ten specified by i. If i is negative, the n is rounded to give an absolute integer with i zeros before the decimal point.
: Example

<pre>
PRINT ROUND(1562.357,2):PRINT ROUND(1562.375,-2) - prints 1562.36 1600
</pre>

==== SGN (n) ====
: Returns 1 if n is positive, 0 if n = 0, -1 if n is negative.

==== SIN (n) ====
: Returns sine of n in degree or radian mode (see DEG and RAD)

==== SPACE$ ====
: [...]

==== SQ (channel) ====
: Returns a bit significant integer showing state of the sound queue for specified channel where channel 1, 2, 3 = A, B, C.
<pre>
Bits 0,1 and 2 number of free entries in the queue
Bits 3,4 and 5 redezvous state at head of the queue
Bit 6 head of the queue is held
Bit 7 channel is currently active
</pre>

==== SQR (n) ====
: Returns the square root of n.

==== STR$ ====
: [...]

==== STRING$ ====
: [...]

==== TAN ====
: [...]

==== TEST ====
: [...]

==== TESTR ====
: [...]

==== TIME ====
: Returns time elapsed since the computer was switched on or reset.
: One second = TIME/300.

==== UNT ====
: [...]

==== UPPER$ ====
: [...]

==== VAL ====
: [...]

==== VPOS (#st) ====
: Reports the current row (line) position of the text cursor relative to the top of the text windows of the specified stream.

==== XPOS ====
: [...]

==== YPOS ====
: [...]

''(Please, fill in. Looks like a lot of work ;-) ...)''

== Error codes ==

* 1 '''Unexpected NEXT''' - Occurs when the FOR of a FOR .. NEXT loop is missing.
* 2 '''Syntax Error''' - Typing error or incorrect punctuation.
* 3 '''Unexpected RETURN''' - Caused by entering a subroutine other than with GOSUB.
* 4 '''DATA exhaused''' - Trying to READ data when data pointer has reached end of data.
* 5 '''Improper argument''' - The argument for a function is not legal (eg. PRINT SQR(--10)).
* 6 '''Overflow''' - The computer cannot handle a number greater than 1.7E38.
* 7 '''Memory full''' - All available RAM is being used or has been reserved. Program to big or control structures too deeply nested.
* 8 '''Line does not exist''' - Attempt to RUN, GOTO or GOSUB a non-existent line number.
* 9 '''Subsript out of range''' - Value of a subscript in an array is greater than DIM declaration.
* 10 '''Array already dimensioned''' - Arrays can only be DIMensioned once within a program.
* 11 '''Division by zero''' - Trying to divide a number by zero.
* 12

== Other Basic Dialects avaliable for the CPC ==

*[[BBC Basic]]
*[[C BASIC Compiler|C BASIC]]
*[[E-BASIC]]

== Web links ==

* [http://www.kjthacker.f2s.com/docs/bastech.html Technical information at the Unofficial Amstrad WWW Resource]
* [http://www.sean.co.uk/books/amstrad/bforbasic.shtm Locomotive Basic Tutorial by Sean McManus]

[[Category:Programming]]

Tas-Spell

2007-02-25T10:04:52Z

C2r: added cat, wiki links

Program to add Spell checking ability to [[Tasword]].

Like it's parent program, it did its job well but was overshadowed by the far more powerful [[ProSpell]].

[[Category:Applications]]

Roland

2007-02-25T10:03:33Z

C2r: added cat

Roland was Amstrad's idea of a recurring character in very early Amsoft games. Other computer games of the mid-1980s frequently employed such a device, such as the Miner Willy character in [[Manic Miner]] and [[Jet Set Willy]].

Roland was both an anagram of [[Arnold]], the codename for the CPC, and the first name of CPC designer [[Roland Perry]].

Appearances in (Very Incomplete List):

* [[Roland Ahoy]]
* [[Roland Goes Digging]]
* [[Roland Goes Square Bashing]]
* [[Roland in Space]]
* [[Roland in the Caves]]
* [[Roland in Time]]
* [[Roland on the Ropes]]
* [[Roland Takes a Running Jump]] (type-in from [[Computing with the Amstrad]]?)

[[Category:Games]]

Clones

2007-02-25T10:02:11Z

C2r: added cat

This is a list of '''Amstrad CPC clones'''.

==Classic Amstrad CPC clones==
* [[KC Compact]] (1989-1990; East Germany)
* [[Aleste 520EX]] (1993; Russia)

==Modern Amstrad CPC clones==
* [[CPC TREX]] (FPGA based solution)
* [[C-ONE]] (FPGA based multi machine solution)
* [[CPCng]] (development currently has been stopped)

[[Category:Hardware]]

Pro-Ext

2007-02-25T10:00:24Z

C2r: added cat

Pro-Ext was an extension utility for [[Protext]], written by [[ChaRleyTroniC]] and sold by [[Sentinel Software]].

It enabled you to incorporate large headline fonts and clip art into Protext documents, which could then be printed out (in graphics mode) on a standard Epson-compatible printer. It was revised several times to v1.5.

The program was due to be replaced by the never-finished [[Fidelity]].

[[Category:Applications]]

Disc format

2007-02-25T09:59:23Z

C2r: added cat

CPCs could read discs formatted in three separate ways. Several high-capacity disc operating systems existed to add new formats to the three standard ones.

== Standard CPC disc formats ==

* '''Data''': 180k single-sided. 40 tracks of nine 512-byte sectors each. Sectors numbered &C1 to &C9. 64 directory entries. Can also be read by [[PCW]]s. The useable capacity is 178k.
* '''System''': 180k single-sided. 40 tracks of nine 512-byte sectors each. Sectors numbered &41 to &49. 64 directory entries. Two reserved tracks containing CP/M BIOS. The useable capacity is 169k.
* '''IBM''': 160k single-sided. 40 tracks of eight 512-byte sectors each. Sectors numbered &01 to &08. Provided for compatibility with CP/M-86 (and DR-DOS 1.0). Used by very few CPC purchasers, but Locomotive Software stated that this was invaluable for cross-assembly. The useable capacity is 158k.
* '''Vendor''': Term used for System format discs with no software in the reserved tracks. The useable capacity is 169k.

== Third-party CPC disc formats ==

* [[FAT]] formats [http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx] (invented by MS-DOS; supported by [[SymbOS]], [[DOS Copy]], [[ReadDSK]], [[SymDOS]], [[DSK-CPC]])
* [[MS800]] formats
* [[Stream2#MoDOS|Prem]] format (supported by [[Stream2]])
* [[RODOS]] formats
* [[ROMDOS]] formats (also supported by [[ParaDOS]]: D80 supported by [[S-DOS]] and [[400K/S]])
* [[Ultraform]]
* [[Xexor]] formats (also supported by [[ParaDOS]])
* XD-DOS etc.??

== References ==

* http://www.seasip.demon.co.uk/Cpm/amsform.html
* http://www.wacci.org.uk/magazine/138/138_08.html
* http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx

[[Category:Hardware]]

Fantasy World Dizzy

2007-02-25T09:58:39Z

C2r: amended page to redirect to dizzy page

#REDIRECT [[Dizzy]]

Technical documentation

2007-02-25T09:54:19Z

C2r: added cat

== Internal components ==
* [[Arnold_V_specs]] - Arnold V (CPC+) Technical Specification
* [[I/O Port Summary]] - map of all known I/O ports of the CPC
* [[Serial interface]] - how to use the DART and 8253 chips of an Amstrad-compatible serial interface
* [[AY-3-8912]] - Sound chip / keyboard controller
* [[CRTC]] - Video chip
* [[Gate Array]] - Custom chip (frequency generation, colors, bank switching)
* [[PIO]] - I/O controller

== Hardware extensions ==

* [[Programming:SYMBiFACE II|SYMBiFACE II]]

== Specifications ==

* [[Disc format]]s
* [[Format:SGX (SymbOS graphic files)|SGX (SymbOS graphic files)]]
* [[Format:VID (SymbOS video files)|VID (SymbOS video files)]]

== Howto's ==

* [[Changing the drive belt]]

[[Category:Hardware]]

Where to learn?

2007-02-25T09:51:45Z

C2r: added cat

''Note: This article was originally [http://www.cpczone.net/boards/viewtopic.php?t=1102 a post at the CPC Zone forums]''

Well, here's some info that I hope will be useful to both you and others. I know very little about the MSX though, this is mostly about the CPC, although the Z80 assembler is the same for all computers; read on.

First you need to make up your mind on what programme/game you are going to make. BASIC offers easiness and stability and quick development. Assembly code runs fast, but takes a while (so to speak) to write.

On the CPC there's a choice of writing your program in assembler only, in a combination of assembler and BASIC, or in BASIC only (or of course in some other language(s)). You can use a BASIC compiler for speeding up BASIC code. FABACOM compiler speeds up a BASIC program by about a factor of 8. However there are no BASIC sprite routines; these have to be written in assembly anyway or use some ready-made routines.

== Assembly ==
=== What assembly is ===

I think you could divide the problem of low level coding into three distinct parts.

# Z80 assembly language 
# Assembler syntax 
# CPC specifics (memory map, firmware (i.e. OS) and hardware)

By saying "assembly", "assembler" or "asm" (for short) 1. and 2. get intermixed and sometimes confuse people. By saying "assembly" the connotations point more to the z80 assembly language (it's commands, a.k.a. "mnemonics". This is source code.); this is a mirror of the z80 architecture as every mnemonic has a direct machine code equivalent (i.e. object code). "Assembler" is a term more properly used for a full-blown program that gets the work done of converting source code into machine code and adds its own made-up commands (which are words that look like z80 mnemonics, but are actually only offered for convenience by the assembler) or directives (words that set up and take care of various things) in the syntax for ease of programming. "asm" may mean both.

Also how a CPC does something, like printing a character on the screen depends on its firmware and hardware and how its memory is organized and used by the firmware, hardware and user-programs. The MSX has totally different hardware so here's where your code starts to differentiate. Since most of the asm code is general purpose, this is why Spectrum ports were so easy to make; just use different screen, sound and keyboard drivers and voila... Of course code that is specifically written for the CPC will take more advantage of its hardware (it will be less portable/general-purpose but the programme/game has the potential to run faster and have more features).

=== Z80 assembly language reference documentation (not a tutorial) ===

For general info on the Z80, your best bet I think is Sean Young's (an MSX emulator author) pdf's. These are not tutorials, but contain a list of every z80 mnemonic and how it works (i.e. what parameters it takes and where it stores the result, if there is one.) You should use these mostly for reference, rather for learning.

Pretty complete documentation on the z80, but not a tutorial: 
[http://www.myquest.nl/z80undocumented/z80-documented-v0.91.pdf The Undocumented Z80 Documented v0.91 (pdf)]

An older version of this file may be found here: 
[http://www.kjthacker.f2s.com/docs/z80.pdf Z80 documentation by Sean Young] (basically chapters 8 & 9 from the above document).

A couple short documents that's more of the same thing: 
[http://www.ticalc.org/archives/files/fileinfo/128/12883.html The Complete Z80 Instruction Reference] 
[http://www.ticalc.org/archives/files/fileinfo/1/109.html Z80 Microprocessor Instruction Set Summary]

If you have a look in the latter files, you'll see that there are Z80 commands for moving things around (mostly LD, LDI, PUSH and POP), adding & subtracting & increment & decrement, logical operations, bit operations (bit tests, shifts, rotates), comparing two values & jumps (goto's) & calls ... basically that's all.

What instruction to use depends on two things:

# What you need to do. e.g. You need to add two 8-bit numbers, you use 8-bit addition. You need to add 1 to an 8-bit number, then you increment it by 1. You can do these two things (addition and increment) for 16-bit numbers too.
# What the Z80 is able to do. It just can't do some things, for example it can't multiply two numbers. You'll need to use a multiplication routine for that. You can add a 16-bit value to the HL register pair, but you can't add a 16-bit value to any other register pair (like BC or DE). In order to get around this you'll have to move data around like exchanging the values of registers or saving data into other registers or on the stack or in a memory location. All CISC processors are full of such quirks (they are not "orthogonal", which means you can't combine every command with every possible parameter type(s). Some commands only take specific parameters and you have to live with that).

Assembler is in a class of languages considered error-prone, so you need to take care that your program is stable. Also, by learning z80 assembler you make a step forward for learning x86 assembler since this is a related family of processors.

=== Z80 Assembly tutorial ===

So there's the Z80 general stuff that you can learn in any Z80 tutorial. A good tutorial I know of is the [http://www.ticalc.org/pub/text/z80/z80asmg.zip Independent Z80 Assembly Guide]. Available online at [http://cobb.host.sk/z80guide/index.htm http://cobb.host.sk/z80guide/index.htm]. It "was written in a way that it can be used for ANY Z80 calculator or computer". You can use all of this code with a CPC or CPC emulator and it will work. No graphics, sound, file or input routines are included of course; all this is CPC specific, but once you've learnt some of the general z80 stuff, then you'll be able to access the CPC's specific features. I'd recommend using WinAPE's built-in assembler, assemble everything in CPC's memory and then check the results with WinAPE's debugger (or in BASIC with peeks and pokes and/or short BASIC programs). Just put a

<code>.org #4000</code>

in front of each example, and a

<code>ret</code>

if necessary at the end, assemble and then use

<code>call #4000</code>

from BASIC to run the machine code.

You don't need to know everything in the above tutorial to get you started. I'd say "The Basics" and "Simple Structures" chapters, the "Moving Data Blocks" paragraph and then the multiplication stuff (or skip that and just use a ready-made multiplication routine for now).

Some useful Z80 links:
* [http://www.ticalc.org/pub/text/z80/ Z80 Documentation]
* [http://icarus.ticalc.org/articles/z80_faq.html z80 faq]
* [http://www.kjthacker.f2s.com/docs/z80.html Some features of the Z80 (the Flags and LDIR are the more important)]
* [http://www.kjthacker.f2s.com/docs/mult.html Multiplication with the Z80]

Really "heavy" official Zilog documentation:
* [http://www.myquest.nl/z80undocumented/z80cpu_um.pdf]Z80 Family CPU User Manual]

=== Assembler syntax ===

That tutorial teaches everything about Z80 assembly, but not much in the way of what is not actually a z80 mnemonic (e.g. LD) but an assembler command (e.g. DEFB). I think most directives don't even get a mention, like how to tell the assembler where to put the object code.

Assembly on the CPC is usually MAXAM compatible (like WinAPE's assembler) since that assembler (MAXAM) set a standard on the CPC. (I personally use the WinAPE built-in assembler. You might also like Pasmo which has a feature similar to using local variables in high level language subroutines. In most assemblers all variables are global.) So in CPC assembly, directives like ORG, LIMIT, INCLUDE, EQU, END, BYTE - TEXT - DEFB - DB, WORD - DEFW - DW, RMEM - DEFS - DS, etc. usually depend on how MAXAM defines them. These commands are not actual Z80 commands, but assembler commands/directives. Assembler commands/directives define where to put the compiled code, they define constants, they tell the assembler to include other source files or header files, where and how to reserve space for and how to name variables, etc. Same goes for macros; some assemblers offer the possibility to define and use these for convenience, but they are not part of the z80 mnemonics. Thus macros may result in a little slower code than hand-optimized code.

* [http://www.kjthacker.f2s.com/docs/maxam.pdf Maxam Documentation by Arnor Ltd]
* [http://www.kjthacker.f2s.com/docs/maxam15.pdf Maxam 1.5 Supplementary Documentation by Arnor Ltd]

== The CPC ==
=== CPC memory layout and usage ===

Only 64K is directly accessible by the Z80. On the CPC architecture the last 16K is by default used as the screen data (addresses &C000 to &FFFF). Addresses 0 to &170 and HIMEM+1 to &BFFF is used by the Firmware, BASIC and AMSDOS ROM's. Himem is a Locomotive BASIC variable that reports the highest available free memory location when the CPC boots up. By lowering this value, you assign less space for the BASIC part of your program and it's BASIC data (strings, variables, arrays). The rest (from the new HIMEM's value up to the initial HIMEM value when the computer boots up) can be used by your machine code and its data. You alter the HIMEM value by e.g.

<code>MEMORY &2000</code>

from BASIC. Obviously it shouldn't be lower than &170 or higher than HIMEM's initial value. (Sometimes I personally don't use this at all. If I compile something at &4000 and my BASIC program is small, then I just don't bother with MEMORY and HIMEM because usually nothing gets overwritten.)

=== CPC Hardware & Firmware ===

Once you're through learning the z80 features and z80 assembly syntax, you'll have to learn a little (or a lot) about the CPC Hardware and how it works. You may also like to use some of the ready made routines offered by the CPC OS (the "Firmware").

For the CPC specifics I believe your number one source of information should be [http://www.cpctech.org.uk/ The Unofficial Amstrad WWW Resource], especially the documents and source code sections.

If you'd like to put some graphics (like tiles and sprites) on the screen you'll need some ready-made routines or start learning on how the CPC's screen works and write your own ones.

The firmware documentation:
[ftp://ftp.nvg.ntnu.no/pub/cpc/docs/firmware.zip The Amstrad CPC Firmware Guide] (in .dsk, text and pdf - you have to be a little patient with this link) which describes the ROM routines for loading files, printing characters on the screen, reading keyboard input, drawing lines, using floats/reals and more. It also describes how and what memory is used by the OS. Also online at: [http://www.cantrell.org.uk/david/tech/cpc/cpc-firmware/ http://www.cantrell.org.uk/david/tech/cpc/cpc-firmware/]

== BASIC ==
=== BASIC and BASIC compilers ===

[http://www.amstradcg.nl/cpcbib.html CPC 664 user's manual]. In case you know some Locomotive BASIC (or you'd wish to learn) it contains general info on the computer along with some short Locomotive BASIC tutorials and full BASIC reference. (There's also a 464 OCR'd .pdf if anyone can upload it somewhere.)

Here's an ok BASIC compiler: 
[ftp://ftp.nvg.ntnu.no/pub/cpc/utils/cpc/fabacom.zip FABACOM/FAST BASIC COMPILER], it compiles Locomotive BASIC source. It seems to not like some commands or parameters of commands. You'll know if your program crashes.

There's at least another two Compilers that are supposed to compile Locomotive BASIC code, but I haven't tried them: 
[[Laser BASIC Compiler]] and a french BASIC compiler called Typhon. Both can be found at planetemu.net [http://www.planetemu.net/?section=recherche&recherche=Laser%20BASIC%20Typhon&type=Tous%20les%20mots&rubrique=roms here].

Sean McManus has a nice BASIC tutorial including some assembler routines at: 
[http://www.sean.co.uk/books/amstrad/index.shtm Sean's Amstrad CPC homepage]

== Other languages ==

A VB-style compiler is supposedly coming soon for SymbOS.

A list of languages available on the CPC: 
[[Programming software]]

== A somewhat advanced example: How to use Locomotive BASIC & your own pipe commands ==

You can use this for all asm source you have available, like for the tutorial source code.

When calling some asm code from BASIC, you would use something like: 
<code>10 CLS 
20 MEMORY &3FFF 
30 CALL &4000 
40 END</code>

The Call command calls a machine code routine. If there's nothing at address &4000 then the computer will probably crash.

When you assemble a z80 program it's important to instruct the assembler as to where it should put the resultant machine code. You do this by using the ORG assembler directive, like:

<code>org #4000</code>

for the BASIC code above. If you have several machine code routines that you would like to call from BASIC then where to call depends on where the routine you want to call starts in memory. However calculating or copying and typing in specific addresses is cumbersome because each time you reassemble your program these memory locations may also change.

The easiest way for calling machine code routines from BASIC is to set up a pipe-commands table. These are similar to the |DIR, |B, |CPM, etc. AMSDOS commands. How to do this is described in official Amstrad documentation: [http://www.kjthacker.f2s.com/docs/manual/s968se10.pdf SOFT 968 Section 10 (Expansion ROMs, Resident System Extensions and RAM Programs)]

For example, start up WinAPE, press F6, create a New File from the assembler's File menu and copy and paste this code:

<pre>
KL_LOG_EXT equ &bcd1

org #4000

INITIALIZE: LD HL,WORK_SPACE ;RSX power-up Routine
LD BC,RSX_TABLE
JP KL_LOG_EXT

WORK_SPACE: DEFS 4 ;Area for Kernel to use

RSX_TABLE: DEFW NAME_TABLE

jp print
jp multiply
jp mem_move

NAME_TABLE:
defb 'PRIN','T'+#80
defb 'MULTIPL','Y'+#80
defb 'MEMMOV','E'+#80
DEFB #00

.print
ret

.multiply
ret

.mem_move
ret
</pre>

Assemble and type

<code>Call &4000</code>

from BASIC. Then you can call each of these routines from BASIC by name, like:

<code>|PRINT</code>

Note that there's no code for all three commands (|PRINT, |MULTIPLY, |MEMMOVE) in this example, they just ret-urn to BASIC. You'll have to write the code for each command between each label and it's RET mnemonic or paste some existent code and rename accordingly the command names (below the NAME_TABLE label) and the jump table (the jp commands). Every jp corresponds one-to-one with an entry in the NAME_TABLE; the order is significant. NAME_TABLE entries must be all upper case with no underscores or spaces.

Also you'd probably need to supply a number of parameters to each of the routines like you would in a high-level language function call. In this case A contains the number of parameters and (IX+offset) points to each parameter (each parameter has a word width so offset increases by 2).

If your code is 100% assembler you don't need all of this. Just Call to some memory location and never RET-urn to BASIC.

[[Category: Programming]]

Talk:Samantha Fox Slideshow

2007-02-18T18:00:39Z

C2r: revert - spam

User:C2r

2007-02-17T11:58:11Z

C2r:

Hello, I'm Chris and am adding this text so that my name doesn't appear in red!

I own a 464, 664, and 6128 and a whole host of random peripherals.

Rather annoyingly I can't get tapes to load on the 6128 at the moment, despite them working on the 664.

Oh yeah, I live in Hertfordshire in the UK.

Talk:Amstrad Action

2007-02-17T11:47:42Z

C2r: /* Digi-Alt AA scans */

== Digi-Alt AA scans ==

....doesn't appear to be working... any ideas? [[User:C2r|C2r]] 23:18, 14 February 2007 (CET)

:Ahhh yes, it's gone offline for a while now... we're looking into uploading them to the Wiki server... [[User:Gryzor|Gryzor]]

::Excellent- I've got most of them archived on my PC, as I did a lot of the scanning - so if you're missing any give us a shout. [[User:C2r|C2r]] 12:47, 17 February 2007 (CET)

Talk:Amstrad Action

2007-02-14T22:18:37Z

C2r: Digi-Alt AA scans

== Digi-Alt AA scans ==

....doesn't appear to be working... any ideas? [[User:C2r|C2r]] 23:18, 14 February 2007 (CET)