Hlavná stránka od Diversant Software - Diversant Software

Jednopriechodový (Single-pass) prekladač jazyka assembler od Diversant Software pre procesory INTEL 8051 a 80251. Uvedená cena zahŕňa elektronickú formu spustiteľnej formy pre 16 bitové systémy. Po zaplatení úhrady za vyššie uvedený digitálny produkt formou bankového prevodu, alebo PayPal-u Vám bude doručený na email ktorý ste uviedli pri registrácii link na stiahnutie počas 60 dní.

Kompilátor jazyka Basic pre ZX Spectrum, alebo Didaktic Gama - Didaktik-M .........1.........2.........3.........4.........5.........6.........7.........8 HISOFT Presents The Colt FAST BASIC COMPILER COLT ZX BASIC Compiler Manual Copyright Threlfall and Hodgson 1985 Published by Hisoft 180 High Street Dunstable LU6 1AT First Edition August 1985 = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = CONTENTS -------- Page 1 Introduction Page 1 The compilation process Page 2 Getting started with COLT Page 4 COLT in detail Page 5 Loading the compiler Page 5 COLT statements Page 9 Strings and arrays Page 9 Error messages during compilation Page 10 Run-time errors Page 10 Saving compiled code Page 11 Re-loading compiled code Page 11 Trace facilities Page 12 Compiling up to 32K Page 12 Returning to Basic Page 13 Fetching variables from Basic Page 13 Taking COLT variables back to Basic Page 14 Floating point? Page 15 LOAD commands Page 15 Speed Page 16 Strange Errors Page 16 COLT in Detail Page 18 Changing these space allocations - some useful addresses Page 18 Calls between Basic and COLT Page 19 Compiling subroutines Page 19 Re-entering code Page 21 The Executive Page 22 Using the Executive Page 22 Quick access commands Page 23 User-definable "soft" (function) keys Page 24 Enhanced Basic Commands Page 24 Window commands Page 26 Sprite commands Page 27 Reading the keyboard Page 28 Other commands Page 31 User-defined Basic Page 32 Executive error messages Page 33 Other disc/wafer interfaces = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Introduction ------------ Welcome to the world of fast programs and easy development given to you and your ZX Spectrum with Hisoft's COLT Basic compiler. COLT is a totally new product which transforms your Spectrum Basic programs into pure z80 machine code, making them run between 2 and 800 times faster! COLT is easy to use and is small enough to allow most programs to be compiled. Before we start to use it, we'll look into the process of compilation to see why having a program such as COLT is so handy. The compilation process ----------------------- When you write a Basic program on your Spectrum, you're taking advantage of the machine's in-built "interactive" features. This means that you can write part of a program, run it and correct any errors. This can be done because the Basic system used by the Spectrum is known as an "interpreter". It takes each line of Basic which you type in, and if the line makes sense it is added to the Basic program in memory. The "syntax checker", which prints a flashing '?' whenever you attempt to enter an incorrect line, can detect only what is known as a "syntax error". A syntax error is a programming error which cannot form part of a Basic program because it does not conform to the "syntax rules" of the language. For example, just as we cannot sensibly say "Time four half past is the" in English, we cannot assign a string to a numeric variable in Spectrum Basic: 10 LET a="This will cause a syntax error" The syntax checker cannot detect "algorithmic" errors, which are programming errors that, although perfectly valid Basic, do not really do what you expect or require. You may have a line which adds 10 to a variable, for instance, when in fact you are supposed to be adding 5. These are always the hardest errors to find! Once you have a valid Basic program in the Spectrum's memory, you can execute the program by typing 'RUN' and pressing the ENTER key. Errors can still occur, of course, if you miss out lines or perform incorrect calculations. The program will then stop with an "error report", telling you at which line the error occurred. This is why the system is known as "interactive", as it allows you to correct errors as they occur, rather than having to run the program, find all the errors, and correct them all before running the program again. Interaction is a feature of interpreters, as they run programs in a particular way. When you RUN a program, the interpreter finds the first line of the program, which is stored in the computer as Basic, and works out what it is supposed to do with the line. This may involve continuing on to other lines, it may involve calling subroutines, or it may just print something on the screen and finish. It doesn't matter what it does, but how it does it. Interpreted programs are automatically much slower than the computer is truly capable of because each individual line has to be examined by the interpreter program every time it is met. A FOR ... NEXT loop is not automatically converted into a machine code loop which ends after a certain number of iterations, but is examined each time the line containing the NEXT is encountered, and a check is made to see if the end of the loop has been reached. The Spectrum Basic interpreter lives in the ROM (read- only memory) inside the machine and cannot easily be removed. COLT supplants this interpreter with a program known as a "compiler". A compiler is a program which converts another program written in a particular language to machine code (in this case), so that the computer can run this program directly rather than having to go through an interpreter. In the case of the COLT compiler, the language which it converts from is Spectrum Basic. The end result is a comparatively short machine code program which will do exactly what the Basic program does, but considerably faster. As it is now in machine code, we cannot run our program by typing 'RUN', as this is an interpreter command. Instead, we need to "call" it using an address given to us by the compiler. We can call machine code programs with the RANDOMIZE USR

