1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
---
language: curto
contributors:
- ["Maleza", "https://maleza.srht.site/"]
lang: es-es
filename: learncurto-es.fs
---
Curto es una traducción completa al español de [UF Forth](http://www.call-with-current-continuation.org/uf/uf.html) (de Felix Winkelmann), un Forth para la [Máquina Virtual UXN](https://wiki.xxiivv.com/site/uxn.html).
```
\ Este es un comentario
( Este es un comentario también pero solo es usado en definiciones de palabras. )
\ --------------------------------- La Pila ----------------------------------
\ Todo programación en Curto se hace manipulando la pila de parámetros
\ (habitualmente referida como "la pila").
5 2 3 56 76 23 65 \ ok
\ estos números se añadieron a la pila de izquierda a derecha.
.s \ <7> 5 2 3 56 76 23 65 ok
\ En Forth, todo es o una palabra o un número.
\ ------------------------------ Aritmética Básica ------------------------------
\ La aritmética (de hecho casi todas palabras que requieren datos) funciona manipulando datos
\ en el pila.
5 4 + \ ok
\ `.` saca el resultado del tope de la pila:
. \ 9 ok
\ Mas ejemplos de aritmética:
6 7 * . \ 42 ok
1360 23 - . \ 1337 ok
12 12 / . \ 1 ok
13 2 mod . \ 1 ok
99 negate . \ -99 ok
-99 abs . \ 99 ok
52 23 max . \ 52 ok
52 23 min . \ 23 ok
\ ----------------------------- Manipulación de Pila -----------------------------
\ Naturalmente, cuando trabajaremos con la pila, querremos algunos métodos útiles:
3 dup - \ duplica el primer valor (1ra ahora igual a 2da): 3 - 3
2 5 cambiar / \ intercambia primer y segundo valor: 5 / 2
6 4 5 rot .p \ rota los tres primeros valores: 4 5 6
4 0 soltar 2 / \ suelta el primer valor (no imprime a pantalla): 4 / 2
1 2 3 pellizcar .p \ suelta el segundo valor (similar a soltar): 1 3
\ ---------------------- Manipulación de Pila Más Avanzada ----------------------
1 2 3 4 plegar \ duplicar el primer valor debajo del segundo: 1 2 4 3 4 ok
1 2 3 4 encima \ empuja segundo valor de la pila: 1 2 3 4 3 ok
1 2 3 4 2 elegir \ duplica el valor en esta posición al tope de la pila: 1 2 3 4 2 ok
\ Los índices de la pila son basados en cero.
\ ------------------------------ Creando Palabras --------------------------------
\ La palabra `:` hace que Curto entre en modo compilar hasta que se ve la palabra `;`.
: cuadrado ( n -- n ) dup * ; \ ok
5 cuadrado . \ 25 ok
\ También podemos ver lo que hace una palabra (código uxntal al que fué compilada):
ver cuadrado \ DUP2 MUL2 JMP2r ok
\ -------------------------------- Condicionales --------------------------------
\ -1 == verdadero, 0 == falso. No obstante, cualquier valor distinto de cero es
\ considerado verdadero:
42 42 = \ -1 ok
12 53 = \ 0 ok
\ `si` es una palabra solo de compilación. `si` <cosas para hacer> `entonces` <resto del programa>.
: ?>64 ( n -- n ) dup 64 > si ." Mas que 64!" entonces ; \ ok
100 ?>64 \ Mas que 64! ok
\ `sino`:
: ?>64 ( n -- n ) dup 64 > si ." Mas que 64!" sino ." Menos que 64!" entonces ;
100 ?>64 \ Mas que 64! ok
20 ?>64 \ Menos que 64! ok
\ ------------------------------------ Bucles -----------------------------------
\ `hacer` también es una palabra solo de compilación.
: miloop ( -- ) 5 0 hacer rc ." Hola!" bucle ; \ ok
miloop
\ Hola!
\ Hola!
\ Hola!
\ Hola!
\ Hola! ok
\ `hacer` espera dos números en el pila: el de incicio y el de terminación.
\ Podemos recibir el valor del indice mientras iteramos con `i`:
: uno-a-12 ( -- ) 13 1 hacer i . bucle ; \ ok
uno-a-12 \ 0 1 2 3 4 5 6 7 8 9 10 11 12 ok
\ `?hacer` funciona similarmente, pero salta el loop si el último y el primer
\ número son iguales.
: cuadrados ( n -- ) 0 ?hacer i cuadrado . bucle ; \ ok
10 cuadrados \ 0 1 4 9 16 25 36 49 64 81 ok
\ cambiar el "paso" con `+bucle`:
: treces ( n n -- ) ?hacer i . 3 +bucle ; \ ok
15 0 treces \ 0 3 6 9 12 ok
\ Los bucles indefinidos comienzan con `empezar` <cosas para hacer> <bandera> `hasta`:
: death ( -- ) empezar ." Ya hemos llegado?" 0 hasta ; \ ok
\ ---------------------------- Constantes, Variables y Memoria ----------------------------
\ Declara una constante `dedos` igual a 5
5 constante dedos
dedos . \ 5 ok
\ Crea la variable `edad`.
variable edad \ ok
\ Ahora escribimos 21 a edad con la palabra `!`.
21 edad ! \ ok
\ Podemos imprimir nuestra variable usando la palabra leer `@`, que empuja el
\ valor a la pila, o `?` que lee e imprime en un solo paso.
edad @ . \ 21 ok
edad ? \ 21 ok
\ ----------------------------------- Arreglos -----------------------------------
\ Crear arreglos es similar a crear variables, pero necesitamos alocar mas
\ memoria para ellos.
\ Podemos usar `2 celdas alocar` para crear un arreglo que sea de 3 celdas de tamaño:
variable misnumeros 2 celdas alocar \ ok
\ Inicializar todos los valores a 0
misnumeros 3 celdas borrar \ ok
\ Alternativamente podemos usar `llenar`:
misnumeros 3 celdas 0 llenar
\ o podemos saltearnos todo lo anterior e inicializar con valores específicos:
crear misnumeros 64 , 9001 , 1337 , \ ok (la última `,` es importante!)
\ ...que es equivalente a:
\ Manualmente escribir valores a cada indice:
64 misnumeros 0 celdas + ! \ ok
9001 misnumeros 1 celdas + ! \ ok
1337 misnumeros 2 celdas + ! \ ok
\ Leyendo valores de un índice en particular:
0 celdas misnumeros + ? \ 64 ok
1 celdas misnumeros + ? \ 9001 ok
\ Podemos simplificar un poco creando una palabra que ayuda a manipular arreglos:
: de-arr ( n n -- n ) celdas + ; \ ok
misnumeros 2 de-arr ? \ 1337 ok
\ Que podemos usar cuando escribimos también:
20 misnumeros 1 de-arr ! \ ok
misnumeros 1 de-arr ? \ 20 ok
\ ------------------------------ La Pila de Retorno ------------------------------
\ La pila de retorno se usa para retener punteros a cosas cuando las palabras están
\ ejecutando otras palabras como en los bucles.
\ Ya hemos visto un uso de esto: `i`, que duplica el tope de la pila
\ de retorno. `i` es equivalente a `r@`.
: mibucle ( -- ) 5 0 hacer r@ . bucle ; \ ok
\ También podemos agregar y retirar de la pila de retorno:
5 6 4 >r swap r> .p \ 6 5 4 ok
\ NOTA: Como Curto usa la pila de retorno para retornar a palabras, `>r` debe
\ siempre ser seguido por un `r>`.
\ --------------------------------- Notas al Final --------------------------------
\ Usar una palabra que no existe vaciara la pila. No obstante, también hay una palabra
\ específicamente para esto:
limpiar
\ vaciar la pantalla:
pagina
\ Cargando archivos Curto:
\ c" archivodeforth.fs" incluido
\ Puede listar cada palabra en el diccionario de Curto (pero es una lista gigante!):
palabras
\ Terminando Curto:
chau
```
##Listo Para Mas?
* [README](https://git.sr.ht/~maleza/curto/tree/curto/item/README)
* [GLOSARIO](https://git.sr.ht/~maleza/curto/tree/curto/item/GLOSARIO)
|
