Atari BASIC: differenze tra le versioni

Versione delle 21:20, 5 ago 2012

Versione delle 21:45, 5 ago 2012

Riga 30:

===L'Atari BASIC===

Il risultato fu un interprete del tutto differente, che fu denominato '''Atari BASIC'''. Il nuovo BASIC differiva in particolar modo nella gestione delle [[Stringa (informatica)|stringhe di caratteri]]: mentre il Microsoft BASIC le considerava come costanti, non più modificabili, l'Atari BASIC ne consentiva la modifica, permettendo di incrementare o decrementare le loro dimensioni, l'Atari BASIC le considerava come costanti, non più modificabili.

Il contratto stipulato con Atari specificava la consegna entro il [[6 aprile]] [[1979]] dell'interprete funzionante (ed anche di un gestore di file, che in seguito sarebbe stato noto come DOS 1.0). Per coprirsi le spalle Atari decise però di continuare a lavorare sulla riduzione del Microsoft BASIC in modo da averne una prima versione in tempo utile per il CES del 1979, mostrarlo alla fiera e poi passare all'Atari BASIC non appena questo fosse stato completato. Ma i bonus sui tempi di consegna fecero terminare a Shepardson il lavoro prima del tempo per cui Atari decise di portare al CES l'Atari BASIC, visto che era stato completato prima della conversione del Microsoft BASIC.

Riga 42:

Un programmatore poteva sapere la versione dell'interprete in uso esaminando una precisa locazione di memoria. Il comando <code>PRINT PEEK(43234)</code> inserito al READY della macchina resistuiva <code>162</code> per la Revision A, <code>96</code> per la Revision B e <code>234</code> per la Revision C.

==DescrizioneCaratteristiche del linguaggio==

===Editor del programma===

L'Atari BASIC usava un [[editor (informatica)|editor]] a righe, come molti BASIC del tempo. A differenza di altri, però, esso analizzava immediatamente la riga immessa alla ricerca di errori di sintassi. Se veniveva inserito un comando sbagliato, l'editor riproponeva la riga che lo conteneva mostrando il punto in cui aveva individuato l'errore.

Riga 75:

Le istruzioni di salto <code>GOTO</code> e <code>GOSUB</code> permettevano l'uso di variabili al posto del numero di riga esplicitato.

<!--

===String handling===

Atari BASIC differs dramatically from Microsoft-style BASICs in the way it handles strings. In BASICs following the Microsoft model, strings are special types that allow for variable length and various operations. Atari BASIC has no strings of this sort, instead using [[Array data structure|arrays]] of characters, rather like [[Fortran]]. This allowed the BASIC language programmers to remove all the special-purpose code needed for handling dynamic resizing of strings, reusing instead the code already being used to handle arrays of numbers. A string is allocated a maximum size using the <code>DIM</code> statement, although its actual length can vary at runtime from 0 to this maximum size.

===Gestione delle stringhe===

Of course, strings are ''not'' used by end programmers in the same way as arrays of numbers &ndash; at least not normally &ndash; so Atari BASIC also includes a selection of commands for "slicing" up arrays. <code>A$</code> refers to the entire string, whereas <code>A$(4,6)</code> "slices" out the three characters 4, 5 and 6. In theory, this is a more elegant solution than Microsoft BASIC's <code>LEFT$</code>, <code>MID$</code>, and <code>RIGHT$</code> solution, as this syntax replaces three separate commands with a single one.

L'Atari BASIC gestiva le stringhe in maniera completamente diversa rispetto ai BASIC stile Microsoft. In questi ultimi le stringhe potevano essere di lunghezza variabile e permettevano diverse operazioni mentre l'Altair BASIC usava l'approccio del [[Fortran]], ossia le stringhe erano [[array]] di caratteri la cui massima dimensione era indicata con il comando <code>DIM</code>, anche se poi la sua dimensione poteva variare durante l'esecuzione del programma tra questo valore e 0. Data una stringa, per accedere al suo intero contenuto bastava usare il nome stesso della stringa, ad esempio <code>A$</code>; se invece si voleva accedere solo ad una sua parte bastava indicare tra parentesi i caratteri di inizio e fine, ad esempio <code>A$(4,6)</code> prelevava i caratteri 4, 5 e 6.

Although this simplification reduces the size of Atari BASIC and offers some theoretical performance benefits, it is also a hindrance to porting BASIC programs from other computers to the Atari. When the Atari was first produced it was the norm for programs to be provided as listings in magazines for programmers to type in. They would have to scan them for instances of <code>LEFT$</code>, <code>RIGHT$</code> and so on, do some mental arithmetic and replace them with slicing commands. Because strings were allocated a fixed size it generally means that programmers will [[pessimization|pessimize]] or [[guesstimate]] the likely maximum size, allocating, perhaps 256 bytes for a string that only ever stores someone's first name.

Strings in Atari BASIC cannot themselves be members of arrays, so arrays of strings have to be implemented by the programmer. Strings can move around in memory, so it is not generally possible for example to store their memory addresses in an array. For short strings of approximately the same length, instead an array is generally built using [[Padding (cryptography)#Byte padding|padding]] so that the strings are all the same length and the ''n''th string in the array is ''n''&times;''l'' characters into it, where ''l'' is the length of the string.

Long strings initialization usually required <code>for</code> loops. Nevertheless, the language enabled fast string initialization with the following trick:

REM The following initialize A$ with 1000 characters of ''x''

DIM A$(1000)

A$="x":A$(1000)=A$:A$(2)=A$

Nonostante questo modo di gestione delle stringhe fosse molto elegante, comportava però dei problemi quando si dovevano portare sull'Atari BASIC programmi scritti per altri interpreti dato che non solo si dovevano considerare le istruzioni <code>LEFT$</code>, <code>RIGHT$</code> e simili usate dai BASIC in stile Microsoft ma anche il fatto che la dimensione di una stringa in Atari BASIC era stabilita a priori.

<!--

===Input/Output===

====CIO overview====