statement, where

is the address which we want to call. There are a very few Basic features which the COLT compiler cannot handle, but we needn't consider them until later. To see how the whole system works, let's start from the beginning. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Getting started with COLT ------------------------- The COLT compiler is supplied on a cassette tape which incorporates a short BASIC loader to get the compiler into memory and initialise it. Make sure that this cassette is fully rewound and then place it in your cassette player ready to be loaded. Type: LOAD "" (ENTER> (press the 'J' key followed by two presses of the SYMBOL-SHIFT 'P' combination) and press PLAY on your cassette recorder. After a few seconds the familiar tape loading stripes should appear on the screen and the program name will be printed: Program: COLT If this doesn't happen, rewind the cassette recorder and try again. If, after numerous attempts, you still cannot get the tape to load, return it to Hisoft when we will be pleased to send you a free replacement. Eventually, the BASIC program will have loaded and started running. The first thing it does is to automatically load the compiler machine code into the computer. When the whole process has finished, you will be asked if you want to make a backup (working) copy of the compiler. If this is the first time that you have used the compiler, we strongly recommend that you answer 'Y' to this question. Hisoft licences you to make one working copy of the compiler on either cassette tape or microdrive cartridge. If you do answer 'Y', you will then be asked if you want to save the copy to cassette tape or microdrive. If you have a microdrive it is obviously sensible to save your working copy on a cartridge as it will subsequently load much faster. Next you are asked whether you want to change the start address of the compiled program from 40000. Answer 'N' to this at the moment, as you won't need to do this until you are compiling large programs. You'll see the screen clear and a clock appear in the top right of the screen, ticking away happily. This clock is part of the "Executive" program, which we'll be examining in greater detail later. Now type in this program in the normal way: 10 LET h$="0123456789ABCDEF" 20 FOR a=0 TO 255 30 LET d$=" " : REM TWO spaces inside the string 40 GO SUB 100 50 POKE 23692,255 60 PRINT a;" = ";d$ 70 NEXT a 80 STOP 100 LET x=INT (a/16): LET y=a-16*x 110 LET d$(1)=h$(x+1) 120 LET d$(2)=h$(y+1) 130 RETURN When you run this program, you will see the numbers from 0 to 255 printed out along with their hexadecimal (base 16) equivalents. The "POKE 23692,255" statement on line 50 simply stops the computer asking "Scroll?" each time the screen is filled up. If you time this program, you'll find that it takes just over 30 seconds to complete. To compile the program type RANDOMIZE USR 60000 and press ENTER. After a very short time, you should see this information printed on the screen: 00:00:00:0 HISOFT COLT Integer Compiler 1.0 (c) 1985 THRELFALL and HODGSON Compiling Line 140 Compiled OK Begin End Vars Lines 40000 40384 51517 51999 Names Nmtop Ctop Nvars 52059 52191 52460 80 To run RANDOMIZE USR 40000 (some of the numbers and messages may be different, but don't worry) All these numbers will be useful to advanced programmers, but the rest of us can ignore them. All we need to know is that the "Compiled OK" message appeared. If a line cannot be compiled (either because it doesn't make sense or because it is one of the things which COLT cannot deal with) then the dubious line is reproduced on the screen with a flashing '?' mark next to the offending part of the line. This program, if typed in correctly, will not cause any errors. When the screen display above appears, run the compiled program by typing: RANDOMIZE USR 40000 (and press ENTER) you can see the difference immediately! Although our example turns out only to be about twice as fast as interpreted Basic, other programs can achieve as much as 70 times greater execution speed. When the compiled program finishes, you can type LIST and find that the original program is still there, ready to be altered and re-compiled at once. By allowing us to do this, the COLT compiler maintains the interactivity provided by the standard Basic interpreter. Now we can look at each feature of COLT and describe its operation in more detail. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - COLT in detail -------------- COLT is a fully microdrive and Interface 1 compatible integer Basic compiler for the ZX Spectrum and Spectrum+. It will compile nearly all ZX Basic code including strings, all the microdrive commands, tape commands, RS232 commands, networking commands and finally the commands associated with the EXECUTIVE. COLT is an "Integer" Basic, which means that it can deal only with whole numbers between -32768 and 32767. This has been done so that the maximum speed can be attained, making COLT ideal for writing high-quality arcade-style games. COLT has been written to not use floating point arithmetic as the increase in speed over the Spectrum's own interpreter would be negligible. COLT includes many special features to maintain compatibility with Spectrum Basic. There are no special commands which cannot be tested in the normal interactive environment. Here is a list of some of the features of COLT: Full string handling Up to 26 one-dimensional arrays and 26 one-dimensional string arrays. Fully microdrive / Interface 1 compatible All microdrive commands except DATA can be compiled Full variable names Access to Basic variables Basic access to COLT variables INPUT with full line editing Computed GOTOs VAL and VAL$ may be used Break key can be permanently enabled Compiles up to 32K of Basic, producing very fast code Very fast compilation (maximum 2 seconds per 1K of Basic) with precise error reporting - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Loading the compiler -------------------- You should load the compiler by typing the command LOAD "". This will load a Basic program which gives some information on the compiler. You will be offered the opportunity of making a working copy to tape or microdrive. This will enable you to treat the copy you have just received as a MASTER BACKUP. In addition, you will be given the chance to change the point at which the compiler places the compiled code. This is RAMTOP, and for the compiler alone may be between 26000 and 59000. If you use the Executive as well then the upper limit is 52000. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - COLT statements --------------- Variable names may be of any length but may contain only the characters 'A' to 'Z', 'a' to 'z' and '0' to '9' (but a digit cannot be the first character of a variable's name). As in Basic, upper and lower case are treated as being the same. There must not be any colour codes embedded in the name or the compiler will object. In the list below: 'e' represents an arbitrary expression 'N' represents a positive integer 'a$' represents any string variable or sliced string expression (as in "x$(1 TO 4)") 'a' represents any simple or loop variable 'a(e)' represents any one-dimensional array or array element Colour codes and other control codes must not appear in the middle of lines, except within quotes. When 'x', 'y' and 'z' are given as arguments to a function then floating point evaluation is possible. The expression 'n/m' may replace 'x', 'y' or 'z' and 'n/m' is calculated to give a floating point result. 'n' and 'm' may be integer variables or integer bracketed expressions, e.g. "BEEP 1/3,5" sounds the beeper for 1/3 of a second. "BEEP (1+2)/(3+4),5" sounds it for 3/7ths of a second. A division sign is the only operator which is allowed outside of brackets, and there may be one only per argument (x, y or z). String expressions should not contain brackets (e.g. a$=(b$+c$)) as they are unnecessary and tend to confuse the compiler. In PRINT statements string comparisons must be in parentheses (brackets); e.g. use "PRINT ("x"<"y")" rather than "PRINT "x"<"y"". Unless otherwise stated, the functions below work exactly as in Basic (remembering that all arithmetic is done in integer form). This table should be examined in conjunction with the Spectrum manual. AND Boolean 'AND'. Cannot be used to mix strings and numbers: e.g. "b$=a$ AND 2" will not compile. ABS e Ar e,e ATTR(e,e) BEEP x,y See comments about floating point above. BIN e BORDER e BRIGHT e CIRCLE x,y,z CHR$ e CLS Both this and the special Interface 1 form CLS# are handled. CAT All forms are supported. CLEAR Clear compiled code variables only. The Interface 1 form "CLEAR#" to reset the channels is supported. The form "CLEAR 12345" is NOT supported. CLOSE All forms are supported. CODE a$ CONTINUE This is not useful in a program and may be compiled. It must be the first sub-statement in a multiple statement line. COPY DATA list 'list' must be a list of integers or strings in quotes and may not contain expressions. It must be the first and only statement in a line. DEF FN User-defined functions are NOT supported! DIM a(v) Only one-dimensional arrays are available in COLT. DIM a$(v) The storage of both arrays and strings is discussed later. Run-time array bound checking is minimal to make the speed of execution as high as possible. All arrays, strings and variables are erased when you re-enter a COLT program. DRAW x,y DRAW x,y,z ERASE FLASH e FN User-defined functions are NOT supported! FORMAT All forms supported. FOR a=u TO v STEP w 'STEP' is optional. Note that the difference between 'u' and 'v' cannot exceed 32767 and the loop is always traversed at least once. GOSUB n 'n' is a positive integer. The fast form of GO SUB. GOSUB e The expression must begin with a non-numeric (i.e. not a digit) and this is then evaluated at run-time. This option is relatively slow and should be used only when absolutely necessary. GOTO n as GOSUB GOTO e as GOSUB IF e THEN IN e INK e INKEY$ INKEY$ #e for Interface 1 INPUT a Editing exactly as in Basic. Colour operations and all three forms of INPUT may INPUT a(v) be intermixed. The suffix #e is allowed to INPUT a$ enable reading from the RS232 or from microdrive files. INT e Helps testing within the interactive environment. INVERSE e LEN a$ a$ cannot be sliced. LET a=e LET a$=a$ LINE LOAD All forms including the microdrive derivatives may be used with the exception of "LOAD ... DATA". See "LOAD commands" below. LPRINT With or without the addition of #e. MERGE MOVE All forms are supported. NEW NEXT a See 'FOR'. Note that COLT expects that the 'NEXT' will follow the 'FOR' when the code is read from top to bottom. OPEN All forms supported. OR OUT e,e OVER e PAPER e PAUSE e PEEK e PLOT e,e POKE e,e POINT(e,e) PRINT With or without #e. RANDOMIZE RANDOMIZE e READ a Reads a list of integers from DATA statements. Only minimal checking is performed to ensure that types are correct. READ a$ As for 'READ a', except that the data read are strings. REM See special type below. Used for testing BREAK key. RESTORE e Restores the data pointer to line e. Line e must exist and be a DATA statement. RESTORE Initialises the DATA pointer to the start of the program. RETURN RND Returns a random integer between 0 and 32767 (this is not quite the same as Basic). To obtain the same effect under Basic use USR 59997. SAVE All forms, including microdrive versions (except "LOAD ... DATA") are allowed. SCREEN$(e,e) SGN e STOP STR$ e See comments on strings and the section called "Floating Point?" below. TAB e TO All forms a$(m TO n), a$( TO n) and a$(m TO ) are allowed. USR e USR "string" VAL a$ If a$ contains a reference to a variable then the Basic variable of that name is used. See "Fetching from Basic" below. VAL$ a$ see VAL VERIFY All forms except "VERIFY ... DATA" allowed. All Executive commands of this form are compiled. Note, however, that "*fx Goto e" always returns to Basic line 'e', not compiled line 'e'. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Strings and arrays ------------------ Strings and arrays are stored within the Basic variable space (i.e. in the space pointed to by the system variable 'VARS' (location 23627)) and are at the front of this space. The space needed for strings and arrays is allocated dynamically as the need arises at run-time, just as in Sinclair Basic. There is one minor difference: if a string or array gets smaller, the space allocated to it does not decrease. This results in code which is about 5 times faster than that which would result if strings were made exactly the correct size. In general, string handling is roughly 20 to 25 times faster than Basic. The fact that the space is not handed back is invisible to the user as an enquiry like "LEN a$" will give the expected result. One side effect is that you may run out of space slightly earlier than usual. However, this process results in faster code for string handling than any other Spectrum Basic compiler. Arrays work in an exactly analogous fashion and get longer, but not shorter, if they are re-allocated. The old array space is reused. The only space used between 'STKEND' and 'RAMTOP' (Basic system variables) at run-time is temporary space used in forming string expressions and is built up from 256 bytes above STKEND (the end of normal Basic space). Note that as this gap is only 256 bytes long, no string should change in length by more than 255 bytes (characters) in one go. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Error messages during compilation --------------------------------- Any error will result in the offending line becoming the current (editing) line. Simply press EDIT (CAPS-SHIFT and 1 simultaneously) to bring the line down to the bottom of the screen ready to be edited. Error reports: 1 Next without For A 'NEXT' statement uses a variable which has not been seen so far in a 'FOR' statement. 2 Variable not found The maximum number of variables (255) has been exceeded. There is no cure except to use fewer variables. 4 Out of memory The table length for the variable names is not long enough (change locations 59991 and 2 - see "Technical Information" below). 8 End of file No code to compile. C Nonsense in Basic This means that the compiler can't compile this particular statement. G No room for line The space allocated to code is too small; try decreasing RAMTOP with a "CLEAR n" with n less than 40000. M RAMTOP no good No room for tables. There must be enough room for the names, lines and variables above RAMTOP for compilation to begin, even when compiling 32K of code. N Statement not found Using GOTO or GOSUB to go to a line number greater than 32767. This can occur at run-time with computed GOTOs and GOSUBs. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Run-time errors --------------- 3 Subscript wrong Only very rudimentary array bound checking is performed to speed up the code. 6 Number too big Usually due to dividing by zero. B Integer out of range A number greater than 32767 or less than -32768 has been used. D and L BREAK into program The BREAK key has been pressed. E Out of data A READ has been attempted after all the DATA statements have been exhausted. H STOP in INPUT The keyword 'STOP' was entered in response to an INPUT statement. P FN without DEF An EXECUTIVE routine has been called but the Executive is not present. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Saving compiled code -------------------- If you wish to save your compiled code you must save both the compiled code and the compiler. It is easiest to save from RAMTOP (usually 40000) to 65535 (the physical top of RAM) as this will also save any user-defined graphics. "E!k" in the EXECUTIVE will do this automatically, otherwise the command is: LET rt=USR 59200: SAVE "name" CODE rt,65535-rt: LET rt=USR 59200 Do not BREAK into this SAVE or the compiler will be corrupted. To minimise the amount of code to be saved try to make "Vars" only just larger than "End" (see "Technical information"). This may be accomplished by the following action: CLEAR (PEEK 23730+256*PEEK 23731)+(Vars-End-5) where "Vars" and "End" are read from the screen at the end of a compilation. The code must then be recompiled and the new entry point noted. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Re-loading compiled code ------------------------ It is extremely important that before re-loading compiled code into a "clean" machine you should "CLEAR n", where 'n' is the address to which your code was compiled (normally 40000). Failure to do this will usually crash the machine. If the compiled code which you re-load contains Executive commands, then the Executive must be re-started with RANDOMIZE USR 55020. This is not necessary for sprite or window functions. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Trace facilities ---------------- A very helpful feature of COLT is that you can use it with or without the BREAK key enabled, and, in addition, in association with the Executive, a trace of each line being executed can be seen. This is achieved by three different 'REM' statements, each of the form "REM #n": REM #0 BREAK is disabled except at "Scroll?", INPUT and during tape and microdrive commands. This results in the fastest, smallest and most secure code. Programs can be broken in to with the Executive. REM #1 BREAK enabled. This produces longer code than REM #0, but BREAK works as usual. REM #2 When used in association with the Executive "*fx line" command, the current line number is displayed every 50th of a second. This clearly is a very powerful feature when debugging. It will cause the line number (but not the statement number) to be printed if there is an error. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Compiling up to to 32K ---------------------- Usually, it is possible only to compile about 16K or so of Basic in a 48K machine (a little less if you are using the Executive). This is because the machine must hold both your source code (i.e. the Basic program) and the resulting compiled code. The latter is much the same size as the former. When working to and from cassette tape this is clearly a good method, as you still have the Basic present to try again if your code does not work as intended. With the advent of the microdrives the position has changed. Provided that you have saved your Basic code, you are unlikely to mind if the compiler removes it from memory during the compilation process. This fact is used in COLT to allow you to compile 30 to 34K of Basic, as follows: 1) SAVE your Basic code 2) With a "CLEAR n" set RAMTOP so that there is room for the area from 'Vars' to 'Ctop' (see "Technical information"). For a 32K program this will need to be about 5K, so use CLEAR 55000. 3) POKE the COLT variable at 59987 (a two-byte integer) with the final RAMTOP address at which you wish the code to be compiled. For example, to make it 32767 (= 127 * 256 + 255), you should: POKE 59987,255: POKE 59988,127 4) Compile. If the compilation is successful then the Basic area will be empty. If any compilation error occurs, the Basic should still be there. Error messages are produced as usual. 5) During compilation, the machine stack has been moved from your original choice to location 65535 (so over-writing the last few UDGs) and then to your new chosen value. 6) Before re-loading any files you should re-execute step 2 above or there will not be room for the Basic. 7) Note that if you have the Executive present then about 25K only of Basic can be compiled, and the first CLEAR (step 2) should be to about 48000. To turn off the Executive to make more space, type: RANDOMIZE USR 59190 and press ENTER. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Returning to Basic ------------------ A section of compiled code will return automatically to Basic when it finishes. STOP will cause a normal error 9 report. If the compiled code was called by an immediate mode command (typed at the bottom), then no statements after the "RANDOMIZE USR n" will be executed. If the code is called by a line in another program then it will return to the next statement. This is carried out by the compiled code executing a CONTINUE, so if you wish to return to some other point in Basic, you should POKE 'OLDPPC' (location 23662) with the line number and 'OSPPC' (location 23664) with the statement number. This will over-ride the values put there by the compiler and must be in the compiled code. This method may also be used to chain programs. If the compiled code contains a line "LOAD "fred"", and the compiled code is invoked from line 10, first statement, then the compiler will return to the second statement in line 10 (if it exists) or the next line in "fred". Hence, you may chain Basic and compiled code. Note however that the LOAD command will destroy the compiled code's arrays and strings. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Fetching variables from Basic ----------------------------- There will be many occasions when you wish to pick up the value of a Basic variable for use in a COLT program. For this reason, if the argument to the VAL function contains a reference to a variable, it uses the Basic variable rather than the COLT variable. This allows you to write statements like LET fred=VAL "fred" which would take the Basic variable 'fred' and transfer its value into the COLT variable 'fred'. The same applies to members of an array: LET b(10)=VAL "b(10)" The 'VAL$' function may be used to get Basic strings into COLT, like this: LET a$=VAL$ "a$" which gets the Basic string variable 'a$' into the COLT string variable 'a$'. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Taking COLT variables back to Basic ----------------------------------- This is not quite as easy as the converse, so a special function has been provided to help: LET fred=USR 59227: PRINT "john" will set Basic variable 'fred' to be equal to COLT variable 'john'. This can be extended to arrays and strings: LET point=USR 59227: PRINT "b(n)" will set 'point' to be an integer pointer to the FIRST member of the COLT array 'b'. 'n' may take any value but the pointer is always to the first member. To access the first element of the array 'b', a Basic line like LET b(1)=PEEK point + 256*PEEK(point+1) would suffice. To get at the 'nth' member, use: LET b(n)=PEEK (point+2*(n-1)) + 256*PEEK (point+2*(n-1)+1) the factor of two allows for the fact that there are 2 bytes per array member. To access a string we would type: LET point=USR 59227: PRINT "a$" where 'point' points to the first member of the COLT string 'a$', (i.e. a$(1)), 'point+1' points to the second member (a$(2)), and so on. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Floating point? --------------- We said at the beginning that COLT used only integer arithmetic, as floating point mathematics is prohibitively expensive in computer time. Exceptions to this rule have been seen already in the DRAW and BEEP commands. The VAL and STR$ functions give access to full floating point arithmetic. Try: PRINT STR$ VAL "SQR 3" You will see that a floating point number is printed out. The VAL function can be used to make available all the floating point functions, such as SIN, COS and TAN. Using the function VAL by itself always returns the result of the floating point operation as an integer. For example: LET a=VAL "100*SQR 20" will set 'a' to be 447. However, "STR$ VAL" has been set to return the floating point result into the string: LET a$=STR$ VAL "100/3" will set a$ to be the string "33.333333". This string can then be manipulated further by repeated use of these functions: LET b$=a$+"*2" LET c$=STR$ VAL b$ Sets c$ to be two times the value of the number held in a$: "66.666666". This process can be continued indefinitely. Note also that any variables used in quotes, like "a*b", refer to the Basic variables 'a' and 'b', not the COLT ones. This form of arithmetic is useful but will run at much the same speed as Basic. Here are a few examples: 10 LET a=VAL "SIN(.523598775)*100+100*.01" 20 PRINT a gives 51 both in Basic and compiled code. Note that the expression did not contain any variables. This may be accomplished like this: 10 LET b=100 20 LET a=VAL ("SIN(.523598775)*100+0.01*"+STR$ b) 30 PRINT b which uses the compiled variable 'b'. However, if line 20 was replaced by: 20 LET a=VAL("SIN(.523598775)*100+0.01*b") the Basic variable 'b' would be used. All the above return integer values, but by using strings we may obtain floating point ones: 10 LET a$="100/LN 12+ EXP 2" 20 LET b$="SIN 1+COS 2+TAN 3+0.01" 30 LET c$=VAL(a$+"2.34973+"+b$) 40 PRINT c$ which gives 300 both in Basic and compiled code. It must be admitted that it is rather cumbersome, but it works! - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - LOAD commands ------------- If you wish to compile these a word of warning is necessary: "LOAD CODE" will work correctly, but loading Basic is dangerous. It will work successfully, but in doing so will wipe out all the COLT arrays and strings from the 'VARS' area of Basic. If you are not using any, then this won't matter, but otherwise strange results will ensue.

RTXOne je jednoduchý a extrémne rýchly operačný systém pre mikroprocesory rady 8051 ktorý je možné použiť pre multitaskovom režime. Uvedená cena zahŕňa elektronickú formu spustiteľnej formy pre 32 bitové systémy. Po zaplatení úhrady za vyššie uvedený digitálny produkt formou bankového prevodu, alebo PayPal-u Vám bude doručený na email ktorý ste uviedli pri registrácii link na stiahnutie počas 60 dní.