Libro SL

Introduccin al
lenguaje SL
Referencia de subrutinas predefinidas
Ejemplos selectos
Juan Segovia Silvero
Centro Nacional de Computacin
Universidad Nacional de Asuncin
Introduccin al lenguaje SL
por Juan Segovia Silvero
Copyright 1999 Centro Nacional de Computacin, CNC
Univeridad Nacional de !uncin, UN!"
!uncin, #araguay
$eviin% &lanca de 'revian
'apa% Jorge (e)a &"
$eervado todo lo derecho
Contenido
INTRODUCCIN.........................................................................................1
#$INCI#!L*S C!$!C'*$+S'IC!S ,* SL""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""-
UN S*NCILL. #$./$!(! *N SL""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""0
.$/!NI1!CI2N ,*L LI&$.""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""3
EL ENTORNO DE DESARROLLO DE SL...............................................5
4ISI2N /*N*$!L ,*L *N'.$N. ,* ,*S!$$.LL.""""""""""""""""""""""""""""""""""""""""""""""""""""""5
US. ,*L *N'.$N."""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""5
Las opciones del men de SLE..................................................................7
Uso de las teclas rpidas...........................................................................9
Principales teclas rpidas.......................................................................10
eclas espec!ficas del editor....................................................................11
$*6U*$I(I*N'.S ,* 7!$,8!$* 9 S.:'8!$*""""""""""""""""""""""""""""""""""""""""""""""""""""""11
ASECTOS !"SICOS DE SL...................................................................1#
L.S C.(*N'!$I.S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""10
I,*N'I:IC!,.$*S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""1;
#!L!&$!S $*S*$4!,!S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""15
,*LI(I'!,.$*S ,* S*N'*NCI!S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""15
*S'$UC'U$! /*N*$!L ,* UN #$./$!(! SL"""""""""""""""""""""""""""""""""""""""""""""""""""""""1<
TIOS DE DATOS !"SICOS $ CONSTANTES LITERALES............1%
L!S C.NS'!N'*S LI'*$!L*S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""-=
Los nmeros............................................................................................."0
Las cadenas de caracteres......................................................................."1
La ecuencia de ecape"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""-1
UN *J*(#L.""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""--
USO DE &ARIA!LES $ CONSTANTES................................................'5
,*CL!$!CI2N ,* 4!$I!&L*S SI(#L*S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""-;
Los #alores por defecto............................................................................"$
,*CL!$!CI2N ,* C.NS'!N'*S (!NI:I*S'!S""""""""""""""""""""""""""""""""""""""""""""""""""""""""-5
%l&unas obser#aciones sobre las constantes manifiestas........................"7
'onstantes manifiestas predefinidas......................................................."(
,*CL!$!CI2N ,* 4*C'.$*S 9 (!'$IC*S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""-<
Un ejemplo sencillo de uso de #ectores..................................................."(
)eclaraci*n + uso de matrices................................................................,0
,*CL!$!CI2N ,* $*/IS'$.S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""01
-tras consideraciones sobre el uso de re&istros ....................................,,
OERADORES $ E(RESIONES..........................................................#5
.#*$!,.$*S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""0;
-peradores aritm.ticos...........................................................................,$
-peradores l*&icos..................................................................................,7
-peradores relacionales..........................................................................,(
.peradore relacionale y cadena"""""""""""""""""""""""""""""""""""""""""""""""" """"""""""""""""""""""""""""""" """"""""""""""""0<
'oncatenaci*n de cadenas......................................................................,9
#$*C*,*NCI! ,* L.S .#*$!,.$*S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""3=
L!S *>#$*SI.N*S C.(#L*J!S 9 *L US. ,* #!$?N'*SIS""""""""""""""""""""""""""""""""""""""""""31
SENTENCIAS.............................................................................................)#
S*N'*NCI! ,* !SI/N!CI2N""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""30
S*N'*NCI! C.N,ICI.N!L @SIA""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""33
Primer ejemplo........................................................................................//
Se&undo ejemplo....................................................................................../0
CICL. (I*N'$!S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""35
Primer ejemplo......................................................................................../7
Se&undo ejemplo....................................................................................../(
CICL. $*#*'I$"""7!S'!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""39
S*N'*NCI! *4!L"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""";=
Ejemplo....................................................................................................00
CICL. ,*S,*""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""";1
Ejemplo....................................................................................................0"
1as detalles acerca del ciclo desde........................................................0"
S*N'*NCI! ,* LL!(!,! ! SU&$U'IN!S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""";0
Ejemplo....................................................................................................0/
S*N'*NCI! $*'.$N!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""";;
CARACTER*STICAS A&AN+ADAS DE LOS ARRE,LOS $
RE,ISTROS...............................................................................................5-
C$*!CI2N ,INB(IC! ,* !$$*/L.S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""";C
'ombinaciones interesantes de arre&los abiertos + de tama2o fijo........0(
INICI!LI1!CI2N ,* !$$*/L.S C.N LI'*$!L*S *S'$UC'U$!,.S"""""""""""""""""""""""""""""""";9
a. %rre&los de tama2o fijo.......................................................................09
b. %rre&los abiertos.................................................................................$0
!$$*/L.S C.N C.N'.$N.S N. $*/UL!$*S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""51
!SI/N!CI2N *N'$* !$$*/L.S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""5-
INICI!LI1!CI2N ,* $*/IS'$.S C.N LI'*$!L*S *S'$UC'U$!,.S"""""""""""""""""""""""""""""""50
!SI/N!CI2N *N'$* $*/IS'$.S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""50
!$$*/L.S ,* $*/IS'$.S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""53
C!N'I,!, ,* *L*(*N'.S ,* UN !$$*/L. !&I*$'.%
US. ,* L! :UNCI2N !L*N@A""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""5;
OERACIONES CON CADENAS.............................................................-
L.N/I'U, ,* UN! C!,*N!% L! :UNCI2N S'$L*N@A""""""""""""""""""""""""""""""""""""""""""""""""5C
!CC*S. ! L.S C!$!C'*$*S ,* UN! C!,*N!""""""""""""""""""""""""""""""""""""""""""""""""""""""""5<
(.,I:IC!CI2N ,* C!$!C'*$*S ,* UN! C!,*N!"""""""""""""""""""""""""""""""""""""""""""""""""""5<
SU&C!,*N!S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""59
C.N4*$SI2N ! NU(?$IC.% L! :UNCI2N 4!L@A""""""""""""""""""""""""""""""""""""""""""""""""""""""C=
SU!RUTINAS.............................................................................................-1
B(&I'. ,* L.S I,*N'I:IC!,.$*S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""C-
'I#.S ,* SU&$U'IN!S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""C0
:UNCI.N*S% SU&$U'IN!S 6U* $*'.$N!N 4!L.$""""""""""""""""""""""""""""""""""""""""""""""""""C3
#$.C*,I(I*N'.S% SU&$U'IN!S 6U* N. $*'.$N!N 4!L.$""""""""""""""""""""""""""""""""""""""C;
,*:INICI2N ,* #!$B(*'$.S :.$(!L*S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""C;
#!S. ,* #!$B(*'$.S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""C5
Por #alor..................................................................................................7$
Por referencia..........................................................................................77
Ejemplo....................................................................................................7(
SU&$U'IN!S 9 !$$*/L.S !&I*$'.S """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""C<
Primer ejemplo........................................................................................79
Se&undo ejemplo......................................................................................79
DE/INICIN DE NO0!RES DE TIOS DE DATOS...........................1#
,*:INICI2N ,* !LI!S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""<3
*J*(#L.S"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""<3
Primer ejemplo........................................................................................(/
Se&undo ejemplo......................................................................................($
ANE(O A. E2E0LOS SELECTOS.......................................................1%
S*$I* ,* :I&.N!CCI"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""<9
C.N4*$SI2N ,* ,*CI(!L ! &IN!$I. @US!N,. $*S'!S SUC*SI4!SA """""""""""""""""""""""""<9
C.N4*$SI2N ! 7*>!,*CI(!L""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""9=
'!&L! !SCII""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""91
ND(*$.S #$I(.S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""9-
(.4I(I*N'.S ,*L !L:IL *N UN '!&L*$. ,* !J*,$*1"""""""""""""""""""""""""""""""""""""""""""90
(!'$I1 C.N 4!L.$*S *N C!$!C.L""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""9;
C.$'* ,* C.N'$.L""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""95
C(L% IN'?$#$*'* #!$! UN L*N/U!J* S*NCILL."""""""""""""""""""""""""""""""""""""""""""""""1==
Ejemplo de uso de '1L.........................................................................100
'aracter!sticas de '1L.........................................................................101
,eclaracin de variaEle""""""""""""""""""""""""""""""""""""""""" """"""""""""""""""""""""""" """"""""""""""""""""""""""" """"""""""""""1=1
Cuerpo del programa"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""1=1
Sentencia"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""1=1
*Fpreione""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""1=-
Pro&rama fuente del int.rprete..............................................................10"
ANE(O !. SU!RUTINAS $ /UNCIONES REDE/INIDAS.............1'1
SU&$U'IN!S #$*,*:INI,!S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""1-<
:UNCI.N*S #$*,*:INI,!S""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""10=
Introduccin
SL es un lenguaje diseado para apoyar la formacin profesional de
estudiantes de informtica, proveyendo un entorno que acompae el proceso
de construccin de algoritmos, desde los ms sencillos hasta aquellos que
requieren tcnicas avanzadas de programacin. La sintais del lenguaje, sus
construcciones y dems caracter!sticas fueron cuidadosamente seleccionadas
para que el alumno se concentre en la "#squeda de soluciones y o"vie
detalles espec!ficos que seguramente tendr ocasin de ver en otras etapas de
su aprendizaje.
$l entorno de programacin incluye un editor multiventanas con
posi"ilidades de compilacin, ejecucin y depuracin de los programas,
apuntando a facilitar la eperimentacin y el pensamiento creativo del
alumno.
$l lenguaje presenta caracter!sticas que lo hacen apropiado para epresar
algoritmos de las etapas iniciales del aprendizaje, pero simultneamente re#ne
un rico conjunto de construcciones que posi"ilitan el tratamiento de tpicos
ms avanzados de estructuras de datos y programacin modular.
1
Ca pG t ul o
1
I n t r o d u c c i n a l l e n g u a j e S L
Principales caractersticas de SL
SL es un lenguaje muy sencillo de aprender y utilizar%
&osee un conjunto simplificado de tipos de datos, pero posi"ilitando la
definicin de tipos agregados. $n este aspecto SL considera los n#meros
enteros y reales, positivos y negativos, "ajo un mismo tipo de dato%
numerico. $isten adems varia"les lgicas y cadenas.
Las cadenas son dinmicas, es decir, su longitud se ajusta
automticamente para contener la secuencia de caracteres que se requiera,
sin o"ligar a la definicin epl!cita de una longitud mima. 'dems estn
predefinidos los operadores relacionales, el operador de concatenacin, la
posi"ilidad de leerlos e imprimirlos y el acceso a cada carcter en forma
individual y directa.
'dems de los tipos de datos "sicos (numerico, cadena, logico) pueden
definirse registros y arreglos n*dimensionales de cualquier tipo de dato.
Los arreglos pueden tener tamao inicial definido, o ser dinmicamente
dimensionados.
Las varia"les, tipos de datos y constantes pueden ser locales o glo"ales.
$l chequeo de compati"ilidad de tipos de datos es estricto, aunque la
compati"ilidad es estructural y no simplemente por nom"res.
Los su"programas comprenden su"rutinas y funciones, los que pueden
reci"ir parmetros por valor o por referencia. Las funciones pueden
retornar valores de cualquier tipo de datos, incluyendo arreglos y registros.
+ada su"programa puede tener su propio conjunto de s!m"olos locales.
Los identificadores (nom"re de varia"les, de constantes, de su"rutinas,
etc.) pueden tener hasta ,- caracteres de longitud, pudiendo la letra ser
parte de un identificador.
Los identificadores de"en ser definidos antes de su uso, a ecepcin de los
su"programas, evitndose as! la necesidad de definir prototipos.
Se cuenta con un rico conjunto de estructuras de iteracin y seleccin.
2
$n general, la sintais del lenguaje presenta similitudes a las de &ascal y +,
favoreciendo la programacin estructurada.
$l lenguaje es de formato li"re como &ascal o +, pero a diferencia de
stos, no requiere ./0 (punto y coma) como separador de sentencias.
$l despliegue y la lectura de datos es muy sencillo.
SL aspira ser un medio de expresin de algoritmos, no un fin en s mismo.
Un sencillo programa en SL
' continuacin se presenta un sencillo programa SL que calcula la suma de
los n#meros pares comprendidos entre 1 y n. $l programa pide al usuario
que tipee un valor para n.
/*
Calcular e imprimir la suma de los nmeros pares comprendidos entre 1 y
un n dado.
Las variables utilizadas son:
n : para almacenar el valor proveido por el usuario como tope.
suma : donde almacenamos el total calculado.
k : contador auxiliar para el ciclo.
AU!" : #uan $e%ovia &'se%ovia(cnc.una.py)
*/
var
n* suma* k : numerico
inicio
imprimir &+,n$uma de numeros pares entre 1 y n.,n-or .avor /*
+in%rese un valor para n: +)
leer &n)
suma 0 1
desde k02 hasta n paso 2
3
suma 0 suma 4 k
5
imprimir &+,nLa suma es +* suma)
fin

Los ejemplos de este manual requieren que la versin del compilador sera 0.6.2 o
posterior. El entorno de desarrollo, que se presenta en el siguiente captulo, tiene
una opcin para verificar la versin del compilador.
3
Organizacin del libro
$n este li"ro se descri"e el lenguaje SL% su estructura general, sus tipos datos
"sicos y agregados, las sentencias, las epresiones, las su"rutinas, etc. Se da
la sintais y las principales caracter!sticas desde el punto de vista de
funcionamiento.
&uede ser utilizado como gu!a para el alumno que est aprendiendo SL. Se
hace adems una "reve introduccin al entorno de desarrollo.
' los efectos de dar una visin glo"al del lenguaje, en el 'neo ' se incluyen
programas ejemplo escritos en SL.
$n el 'neo 2 se descri"en tam"in en detalle las rutinas utilizadas para la
entrada3salida, funciones de conversin de tipos de datos, etc.
4
El entorno de desarrollo de SL
$l entorno de desarrollo est diseado para "rindar al que se inicia en el
estudio de algoritmos un am"iente integrado con el cual pueda desarrollar
sus programas. $l entorno posi"ilita%
&reparar o modificar los programas fuentes, contando con funciones para
cortar y pegar tetos, realizar "#squedas y sustituciones, etc.
4antener simultneamente varios programas fuentes tal que sea posi"le
realizar comparaciones, copiados de tetos, etc. +ada programa fuente se
sit#a en una ventana independiente.
+ompilar los programas editados, reci"iendo indicacin acerca de la
u"icacin y naturaleza de los errores sintcticos o semnticos, si los
hu"iere.
$jecutar programas.
5epurar programas, pudiendo esta"lecer puntos de ruptura, ejecucin
paso a paso, por niveles, visualizar valores de varia"les y epresiones a
medida que avanza la ejecucin del programa, etc.
$sta"lecer de una forma muy sencilla los archivos para entrada y salida de
datos.
6uardar y resta"lecer el entorno de tra"ajo (ventanas a"iertas, posicin
del cursor dentro de cada ventana, colores, parmetros de ejecucin, etc.)
5
Ca pG t ul o
-
Visin general del entorno de desarrollo
&ara utilizar el entorno de desarrollo, de"e u"icarse en el directorio donde se
encuentre instalado el compilador, si dicho directorio no est en el camino
(&'78). 7ipee sle y pulse la tecla $97$:. Si su sistema operativo es
;indo<s=> o ;indo<s=? puede crear un acceso directo en el escritorio o en
el men# inicio. 5e"er ver una pantalla similar a la que se muestra en la
figura 1.
igura 1! "l am#iente de programacin de SL $SL"%
Uso del entorno
Se utiliza para realizar acciones tales como compilar, ejecutar o esta"lecer
una opcin del entorno. ' este men# se accede pulsando 'L7*@1A. La "arra
del men# principal luce como sigue%
igura 2! "l men& principal de SL"
'
(en&
principal
)entana
de edicin
)isor de
e*presiones
Bn determinado !tem de esta "arra puede ser seleccionado pulsando la tecla
'L7 en conjuncin con la correspondiente letra resaltada. &or ejemplo, al
!tem C$ditarD se puede acceder pulsando 'L7*$.
$l primer !tem, sealado con , contiene una calculadora sencilla y una ta"la
'S+EE, am"os de utilidad durante la edicin y depuracin de programas.
+ontiene adems un su"!tem que despliega informacin so"re la versin del
compilador, copyright y otros datos generales.
$l entorno es muy sencillo de utilizar. +on unos pocos minutos de prctica y
eploracin podr editar sus programas, compilarlos, ejecutarlos e incluso
utilizar las opciones avanzadas de depuracin.
Las opciones del men de SLE
La siguiente ta"la resume la funcin de cada opcin del men#.
Tabla 1! +pciones del men& de SL"
Men Opcin Elija esta opcin para
Archivo Nuevo +rear un nuevo archivo de programa fuente. Enicialmente el
archivo no tiene nom"re y de"e proveer uno antes de gra"arlo.
Abrir '"rir un archivo de programa fuente ya eistente. SL$ le
mostrar una ventana donde podr elegir el archivo de una
lista, o tipearlo directamente.
rabar 6ra"ar un archivo de programa fuente. Si ste aun no tiene
nom"re, SL$ le pedir que indique uno.
rabar como +rear un nuevo archivo de programa fuente en "ase al que se
est editando. SL$ le preguntar cmo de"e llamarse este
archivo.
!ambiar directorio $sta"lecer en qu directorio se estar tra"ajando, es decir,
dnde se "uscarn los archivos de programas fuentes y dnde
se gra"arn los programas compilados.
Ir al "OS 'cceder a la l!nea de comandos del sistema operativo, sin dejar
completamente SL$. 'l salir del procesador de comandos se
volver automticamente a SL$.

,
Tabla 1! +pciones del men& de SL" $continuacin%
Imprimir Emprimir el programa o archivo que se est editando.
Salir '"andonar SL$. Si alg#n programa fuente fue modificado,
SL$ le preguntar si desea gra"arlo antes de salir.
Editar "es#acer 5eshacer el #ltimo cam"io realizado en el teto del programa
fuente, por ejemplo "orrar, cortar, pegar, etc. Solo podr
deshacer un cam"io si permanece en la misma l!nea donde ste
se efectu.
!ortar 7ransferir al portapapeles la porcin de teto que est marcada.
!opiar Ensertar en el portapapeles una copia de la porcin de teto que
est marcada.
$e%ar Ensertar en el programa fuente que se est editando lo #ltimo
que se haya copiado al portapapeles.
&orrar $liminar la porcin de teto que est marcada.
Mostrar portapapeles 'ctivar la ventana del portapapeles.
Buscar Encontrar Localizar un teto determinado dentro del programa fuente.
'eempla(ar Sustituir un teto determinado por otro en el programa fuente.
&uscar de nuevo :epetir la #ltima operacin de localizacin o sustitucin.
Eecutar !ompilar Ferificar que el programa est correcto, seg#n las reglas de SL,
y prepararlo para su ejecucin posterior.
)so de memoria +am"iar el tamao del rea de cdigo del rea de datos. '
menos que escri"a programas de varios miles de l!neas o que
use miles de varia"les, no necesitar cam"iar los valores por
defecto esta"lecidos por SL$.
Ejecutar $jecutar el programa que se est editando. $l programa ser
primero compilado si SL$ detecta que fue cam"iado luego de
la #ltima compilacin eitosa.
Terminar 8acer que termine la ejecucin de un programa.
Ar%umentos $sta"lecer parmetros que luego el programa pueda recuperar
al inicio de la ejecucin, a travs de la funcin paramval().
$ncierre entre comillas los parmetros que consten de varias
pala"ras.
!epurar $aso a paso Seguir l!nea a l!nea la ejecucin de un programa.
$or nivel Seguir la ejecucin de un programa. ' diferencia de la opcin
C&aso a pasoD, las llamadas a su"rutinas son ejecutadas en un
solo paso, es decir, no se muestra la ejecucin de las sentencias
de las su"rutinas.
-
Tabla 1! +pciones del men& de SL" $continuacin%
*asta l+nea actual $jecutar un programa hasta que la ejecucin llegue a cierta
l!nea en el programa fuente.
$unto de parada $sta"lecer en qu l!neas de"e detenerse la ejecucin de un
programa.
Evaluar e,presin G"servar qu valor tiene una varia"le o una epresin.
A%re%ar e,presin Encluir una epresin en CFisor de epresionesD.
Ventana Tama-o.Mover 4over o cam"iar de tamao un ventana, usando las teclas del
cursor. &ulse $97$: cuando haya terminado de u"icar o
cam"iar de tamao la ventana.
/oom 'ctivar3desactivar el modo de pantalla completa de una
ventana de edicin.
Mosaico Grganizar las ventanas de edicin que estn a"iertas de modo
que todas sean vistas en el pantalla, al menos parcialmente.
!ascada Grganizar las ventanas de edicin que estn a"iertas de modo
que queden solapadas.
Si%uiente 'ctivar la siguiente ventana a"ierta. Luego de la #ltima ventana
se volver a la primera.
$revio 7raer al frente la ventana previa.
'esultados G"servar los resultados que hayan impreso los programas
durante su ejecucin.
0isor de e,presiones 'ctivar la ventana que contiene la lista de epresiones que
desea monitorearse durante la ejecucin de un programa.
Opciones !olores +am"iar los colores de los elementos de SL$% men#es, teto,
"ordes, etc.
rabar escritorio 6ra"ar en un archivo la com"inacin de colores, ventanas
a"iertas y dems elementos de SL$, de modo que luego pueda
recuperarse.
'estaurar escritorio :ecuperar la com"inacin de colores, ventanas a"iertas y
dems elementos de SL$ que fueron almacenados en un
archivo con la opcin C6ra"ar escritorioD.
)so de las teclas rpidas
Las teclas rpidas son teclas de funcin o com"inaciones de teclas que pueden
ser usadas para ejecutar gilmente acciones sin necesidad de acceder al men#
y seleccionar la opciones correspondientes. Las opciones ms usadas del
men# tienen asociadas una tecla rpida. Gtras teclas rpidas tam"in estn
situadas en la #ltima l!nea de la pantalla de SL$.
' continuacin se muestra el !tem C$jecutarD del men# principal, seguida de
una ta"la que resume las principales teclas.
.
igura 3! U#icacin de las teclas rpidas
$rincipales teclas rpidas
Tabla 1! Lista de las principales teclas rpidas
Tecla 2uncin
"# 6ra"ar el archivo que se est editando.
"$ '"rir un archivo que est almacenado en el disco.
"% $jecutar un programa hasta que la ejecucin llegue a cierta l!nea en el programa fuente.
"& 'ctivar3desactivar el modo de pantalla completa de una ventana de edicin.
"' 'ctivar la siguiente ventana a"ierta. Luego de la #ltima ventana se volver a la primera.
"( Seguir l!nea a l!nea la ejecucin de un programa.
") Seguir la ejecucin de un programa. ' diferencia de la opcin C&aso a pasoD, las
llamadas a su"rutinas son ejecutadas en un solo paso, es decir, no se muestra la
ejecucin de las sentencias de las su"rutinas.
"*+ 'cceder al men# principal.
Alt,"$ +errar una ventana.
Alt,"& G"servar los resultados que hayan impreso los programas durante su ejecucin.
Alt,"- Ferificar que el programa est correcto, seg#n las reglas de SL, y prepararlo para su
ejecucin posterior.
.trl,"# 8acer que termine la ejecucin de un programa.
.trl,"% G"servar qu valor tiene una varia"le o una epresin.
.trl,"( Encluir una epresin en CFisor de epresionesD.
.trl,") $sta"lecer3desactivar punto de parada.
.trl,"- $jecutar el programa que se est editando. $l programa ser primero compilado si
SL$ detecta que fue cam"iado luego de la #ltima compilacin eitosa.
1/
Teclas espec+3icas del editor
Tabla 4! Lista de las principales teclas espec01icas del editor
Tecla 2uncin
.trl,/ $liminar una l!nea de teto.
.trl,0" Localizar un teto determinado dentro del programa fuente.
.trl,0A Sustituir un teto determinado por otro en el programa fuente.
.trl,L :epetir la #ltima operacin de localizacin o sustitucin.
Tabla 4! Lista de las principales teclas espec01icas del editor $continuacin%
Tecla 2uncin
.trl,1ns Ensertar en el portapapeles una copia de la porcin de teto que est marcada.
Shi2t,1ns Ensertar en el programa fuente que se est editando lo #ltimo que se haya copiado al
portapapeles.
.trl,!el $liminar la porcin de teto que est marcada.
3ome Er al principio de la l!nea actual
End Er al final de la l!nea actual.
.trl,Bac4space 5eshacer el #ltimo cam"io realizado en el teto en edicin.
5e6uerimientos de hard7are 8 so2t7are
SL$ requiere ;indo<s=> o ;indo<s=? para funcionar. Bna configuracin
acepta"le es una &+ con%
&rocesador &entium con 1H42 de :'4 (se recomienda ,-42).
1A42 de espacio li"re en disco duro.
4onitor color.
4ouse.
11
12
Aspectos b5sicos de SL
Los comentarios
Los comentarios son utilizados dentro de los programas SL para "rindar
informacin al programador que realizar, posi"lemente, modificaciones al
programa original. $s decir, sirve para documentar un programa o parte de
l. 7odos los comentarios insertados en un programa SL son completamente
ignorados por el compilador.
$isten dos formas de introducir comentarios en el programa fuente%
&rimera forma% Bsando la do"le "arra (33).
$l compilador ignora todo lo que sigue a la do"le "arra, hasta el final de
la l!nea. Se utiliza generalmente para hacer acotaciones en la misma l!nea
de alguna sentencia cuya compresin por parte del programador ser
facilitada con el comentario.
Si se desea escri"ir un comentario que ocupe ms de una l!nea, cada una
de stas de"e iniciarse con 33.
13
Ca pG t ul o
0
+omentarios iniciados con 33 se utilizan a menudo para eplicar el
propsito de una varia"le.
$jemplo%
programa cuadrado
//
// &6sto es un comentario7)
// 8ado un nmero n* imprimir su cuadrado.
//
var
n* // valor proveido por el usuario
cuad : numerico // cuadrado de n
inicio
// -idamos al usuario 9ue in%rese un numero
leer &n)
// Calculemos el cuadrado de n para lue%o imprimirlo
cuad 0 n * n
imprimir &cuad)
fin
Segunda forma% Bsando el par /* */
' diferencia de la do"le "arra, el comentario puede ocupar varias l!neas,
es decir, el comentario termina solo cuando se encuentra la secuencia I3 y
no cuando se llega al final de la l!nea.
Lo que sigue es el mismo programa que imprime el cuadrado de un
n#mero, pero con comentarios multil!neas, com"inados con el uso de la
do"le "arra.
programa cuadrado
/*
&6sto es un comentario7)
8ado un nmero n* imprimir su cuadrado.
*/
14
var
n* // valor proveido por el usuario
cuad : numerico // cuadrado de n
inicio
/* -idamos al usuario 9ue in%rese un numero */
leer &n)
// Calculemos el cuadrado de n para lue%o imprimirlo
cuad 0 n * n
imprimir &cuad)
fin
Bn comentario multil!nea (delimitado por 3I J I3) puede contener otros
comentarios iniciados con do"le "arra, aunque no a otro multil!nea, es decir,
no pueden anidarse.
1denti2icadores
Los identificadores son utilizados para dar nom"re a los programas,
varia"les, su"rutinas, tipos de datos, constantes y otros elementos de un
programa SL.
$isten algunas reglas a tener en cuenta en la creacin de identificadores%
1. 5e"en comenzar con una letra o con el carcter .K0 (guin "ajo).
-. &ueden tener hasta ,- caracteres.
,. 9o de"en contener espacios.
L. La com"inacin de may#sculas y min#sculas en los identificadores
hace que los mismos sean considerados diferentes. $n otras pala"ras%
CANTIDAD, cantidad y Cantidad representan tres identificadores
distintos.
>. &ueden incluir las letras y M (ee min#scula y may#scula
respectivamente).
H. 9o pueden contener caracteres acentuados.
N. &ueden incluir com"inaciones de letras y n#meros y el carcter .K0
(guin "ajo)
15
's!, los siguientes son identificadores vlidos%
peso total:puntos ;A<C!LU;=A$ "esultado
mat2 var:12:meses s%te:a>o
Los siguientes no son acepta"les como identificadores (las eplicaciones van
entre parntesis)%
2da:var &debe empezar con letra o %ui?n ba'o)
@prueba &debe empezar con letra o %ui?n ba'o)
cant alumnos &contiene un espacio)
totApuntos &no puede contener %ui?n)
Palabras reservadas
Las pala"ras utilizadas por SL para propsitos especiales son llamadas
Cpala"ras reservadasD. 5ado que las mismas tienen un significado espec!fico
para el compilador de SL, no pueden ser utilizadas como identificadores.
7odas las pala"ras reservadas de"en ser escritas siempre completamente en
letras min#sculas, de lo contrario el compilador SL no las reconocer como
tales.
Tabla 67 2ala#ras reservadas de SL
and archivo caso const
constantes desde eval fin
hasta inicio lib libext
matriz mientras not or
paso subrutina programa ref
registro repetir retorna si
sino tipos var variables
vector
!elimitadores de sentencias
Las sentencias pueden ocupar una o varias l!neas, es decir%
a 0 &b 4 c) * &b / y) 4
&y / c)
es una sentencia vlida, aunque ocupa dos l!neas.
1'
&uede escri"irse ms de una sentencia en una sola l!nea, si se las separa por el
carcter punto y coma (./0). 's!%
a 0 b 4 cB n 0 a / y
son dos sentencias escritas en una sola l!nea, separadas por el carcter punto
y coma (./0).
Las epresiones numricas complejas o las sentencias muy largas pueden ser
li"remente distri"uidas en dos o ms l!neas para mejorar la legi"ilidad del
programa fuente SL.
7am"in de"emos sealar que las l!neas en "lanco y los espacios entre las
sentencias no son necesarios para la computadora interprete correctamente el
programa, por lo tanto podr!amos omitirlas, pero al suprimirlos haremos
dif!cil a otras personas, e incluso a nosotros mismos, la comprensin de
nuestros programas.
1,
Estructura general de un programa SL
$l siguiente diagrama muestra esquemticamente las partes de un programa
SL
programa nombre:del:pro%rama $sta especificacin es opcional.
Const
declaracion de una o mCs constantes
+onstantes, tipos de datos y varia"les
glo"ales.
tipos
declaracion de uno o mCs tipos de datos
+ualquiera de estas clusulas (const, tipos,
var) pueden aparecer ninguna o varias veces,
en cualquier orden.
var
declaracion de una o mCs variables
inicio
...
sentencias
...
fin
'qu! empieza la ejecucin del programa.
'qu! termina la ejecucin del programa.
subrutina sub1&) retorna tipo:dato
const
...
tipos
...
var
...
inicio
...
sentencias
retorna &al%un:valor)
fin
Las su"rutinas van despus del programa
principal, y a su vez pueden tener varia"les,
constantes y tipos de datos locales.
&ueden reci"ir cualquier cantidad de
parmetros. Si son funciones, retornan un
valor.
subrutina sub2 &ref p : tipo:dato* ...)
const
...
tipos
...
var
...
inicio
...
sentencias
...
fin
Los parmetros pueden ser pasados por
valor o por referencia.
1-
Tipos de datos b5sicos 8 constantes
literales
$l tipo de dato de una varia"le determina qu valores pueden ser almacenados
en dicha varia"le y qu operaciones podemos realizar con ella. &or ejemplo,
si usamos una varia"le para almacenar la altura de una persona estamos
diciendo que dicha varia"le contendr valores numricos. $n este caso
diremos que el tipo de la varia"le edad es numrico.
$n SL todos los valores y varia"les tienen asociados un tipo de dato y el
compilador realizar verificaciones precisas para asegurar que las operaciones
realizadas sean consistentes. Si por ejemplo se escri"e un programa que
contenga
a = suma + 10
el compilador sealar que eiste un error pues sumar una pala"ra con 1A no
produce un resultado significativo. $l compilador dir que no eiste
concordancia de tipos de datos pues, como veremos en seguida, CsumaD es
una cadena mientras que 1A es un numrico.
1.
Ca pG t ul o
3
SL soporta tres tipos de datos "sicos o fundamentales% numricos, cadenas y
"ooleanos. $stos tipos representan valores simples para los que el lenguaje
tiene un rico conjunto de operadores y funciones predefinidas.
$isten adems otros mecanismos para definir tipos de datos ms complejos
que se eplican en cap!tulo C7ipos de datos agregadosD
Tabla 9! 3ipos de datos #4sicos de SL
Tipo de dato
b5sico "escripcin de los valores :ue puede almacenar
cadena +ualquier secuencia de caracteres 'S+EE, ecepto el carcter 9BL (valor 'S+EE A). La
cadena vac!a se representa por CD y su longitud es A.
logico Los valores 7:B$ y @'LS$, o sus sinnimos SE y 9G respectivamente. $stos cuatro
identificadores son constantes predefinidas.
numerico Falores enteros y reales, con signo o sin signo.
Las constantes literales
Se llaman constantes literales a aquellos n#meros o cadenas que forman parte
del teto del programa.
Los nmeros
Los n#meros en SL pueden ser enteros o reales. Los enteros se componen
#nicamente de d!gitos y opcionalmente el carcter de signo (.O0 o .*.)
precedindolos.
Los reales, en cam"io, pueden contener adems un punto decimal (..0)
seguido de otros d!gitos, que indican la parte fraccionaria del n#mero.
'dems puede utilizarse notacin cient!fica. 'lgunos ejemplos de constantes
numricas son%
D1E A111 421F
D.1E 2e411 GeAD H641D1
Los valores mimos y m!nimos son%
Falor m!nimo % *1.N$*,A?
Falor mimo % 1.N$O,A?
2/
Las cadenas de caracteres
Bna cadena es una secuencia de caracteres encerrados entre comillas o
apstrofes.
Los siguientes son ejemplos de cadenas%
+Aprendiendo a pro%ramar.../
+Conteste con IsiJ o InoJ* por .avor/
I;arKa di'o: +LMuenos dKas7/I
+omo puede o"servarse, cualquier carcter puede ser incluido como parte de
la cadena, ecepto el delimitador. Si por ejemplo se desea incluir una comilla
en un mensaje, de"e iniciarse y finalizarse la cadena con apstrofe, y
viceversa, o utilizar PD.
Las constantes de cadena de"en ca"er completamente en una l!nea. $s decir,
lo siguiente no es vlido porque la comilla que cierra la cadena aparece
recin en la segunda l!nea%
texto 0 +Aprender a pro%ramar
es divertido/
Si es necesario distri"uir una constante de cadena en ms de una l!nea, puede
usarse el operador de concatenacin%
texto 0 +Aprender a pro%ramar/ 4
+es divertido/
Las secuencias de escape
Las Csecuencias de escapeD permiten insertar en un programa fuente
caracteres que, de ser tipeados directamente, ser!an mal interpretados por el
compilador. La siguiente ta"la resume estas secuencias y sus significados.
Tabla ;! Secuencias de escape
Secuencias Si%ni3icado
9n Enicio de la siguiente l!nea
9r Enicio de la l!nea actual
9t 7a"ulador
21
&or ejemplo
imprimir &+-rimera linea,n$e%unda linea/)
har que lo que sigue a Pn se imprima en otra l!nea%
-rimera linea
$e%unda linea
+ualquier otra com"inacin da como resultado el carcter que sigue a la
primera "arra invertida. 's!%
N,.N 8a como resultado .
N,,N 8a como resultado ,
N,NN 8a como resultado N
9o de"emos olvidar que las secuencias de escape representan un solo
carcter, aunque lo sim"olicemos con dos. $s decir, la cadena
C2uenosPnd!asD contiene 11 caracteres%
1 - 0 3 ; 5 C < 9 1= 11
& u e n o H
n
d G a
Un eemplo
$l siguiente programa calcula la altura mima que alcanza un proyectil
lanzado con una velocidad y angulo prove!dos por el usuario.
+omo ya vimos con anterioridad, la clusula Cprograma algunKnom"reD es
opcional. Su #nica funcin es proveer al programador una indicacin del
propsito del programa. Bsemos o no la clusula CprogramaD, es importante
poner un comentario al inicio al inicio del programa fuente, declarando los
o"jetivos y otros datos adicionales de inters para quien de"a leer y
comprender nuestros programas.
/*
22
!M#6OP!: Calcular la altura maxima alcanzada por un proyectil
lanzado con una velocidad inicial y an%ulo dados.
AU!": 'se%ovia

La .ormula utilizada es:

donde:
P1 : velocidad inicial
a : an%ulo de disparo
% : aceleracion de la %ravedad
*/

var
v:disp* // Pelocidad inicial
a:disp : numerico // An%ulo de disparo

a:disp:rad : numerico // O%ual 9ue a:disp pero en radianes
Q:max : numerico // Altura maxima
inicio
/*
-idamos al usuario 9ue in%rese velocidad inicial y an%ulo de
disparo. 6ste ultimo debe estar en %rados sexa%esimales.
*/
imprimir &R,n,n/*
+On%rese velocidad inicial* an%ulo de disparo en sexa%esimales:R)
leer &v:disp* a:disp)

// La .uncion sin&) opera con radianes y nosotros leimos en sexa%esimales.

a:disp:rad 0 a:disp * D.1E1GS2TGE / 1H1
Q:max 0 & &v:disp * sin &a:disp:rad) ) U 2 ) / &2 * S.H)
imprimir &R,n,nAltura maxima0R* Q:max)
fin
23
h=
[V0sen a]
2
2g
24
)so de variables 8 constantes
Bn programa SL de"e declarar todas sus varia"les antes de usarlas. Si "ien la
declaracin de las varia"les puede resultar tediosa al principio, al hacerlo
estamos dando al compilador suficiente informacin que le permita%
'yudarnos en la deteccin de errores de tipeo. 4uchas veces
inadvertidamente escri"imos mal el nom"re de las varia"les, las pala"ras
reservadas, etc.
4ejorar el diagnstico de errores de sintais o de uso del lenguaje.
Gptimizar el rendimiento del programa durante su ejecucin y planificar
el uso de la memoria.

' continuacin veremos la declaracin de varia"les simples, arreglos (vectores y
matrices) y registros, as! como el uso de constantes manifiestas.
!eclaracin de variables simples
&ara declarar una varia"le, se escri"e el nom"re seguido de dos puntos (.%0),
seguido del tipo de dato%
25
Ca pG t ul o
;
var
edad : numerico
nombre : cadena
Si varias varia"les corresponden al mismo tipo, se las puede declarar de la
siguiente forma%
var
tot:mensual* tot:%eneral : numerico
nombre* apellido : cadena
Los valores por de3ecto
SL da automticamente un valor inicial a las varia"les, dependiendo de qu
tipo sean. La siguiente ta"la resume los valores iniciales%
Tabla <! )alores iniciales de las varia#les en SL
Tipo de dato
b5sico 0alor inicial
cadena +adena vac!a. $s decir, SL impl!citamente hace variable 0 +/
logico Falor lgico falso. $s decir, SL impl!citamente hace variable = FALSE
numerico +ero. $s decir, SL impl!citamente hace variable = 0
!eclaracin de constantes mani2iestas
Las constantes manifiestas (o simplemente constantes) son nom"res a los
que asignamos un valor que no cam"iar durante la ejecucin de todo el
programa.
$l siguiente programa utiliza una constante manifiesta (:'EQK,) y calcula la
altura de un tringulo equiltero, si se da la longitud del lado. $l programa
imprimir -.>=?A? si se ingresa , como longitud del lado, que corresponde a
la siguiente figura%
/*
!M#6OP!: Calcular la altura de un trian%ulo e9uilatero* dado el lado.
AU!": 'se%ovia
2'
Altura52!5.-/-
Lado53
La .ormula utilizada es:

donde:
a : lado del triCn%ulo
*/
const
"AOV:D 0 1.FD21G1H1H
var
a* Q : numerico // lado y altura* respectivamente
inicio
imprimir &R,n,nOn%rese lon%itud del lado:R)
leer &a)

Q 0 a * "AOV:D / 2
imprimir &R,n,nAltura del triCn%ulo0R* Q)
fin
Al%unas observaciones sobre las constantes mani3iestas
Las constantes manifiestas son #tiles para la programacin porque%
4ejoran la legi"ilidad del programa, dando nom"res descriptivos a valores
que de otra forman pueden lucir CmgicosD.
@acilitan el mantenimiento, ya que si el valor constante se usa en muchas
partes del programa y necesita ser modificado, solo de"e hacerse en una
sola parte.
7odas las constantes manifiestas corresponden a un tipo de dato, que depende
del valor que se les asocie. &or ejemplo la siguiente es una constante manifiesta
de cadena%
const
8OWO!$ 0 +112DEGTFHS/
'dems el compilador SL verifica que el valor de la constante nunca sea
alterado, directa o indirectamente. &or ejemplo, ocurrir un error de
compilacin si en el cuerpo del programa se intenta asignar alg#n valor a la
constante DIGITOS.
2,
h=
a 3
2
!onstantes mani3iestas prede3inidas
SL tiene cuatro constantes manifiestas lgicas predefinidas% 7:B$, @'LS$,
SE, 9G.
Tabla =! Constantes mani1iestas prede1inidas de SL
!onstante
mani3iesta 0alor asociado
:5UE +orrespondiente al valor de verdad verdadero
"ALSE +orrespondiente al valor de verdad falso
S1 Sinnimo de 7:B$
;O Sinnimo de @'LS$
!eclaracin de vectores 8 matrices
La declaracin de vectores en SL es muy sencilla% se declara como una
varia"les ms, indicando al compilador los datos adicionales que necesita%
La cantidad de elementos que tendr, y
5e qu tipo sern los elementos, es decir, si sern numricos, de cadena o
lgicos. $n cap!tulos siguientes veremos que incluso pueden tener
elementos mucho ms complejos que estos tres "sicos.
&or ejemplo, para declarar un vector numrico de 1AA elementos
escri"iremos%
var
A : vector X111Y numerico
&ara imprimir el valor del primer elemento escri"iremos%
imprimir &A X1Y)
+on el siguiente ciclo podemos imprimir todos los elementos del vector, uno
en cada l!nea%
desde k01 hasta 111
3
imprimir &+,n/* A XkY)
5
)n ejemplo sencillo de uso de vectores
2-
' continuacin presentamos un programa que calcula la cantidad de alumnos
que o"tuvieron una nota inferior al promedio del curso para cierta materia.
7endremos en consideracin los siguientes datos adicionales%
$l curso tiene -A alumnos
7odos los alumnos se presentaron al eamen
Las notas van del A al 1AA
5ado que necesitaremos almacenar la nota de cada alumno para luego
compararlo con el promedio del curso, usaremos un vector.
/*
!M#6OP!: Calcular la cantidad de alumnos 9ue obtuvieron nota
in.erior al promedio del curso en cierta materia.
Zay 21 alumnos. odos rindieron. Las notas van del 1 al 111.
Asumimos 9ue todas las notas son correctas.
AU!": 'se%ovia
*/
const
;A<:ALU;=!$ 0 21

var
notas : vector X;A<:ALU;=!$Y numerico
suma:notas : numerico // suma de todas las notas leidas
prom : numerico // promedio del curso
cnb : numerico // cantidad con notas ba'as
k : numerico

inicio
desde k01 hasta ;A<:ALU;=!$
3
imprimir &R,nOn%rese nota para alumno numero R* k* R:R)
leer &notas XkY)

/*
Payamos obteniendo la suma de las notas para 9ue* una vez
terminada la lectura* podamos calcular el promedio.
-odriamos Qacerlo en otro ciclo* pero ya 9ue tenemos el dato...
*/
suma:notas 0 suma:notas 4 notas XkY
5

prom 0 suma:notas / ;A<:ALU;=!$

2.
/*
!bservar 9ue la cantidad de alumnos con notas in.eriores
al promedio del curso $!L! podremos calcular una vez
obtenido el promedio.
*/
cnb 0 1
desde k01 hasta ;A<:ALU;=!$
3
si & notas XkY [ prom )
3
cnb 0 cnb 4 1
5
5
imprimir &R,n6xisten R* cnb* R alumnos con notas in.erioresR*
R al promedio del curso* 9ue es R* prom)
fin
Si los datos prove!dos al programa fueran%
HS FD HE SE HT SE GS S1 SH ED GD FG T2 ED HH FF SE HF S2 S1
el resultado ser!a%
6xisten H alumnos con notas in.eriores al promedio del curso* 9ue es FH.T
"eclaracin 8 uso de matrices
Las matrices son declaradas eactamente igual que los vectores, ecepto que
se especifica ms de una dimensin entre los corchetes%
var
; : matriz XG* 11Y cadena
$n este caso 4 es una matriz de > filas por 1A columnas, donde cada
elemento es una cadena.
La siguiente matriz tridimensional se declara con%
;D : matriz XD* G* 2Y numerico
3/
!eclaracin de registros
Se llama CregistroD (algunos usan el trmino CestructuraD) a una varia"le
que est compuesta a su vez de otras varia"les.
La ventaja de agrupar varia"les para formar una estructura ms compleja
es que de esa forma se mantiene la unidad conceptual del dato. &or
ejemplo, una fecha es un solo CdatoD, a pesar de que se compone de d!a,
mes y ao. $n muchos casos es desea"le tratarla como una sola entidad y
en otros deseamos operar so"re sus componentes.
' continuacin un ejemplo de declaracin de registro%
var
r : registro
3
nombre : cadena
edad* peso : numerico
direccion : cadena
5

' las varia"les contenidas en un registro se las llama campos. $n este
caso, r es una varia"le que contiene tres campos, los que pueden ser
accedidos de la siguiente forma%
r.nombre 0 +;aria Wonzalez/
r.edad 0 1G
r.peso 0 EH
r.direccion 0 +Al%un lu%ar/
31
5 columnas
3 1ilas
(3 6175728
es decir, los campos son accedidos poniendo el nom"re de la
varia"le*registro, seguido de un punto y a continuacin el nom"re del
campo. Los campos son utilizados como cualquier otra varia"le.
Los registros pueden contener varia"les de cualquier tipo, incluyendo
vectores, otros registros, etc.
5adas las siguientes definiciones%
var
p1* p2 : registro
3
nombre : cadena
edad* peso : numerico
direccion : cadena
.ecQa:nac : registro
3
dia* mes* a>o : numerico
5
notas : vector X111Y numerico
5
Las varia"les p1 y p- son registros, am"os conteniendo H campos, uno de
los cuales (fechaKnac) es a su vez un registro y el #ltimo es un vector
numrico de 1AA elementos. &or lo tanto, para asignar un valor al campo
dia de la varia"le p1 se usar!a%
p1..ecQa:nac.dia 0 2D
y para asignar un valor al segundo elemento del vector notas de la varia"le
p- se usar!a%
p2.notas X2Y 0 SH
En el captulo veremos en m!s detalle estas " otras posi#ilidades de los
registros.
32
Otras consideraciones sobre el uso de re%istros
Los nom"res de campos no pueden duplicarse dentro de un mismo
registro.
&ara leer o imprimir un registro, de"e realizarse la operacin deseada
so"re cada uno de sus campos, toda vez que estos sean de tipos
simples.
Bna definicin de registro de"e especificar al menos un campo.
33
34
Operadores 8 e,presiones
Llamamos expresin a una com"inacin vlida de operadores, constantes,
varia"les y llamadas a funciones. Las epresiones tienen un papel
fundamental en SL pues a travs de ellas epresamos los clculos y otras
operaciones que deseamos que el programa realice.
$l uso de epresiones es muy sencillo porque en su mayor!a se componen de
operaciones aritmticas de uso cotidiano% sumas, multiplicaciones, potencias,
etc.
'lgunos ejemplos de epresiones son%
peso * 11
cantidad 4 1
s9rt &aU2 4 bU2) // s9rt&) calcula la raiz cuadrada
apellido 4 +* / 4 nombre // produce* por e'emplo* +Wonzalez* ;arta/
Operadores
Los operadores son s!m"olos que usamos para indicar la realizacin de
operaciones con ciertos datos, a los que llamamos operandos. Los operadores
35
Ca pG t ul o
5
de SL se dividen en cuatro grupos% aritmticos, lgicos, relacionales y de
concatenacin de cadenas.
Operadores aritm>ticos
La ta"la siguiente resume los operadores aritmticos disponi"les en SL.
$stos operadores pueden aplicarse a cualquier valor numrico, sea que este
tenga parte fraccionaria o no.
+omo puede apreciarse, todos estos operadores, con ecepcin de los dos
#ltimos, son "inarios (requieren dos operandos).
Tabla ?! +peradores aritm9ticos
Opera
@dor
Si%ni3icado Ejemplos 8 observaciones
, Suma a 0 b 4 11
< :esta a 0 b \ 11
= (ultiplicacin a 0 b * 11
> ;ivisin! a 0 12DE / 11 // producirC 12D*E
Si se desea solo la parte entera, puede usarse la funcin int()%
a 0 int &12DE / 11) // producirC 12D
Si el divisor es cero, se produce un error de ejecucin y el programa
termina.
? (dulo! Calcula el resto de
dividir el primer operando por
el segundo
a 0 11 ] D // producirC 1
$ste operador E69G:' las partes fraccionarias de am"os
operandos%
a 0 11.E ] D.11 // producirC tambi^n 1
Si el divisor es cero, se produce un error de ejecucin y el programa
termina.
3'
Tabla ?! +peradores aritm9ticos $continuacin%
Opera
@dor
Si%ni3icado Ejemplos 8 observaciones
@ 2otenciacin! a 0 2 U E // producirC 1T
a 0 2 U 1.G // producirC 1.E1E21
&raKz cuadrada de 2)
$l eponente puede ser un valor entero o fraccionario.
a 0 2 U D U 2
se interpreta como
a 0 2 U &D U 2)
< Cam#io de signo a 0 11B b 0 Aa // b tendrC \11
Se le llama tam"in Cmenos unitarioD pues act#a so"re un solo
operando.
, Identidad de signo! "l signo del
operando al <ue se aplica
<ueda inalterado!
a 0 A11B b 0 4a // b tendrC \11
Operadores l%icos
La ta"la siguiente resume los operadores lgicos o "ooleanos disponi"les en
SL. Los operadores and y or son "inarios, mientras que not es unitario.
Tabla 1A! +peradores lgicos o #ooleanos
Operador Si%ni3icado Observaciones
and Conjuncin // estC a entre 1 y 111_
si & a `0 1 and a [0 111 )
3
...
5
or ;is=uncin extra>o 0 111 ` 2111 or 1 [ 11
La varia"le CetraoD, que de"i se declarada como de
tipo lgico, tendr el valor de verdad verdadero, ya que 1
es menor que 1A, a pesar de que 1AA no es mayor que
-AAA.
not Negacin extra>o 0 not&1 [ 11)
La varia"le CetraoD, que de"i se declarada como de
tipo lgico, tendr el valor de verdad falso. Los parntesis
no son necesarios aqu!, aunque desea"les por claridad.
3,
Operadores relacionales
Los operadores relacionales disponi"les en SL se detallan en la ta"la
siguiente. 7odos estos operadores son "inarios, es decir, requieren dos
operandos. &ueden ser aplicados a cualquier tipo simple (numrico, cadena o
lgico) siempre que am"os sean del mismo tipo y producen un valor
"ooleano (verdadero o falso).
Tabla 11! +peradores relacionales
Operador Si%ni3icado Ejemplos
A
4enor que a [ 21
B
4ayor que a ` 1
AC
4enor o igual que a [0 21
$l signo R de"e seguir inmediatamente al signo S para
que el compilador interprete SR como Cmenor o igual
queD. 'dems, no es equivalente escri"ir RS.
BC
4ayor o igual que a `0 21
$l signo R de"e seguir inmediatamente al signo T para
que el compilador interprete TR como Cmenor o igual
queD. 'dems, no es equivalente escri"ir RT.
CC Igual <ue a 00 b
9o de"e eistir ning#n otro carcter entre el primer signo
R y el segundo para que el compilador interprete RR
como Cigual queD.
AB ;istinto de a [` b
$l signo T de"e seguir inmediatamente al signo S para
que el compilador interprete ST como Cdistinto deD.
'dems, no es equivalente escri"ir TS.
Operadores relacionales y cadenas
+uando dos cadenas, sean stas literales o varia"les, aparecen como
operandos de un operador relacional, cada carcter de la primera cadena es
comparado el carcter que se encuentra en la segunda cadena en la misma
posicin desde la izquierda.
SL considera que C'D es menor que C2D porque la primera letra aparece
antes que la segunda en la ta"la 'S+EE. $sta comparacin de posiciones en la
3-
ta"la 'S+EE determina el funcionamiento de los operadores relacionales
aplicados a cadenas. ' continuacin algunos ejemplos.
Tabla 11! Algunos ejemplos del uso de cadenas con operadores relacionales
!omparacin 'esultado E,plicacin
ABC < ACC
Ferdadero $l segundo carcter de la primera cadena es C2D, mientras
que de la segunda cadena es C+D. $n la ta"la 'S+EE C2D est
antes que C+D.
a <= A
@also $n la ta"la 'S+EE las letras min#sculas aparecen mucho
despus que las may#sculas, es decir, son CmayoresD.
ABA > AB
Ferdadero Los dos primeros caracteres de am"as cadenas coinciden
pero la primera cadena tiene un carcter ms que la segunda,
lo que la convierte en CmayorD que la segunda.
AbCdE == AbCdE
Ferdadero Los caracteres de am"as cadenas son los mismos, en el
mismo orden.
Z >
Ferdadero Bna cadena de longitud uno es mayor que la cadena vac!a.
==
Ferdadero 'm"as cadenas tienen longitud A.
!oncatenacin de cadenas
Llamamos concatenacin a la operacin de tomar dos cadenas y generar una
tercera que contiene todos los caracteres de la primera cadena seguidos de los
de la segunda. Feamos un ejemplo%
/*
!M#6OP!: ;ostrar el uso del operador de concatenaci?n de cadenas.
AU!": 'se%ovia
*/
var
cad1* cad2* cadD : cadena
inicio
cad1 0 +-rimer/
cad2 0 +Curso/
cadD 0 cad1 4 cad2
imprimir &cadD)
fin
$l programa imprimir
-rimerCurso
3.
Si deseamos dejar un espacio entre la primera y la segunda cadena, podemos
escri"ir%
cadD 0 cad1 4 + + 4 cad2
$l signo utilizado para concatenar cadenas es el mismo que usamos para
sumar n#meros. $l compilador puede interpretar correctamente lo que
deseamos realizar porque inspecciona el tipo de las varia"les que acompaan
al signo .O0% Si am"os operandos son numricos, se trata de una suma/ si
am"os son cadenas, se requiere una concatenacin/ de lo contrario hay un
error.
$s importante sealar que la concatenacin, a diferencia de la suma de
n#meros, 9G es conmutativa. $s decir, no da lo mismo
cadD 0 cad1 4 cad2
que
cadD 0 cad2 4 cad1
$n cap!tulos siguientes veremos que eisten varias funciones predefinidas y
otras operaciones sofisticadas que podemos realizar con cadenas de
caracteres.
Precedencia de los operadores
Las reglas de precedencia de los operadores determinan en qu orden SL
eval#a las epresiones. $n general, los operadores aritmticos tienen la
precedencia usual. La siguiente ta"la define las precedencias de los
operadores en SL.
Tabla 14! 2recedencia de los operadores
$recedencia Operadores
1 (mayor precedencia)
@ (potenciacin)
-
<D , (cam"io de signo, identidad de signo)
,
=D >D ?
L
,D <
4/
Tabla 14! 2recedencia de los operadores $continuacin%
$recedencia Operadores
>
CCD ABD AD ACD BD BC
H
not
N
and
? (menor precedencia)
or
Los operadores que se encuentran en la misma l!nea tienen igual precedencia.
Si forman parte de una epresin o su"epresin no parentizada, se
evaluarn de izquierda a derecha.
Siguiendo la ta"la anterior, la siguientes sentencias hacen que la varia"le
termine con el valor ,1%
a 0 2
b 0 E 4 a * D // b 0 E * &2 * D) 0` E * T 0` 2E
c 0 a U 2 * Ab // c 0 &2 U 2) * A2E 0` E *A2E 0` AST
a 0 b A c ] 11 4 1 // a 0 2E A &AST ] 11) 4 1 0` 2E \ &AT) 4 1 0` D1
Las eEpresiones compleas 8 el uso de parFntesis
&odemos utilizar parntesis con dos propsitos%
&ara hacer que las epresiones sean ms legi"les.
La Ca"undanciaD de parntesis no tiene ning#n impacto negativo so"re la
ejecucin del programa y en cam"io puede facilitar su comprensin, no
solo por parte de uno mismo sino por otros que de"an entender el
programa despus. Bn ejemplo que muestra el uso de parntesis con este
propsito es%
y 0 v1y * t 4 1/2 * A% * tU2 // sin parentizaci?n +redundante/
y 0 &v1y * t) 4 & &1/2)*&A%)*&tU2) )
&ara alterar el orden en que se eval#an las epresiones, si la precedencia
por defecto no produce el resultado que necesitamos. Feamos dos
ejemplos%
a) D * 2 4 1 // es F* pero
D * &2 4 1) // es S
b) A2U2 // es AE* pero
&A2)U2 // es E
41
42
Sentencias
Las sentencias en SL especifican cmo se irn ejecutando las distintas partes
de un programa. $isten varias clases de sentencias% algunas que permiten
ejecutar repetidamente un conjunto de instrucciones (ciclos), otras para
ejecutarlas selectivamente dependiendo de ciertas condiciones (sentencias
condicionales), alterar el valor de las varia"les, ejecutar un su"programa, etc.
$n este cap!tulo veremos la sintais de cada una de las sentencias de SL, as!
como algunos ejemplos de uso.
Sentencia de asignacin
La asignacin a una varia"le tiene la siguiente forma general%
nombre:de:variable 0 expresi?n
$jemplos de asignaciones son%
a 0 11.2D1
b 0 a 4 1
Qipotenusa 0 s9rt &aU2 4 bU2)
43
Ca pG t ul o
C
4s adelante veremos que la asignacin entre vectores, matrices y
registros tiene otras opciones que pueden facilitar la escritura de los
programas.
Sentencia condicional GsiH
$n SL eisten dos sentencias condicionales% sentencia si y sentencia eval.
La primera posi"ilita elegir qu parte de un programa se ejecutar si cierta
condicin se cumple. La segunda puede ayudar a mejorar la legi"ilidad de
un grupo de sentencias si muy largas o complejas.
La sintais "sica de la sentencia si es%
si & condicion )
3
sentencias...
sino
sentencias...
5
La clusula CsinoC y las sentencias correspondientes son opcionales% solo
se usan cuando el programa necesita tomar acciones si la condicin es
falsa.
$rimer ejemplo
Bna caracter!stica peculiar de los tringulos es que ninguno de sus lados
puede ser superior a la suma de los otros dos. $l siguiente programa
verifica si tres valores ingresados por el usuario pueden ser utilizados
como longitudes de un tringulo. $l programa utiliza una construccin
sencilla sisino.
/*
!M#6OP!: 8eterminar si tres valores numericos in%resados por
el usuario pueden ser los lados de un triCn%ulo.
AU!": 'se%ovia
a6CZA: 1HAdicA1SSS
*/
var
a* b* c : numerico
inicio
leer &a* b* c)
44
si & &a ` b 4 c) or &b ` a 4 c) or &c ` a 4 b) )
3
imprimir &+,n=o pueden ser los lados de un triCn%ulo/)
sino
imprimir &+,n-ueden .ormar un triCn%ulo/)
5
fin
Se%undo ejemplo
$l siguiente ejemplo usa una variante de la sentencia si que posi"ilita
verificar varias condiciones y ejecutar acciones para cada caso. $l
programa de"e procesar los puntajes de un grupo de -A alumnos
correspondientes a cierta asignatura y determinar cuntos aplazados hu"o,
cuntos o"tuvieron , y cuntos >.
$l programa usa una variante de la sentencia si cuya sintais es%
si & condicion )
3
sentencias...
sino si & condicion )
sentencias...
sino
sentencias...
5
+omo puede apreciarse, esta variante permite UencadenarU varios
condicionales en una sola sentencia si. $sta estructura es muy #til porque
permite o"viar anidamientos innecesarios. 5e"e o"servarse que las
secuencias Usino si (condicin)U no van seguidas de UVU. 'dems la pala"ra
UsiU de"e u"icarse en la misma l!nea que el UsinoU correspondiente.
/*
!M#6OP!: Calcular cuCntos unos* tres y cincos se dieron en un %rupo
de
21 alumnos considerando los punta'es de una asi%natura
determinada.
Los punta'es estCn expresados en pocenta'es.
6scala:
1 \ GS A` 1
T1 \ FE A` 2
45
FG \ HE A` D
HG \ SE A` E
SG \ 111 A` G
AU!": 'se%ovia &'se%ovia(cnc.una.py)
*/
var
n1* // Cantidad de unos*
nD* // de tres y
nG : numerico // de cincos
pnt : numerico // -unta'e obtenido por un alumno
k : numerico
inicio
k 0 1
n1 0 1B nD 0 1B nG 0 1
repetir
leer &pnt)
si & pnt `0 SG )
3
nG 0 nG 4 1
sino si & pnt `0 HG )
nD 0 nD 4 1
sino si & pnt [ T1 )
n1 0 n1 4 1
5
k 0 k 4 1
hasta & k ` 21 )
imprimir &+,nCantidad de unos: +* n1*
+,nCantidad de tres: +* nD*
+,nCantidad de cincos: +* nG)B
fin
.iclo mientras
$sta construccin posi"ilita ejecutar repetidamente un conjunto de
sentencias mientras se cumpla cierta condicin definida por el
programador.
La sintais del ciclo mientras es%
mientras & condici?n )
3
sentencias...
5
4'
5e"emos notar que la condicin va siempre entre parntesis.
$rimer ejemplo
+omo ejemplo de uso del ciclo mientras escri"iremos un programa para
calcular cuntos guaran!es recaudaremos en un sorteo si vendemos t!cWets
numerados del 1AAA al ====, asumiendo que vendemos todos los
n#meros.
+ada t!cWet cuesta lo que su n#mero indica, es decir, el t!cWet n#mero L->
cuesta cuatrocientos veinticinco.
/*
!M#6OP!: Calcular cuanto se recaudaraJ en un sorteo* si vendemos
todos
Los tickets numerados del 1111 al SSSS.
AU!": desconocido
!M$6"PACO!=: 6l autor de este pro%rama no sabe 9ue la .ormula directa
para calcular el total de %uaranies es:
total 0 &ult:numero \ prim:numero 4 1) / 2 * &prim:num 4 ult:numero)
-or eso Qace un pro%rama +lar%o/ usando ciclos.
*/
var
total : numerico
num : numerico
inicio
total 0 1
num 0 1111
mientras & num [0 SSSS )
3
total 0 total 4 num
num 0 num 4 1
5
imprimir &+,n$eraJ recaudada la suma de Ws. +* total)B
fin
4,
Se%undo ejemplo
El ciclo mientras tiene una peculiaridad% las sentencias contenidas en el ciclo
puede que nunca se ejecuten. $sto ocurrir cuando la condicin del ciclo
sea falsa incluso antes de entrar al ciclo. $sta caracter!stica del ciclo
mientras es com#nmente utilizada en muchas aplicaciones cotidianas.
+omo ejemplo, el programa que sigue calcula el cociente de la divisin
entera de dos n#meros tam"in enteros.
/*
!M#6OP!: Calcular el cociente de a/b* donde a y b son enteros.
La division se Qace por restas sucesivas.
AU!": desconocido
!M$6"PACO!=: 6l autor de este pro%rama no sabe 9ue puede usarse
cociente 0 int &a / b)
-or eso Qace un pro%rama +lar%o/ usando ciclos.
Ademas* el pro%rama trata de ser +comunicativo/ con el
usuario para mostrar distintos usos de imprimir&).
*/
var
a* b* cociente : numerico
inicio
imprimir &+,n-ro%rama para calcular cociente de la division/*
+entera de dos numeros* ambos enteros./
)
imprimir &+,nOn%rese dos numeros enteros* separados por comas:/)
leer &a* b)
cociente 0 1
/*
$i el usuario tipea:
H* 1G
el ciclo nunca se e'ecutara. La variable cociente se%uira
teniendo 1* 9ue es precisamente la respuesta 9ue el pro%rama
debe dar en este caso.
*/
4-
mientras & a `0 b )
3
a 0 a A b
cociente 0 cociente 4 1
5
imprimir &+,n6l cociente es +* a)B
fin
.iclo repetirIIIhasta
' diferencia del ciclo mientras, el ciclo repetir*hasta ejecuta al menos una
vez las sentencias definidas en el cuerpo del ciclo, pues la verificacin para
continuar o no en el ciclo se realiza al final, como puede apreciarse en la
sintais%
repetir
sentencias...
hasta & condicion:de:.in )
5e"emos o"servar que la condicin de fin va entre parntesis.
Si "ien esta forma de ciclo es utilizado con menor frecuencia que el ciclo
mientras, hay situaciones en las que con l el algoritmo resultante es ms
sencillo y directo. ' continuacin un ejemplo%
/*
!M#6OP!: $eparar cada di%ito de un entero positivo in%resado por
el usuario* empezando por el primero de la derecQa.
Cada di%ito se imprime en una linea independiente.
AU!": 'se%ovia
*/
var
num* di% : numerico
inicio
imprimir &+,nOn%rese un numero entero positivo:/)
leer &num)
imprimir &+,nLos di%itos de /* num* + son:/)
/*
Un caso +especial/ lo representa el numero 1* 9ue consta
4.
de un solo di%ito &el 17)
Usando el ciclo mientras la solucion seria un poco mas lar%a.
*/
repetir
di% 0 num ] 11
imprimir &+,n/* di%)
num 0 int &num / 11)
hasta & num 00 1 )
fin
Sentencia eval
La sentencia eval es funcionalmente equivalente a la forma etendida de la
sentencia si, pero aporta mayor legi"ilidad cuando las condiciones son
varias o complejas.
La sintais de la sentencia eval es%
eval
3
caso & condicion )
sentencias...
caso & condicion )
sentencias...
sino
sentencias...
5
$l programa verificar el valor de verdad de la primera condicin. Si se
cumple, ejecutar todas las acciones definidas para ese caso en particular y
luego ir a ejecutar la sentencia que siga a la llave que cierra el cuerpo de
la sentencia eval. Si no se cumple, pasar a verificar la siguiente condicin
y as! sucesivamente. Si ninguna condicin fuese verdadera y eistiese una
clusula CsinoD, se ejecutarn las acciones definidas "ajo esta clusula. La
clusula CsinoD es opcional. Si est presente de"e ser la #ltima.
Ejemplo
$l siguiente programa clasifica lo ingresado por el usuario en Cletra
may#sculaD, Cletra min#sculaD, Cd!gitoD, o Calg#n otroD. &ara determinar a
qu categor!a pertenece un carcter se aprovecha la distri"ucin de los
5/
caracteres en la ta"la 'S+EE junto con los operadores relaciones mayor o
igual (CTRD) y menor o igual (CSRD).
/*
!M#6OP!: Clasi.icar un carCcter in%resado por el usuario en
+letra mayscula/* +letra minscula/* +dK%ito/ o
+al%n otro/.
AU!": 'se%ovia
*/
var
let : cadena
ms% : cadena
inicio
leer &let)
/*
Consideremos solo el primer carCcter* por si Qaya tipeado
mCs de uno.
!bservar c?mo se usan los corcQetes para seleccionar el
primer carCcter.
*/
let 0 let X1Y
eval
3
caso & let `0 IAJ and let [0 IVJ )
ms% 0 +letra mayscula/
caso & let `0 IaJ and let [0 IzJ )
ms% 0 +letra minscula/
caso & let `0 I1J and let [0 ISJ )
ms% 0 +dK%ito/
sino
ms% 0 +al%n otro/
5
imprimir &+,n6l carCcter 9ue usted in%res? es +* ms%)
fin
.iclo desde
Btilizamos el ciclo desde cuando conocemos previamente el n#mero de
veces que deseamos ejecutar un conjunto de instrucciones.
La sintais es%
desde variable:de:control 0 valor:inicio Qasta valor:.in Xpaso
incrementoY
3
sentencias...
5
51
'l igual que el ciclo mientras, el conjunto de sentencias que forman parte
de un ciclo desde puede que nunca se ejecute. $sto ocurrir si%
$l valor inicial es superior al valor final y el incremento es positivo,
$l valor inicial es inferior al valor final y el incremento es negativo.
Ejemplo
$l siguiente programa imprime el cuadrado de los primeros 1A n#meros
enteros positivos.
/*
!M#6OP!: Omprimir una tabla con el cuadrado de los primeros 11
numeros enteros.
AU!": 'se%ovia
*/
var
k : numerico
inicio
desde k01 hasta 11
3
imprimir &+,n/* k* + :,t/* kU2)
5
fin
$l programa imprime%
1 : 1
2 : E
D : S
E : 1T
G : 2G
T : DT
F : ES
H : TE
S : H1
11 : 111
Mas detalles acerca del ciclo desde
+uando usamos el ciclo desde de"emos tener presente algunos detalles%
52
$l valor de inicio, el valor de fin y el incremento de"en ser epresiones
numricas. $l primero (inicio) y el #ltimo (incremento) son siempre
automticamente truncados a enteros.
$l valor del incremento puede ser negativo (por ejemplo, para ir de
1AA a 1).
$l ciclo puede realizarse de A a n veces.
La varia"le de control de"e ser numrica, pudiendo ser un elemento de
un vector o matriz.
'lterar el valor de inicio, el valor de fin o el incremento no tiene
ning#n efecto so"re la cantidad de veces que se ejecutar el ciclo (esto
se calcula justo antes de iniciar el ciclo).
Si se desea salir del ciclo en forma anticipada, puede asignarse a la
varia"le de control el valor de fin.
Sentencia de llamada a subrutinas
Bna su"rutina puede ser ejecutada escri"iendo su nom"re, seguido de los
parmetros reales que ella necesite. &odemos invocar la ejecucin de
su"rutinas que hemos escrito en nuestro programa u otras que estn
predefinidas en SL. La definicin de su"rutinas, los parmetros formales,
los valores de retorno y otros detalles veremos en el apartado
CSu"rutinasD.
La sintais de llamada a su"rutinas es%
nombre:subrutina &parametro1* parametro2* ...)
La cantidad de parmetros y el tipo de dato de cada parmetro depende de
la definicin de la su"rutina.
53
Ejemplo
$l siguiente programa imprime la suma de los primeros n n#meros
enteros. $l valor de n es prove!do por el usuario. Fea el apartado
CSu"rutinasD para ms detalles.
/*
!M#6OP!: Calcular e imprimir la suma de los primeros n
numeros enteros. ;uestra el uso de subrutinas.
AU!": 'se%ovia
*/
var
tot : numerico
n : numerico
inicio
/*
cls&) es una subrutina prede.inida 9ue limpia la pantalla
*/
cls&)
imprimir:explicacion&)
imprimir &+=umero entero_ /)
leer &n)
calcular:suma &n)
imprimir &+,nLa suma de los primeros /* n* +nmeros enteros es +* tot)
fin
/* continuaci?n del pro%rama e'emplo:llamada:subrutinas */
subrutina imprimir:explicacion&)
inicio
imprimir &+,n6ste pro%rama de e'emplo calcula la suma de los enteros/*
+,npositivos comprendidos entre 1 y un valor /*
+9ue se in%resa,n/)
fin
subrutina calcular:suma &entero:tope : numerico)
/*
6'emplo de subrutina 9ue recibe un parametro.
*/
var
k : numerico
inicio
tot 0 1
desde k 0 1 hasta entero:tope
3
tot 0 tot 4 k
5
fin
54
Sentencia retorna
@inaliza la ejecucin de una su"rutina que retorna un valor (funciones) y
de"e ser la #ltima sentencia, por lo que solo puede aparecer una vez en
cada su"rutina.
La sintais es%
retorna & expresion )
55
5'
!aracter+sticas avan(adas de los arre%los 8
re%istros
$n el cap!tulo > ya hemos visto cmo declarar vectores, matrices y registros.
$n ste veremos con mayor detalle otros aspectos de SL particularmente
interesantes% creacin dinmica de arreglos, inicializacin de arreglos y
registros con literales estructurados, arreglos con contornos no regulares,
asignacin entre arreglos, asignacin entre registros, y arreglos de registros.
.reacin dinJmica de arreglos
+omo ya ha"!amos visto, la siguiente declaracin ha"ilita un vector de 1AA
elementos numricos%
v : vector X111Y numerico
$n este caso el tamao del vector ya est definido al momento de la
compilacin. Sin em"argo eisten algunos pro"lemas de la vida real en los
que no es posi"le conocer o no es conveniente predefinir la cantidad mima
de elementos que se requerirn. &uede incluso que el valor mimo var!e de
5,
Ca pG t ul o
<
tiempo en tiempo. $n estas situaciones podemos usar arreglos cuya creacin
sea dinmica, que se declaran como sigue%
v : vector X*Y numerico
es decir, en vez del tamao u"icamos un asterisco para indicar que dicho
valor a#n no conocemos.
Xa en el cuerpo del programa, cuando sepamos la cantidad de elementos que
necesitamos, usamos la su"rutina predefinida dim() que posi"ilita asignar
efectivamente la memoria necesaria%
leer &n)
dim &v* n)
...
$sta posi"ilidad eiste tam"in para las matrices, sin importar la cantidad de
dimensiones. &or ejemplo, lo que sigue declarar!a una matriz en las que la
cantidad de filas y columnas no son conocidas al momento de la
compilacin%
; : matriz X** *Y numerico
inicio
leer &cant:.il* cant:col)
dim &;* cant:.il* cant:col)
...
$ los vectores " matrices crea#les din!micamente los llamamos gen%ricamente
arreglos abiertos&. 'omo veremos en captulos siguientes, (L aprovecha la
disponi#ilidad de arreglos a#iertos para facilitar la escritura de algoritmos m!s
generales.
!ombinaciones interesantes de arre%los abiertos 8 de tama-o 3ijo
La definicin de un arreglo puede incluir una mezcla de tamao fijo con
tamao a"ierto. &or ejemplo, si al momento de escri"ir un algoritmo
sa"emos que requerimos una matriz que tiene ? columnas pero no est
definida la cantidad de filas, podemos escri"ir%
5-
; : matriz X** HY numerico
inicio
leer &cant:.il)
dim &;* cant:.il)
...
$n este caso dim() solo requiere dos parmetros% la matriz 4 y la cantidad de
filas. La cantidad de columnas es tomada de la definicin.
Sin em"argo de"emos recordar que, una vez especificado un valor concreto
para una dimensin, ya no es posi"le usar asterisco para las siguientes
dimensiones. &or lo tanto lo que sigue dar error de compilacin%
; : matriz XG* *Y numerico // 777 =o es vClido 777
(i un programa intenta usar un arreglo a#ierto no iniciali)ado, se genera un error
de ejecucin " el programa para.
1nicializacin de arreglos con literales estructurados
Los elementos de un arreglo pueden ser inicializados completamente con una
sola sentencia. 5ependiendo de que el arreglo tenga tamao fijo o sea
a"ierto, las opciones var!an ligeramente.
La iniciali)acin de arreglos es naturalmente una asignacin. 'omo tal, el valor
previo del arreglo se pierde completamente.
' continuacin unos ejemplos%
a7 Arre%los de tama-o 3ijo
var
tope:meses : vector X12Y numerico
dias:sem : vector XFY cadena
mat : matriz XG* DY numerico
inicio
tope:meses 0 3D1* 2H* D1* D1* D1* D1* D1* D1* D1* D1* D1* D15
dias:sem 0 3+lunes/* +martes/* +miercoles/* +'ueves/*
+viernes/* +sabado/* +domin%o/
5
5.
mat 0 3 3 1* 2* D5*
3 E* G* T5*
3 F* H* S5*
311* 11* 125*
31D* 1E* 1G5
5
fin
Si a partir de cierto punto el resto de los elementos de un arreglo tiene el
mismo valor, puede utilizarse la siguiente notacin%
var
vec : vector X111Y numerico
inicio
vec 0 3121* E1* FD* G* 1* ... 5 // todos cero desde el sexto elemento.
La matriz mat del ejemplo anterior podr!a inicializarse con%
1 - 0
3 ; 5
C < 9
C < 9
C < 9
$s decir, una asignacin como la que sigue puede inicializar con ceros un
vector numrico de tamao fijo, independientemente de cuntos elementos
tenga%
v 0 31* ...5
b7 Arre%los abiertos
Los arreglos a"iertos tam"in pueden ser inicializados con literales
estructurados%
var
inicio
v 0 311* 21* D1* E1* G15
...
'/
La matr0> tendr0a
mat = { { 1, 2, !,
{ ", #, $!,
{ %, &, '!,
(((
!
'uando un arreglo a#ierto es iniciali)ado de esta forma, no es necesario el uso de
dim*+. ,or otra parte, con los arreglos a#iertos no es posi#le el uso de la opcin
de autocompletado *los tres puntos seguidos+ como componente de iniciali)acin.
Bn arreglo a"ierto, independientemente de la cantidad de dimensiones,
puede volver al estado de Cno inicializadoD usando el inicializador VY%
var
m : matriz X** *Y numerico
inicio
dim &v* 11)
dim &m* G* D)
/*
b anto v como m ya estan inicializadas. AQora eliminemos los elementos
de ambos arre%los.
*/
v 0 35
m 0 35
/*
Puelven a estar como si nunca Qayan sido inicializados.
*/
fin
Arreglos con contornos no regulares
5ado que en SL una matriz es un vector de vectores, es posi"le tener
arreglos en los que las filas pueden tener longitudes diferentes unas de otras.
$l siguiente programa crea un arreglo como el que se muestra grficamente a
continuacin%
var
; : matriz X** *Y numerico
.* c : numerico
inicio
; 0 3 3 1* D* 1D* D15*
3 F* 21* G* 1F* 1S* 25*
35*
3 F1* 2D5
5
fin
'1
1 D 1D D1
F 21 G 1F 1S 2
F1 2D
Asignacin entre arreglos
Bn arreglo puede ser asignado a otro con una sola sentencia de asignacin, es
decir, no se requiere asignar elemento a elemento. ' continuacin algunos
fragmentos de cdigo que muestran su uso%
var
;1 : matriz XG* DY numerico
;2 : matriz X** *Y numerico
P1 : vector XDY numerico
P2 : vector X*Y numerico
inicio
;1 0 3 32* 11* ED5*
31* 21* 1E5*
3E* 1* 2F5*
3G* EG* HS5*
3D* 1S* E25
5
;2 0 ;1

P1 0 ;1 X2Y // 31* 21* 1E5
P2 0 ;1 XDY // 3E* 1* 2F5
P2 0 P1 // P2 0 31* 21* 1E5
...
&ara que dos arreglos sean asigna"les los tipos de sus elementos de"en ser
compati"les. 'dems de"e cumplirse que%
$l destino (el que est a la izquierda del signo de asignacin) tiene la
misma cantidad de elementos que el origen,
$l destino es un arreglo a"ierto.
-n arreglo a#ierto no puede ser asignado a uno de tama.o fijo. (i el programa est! en
ejecucin " (L detecta que esto ocurrira, se despliega un mensaje de error " la ejecucin
se cancela.
'2
1nicializacin de registros con literales estructurados
'l igual que los arreglos, los registros pueden ser inicializados con literales
estructurados. 'lgunos ejemplos son%
var
r : registro
3
nombre : cadena
.ecQa:nac : registro
3
dia* mes* a>o : numerico
5
notas : vector X*Y numerico
5
inicio
r 0 3 +Carolina W?mez/* // campo nombre
312* 1F* 1STS5* // campo .ecQa
3HF* S1* SS* SD5 // E notas
5
...
Asignacin entre registros
7am"in es posi"le asignar una varia"le de tipo registro a otra varia"le
coincidente en tipo. $n este caso los valores de todos los campos
(incluyendo los que sean registros, vectores, etc.) sern copiados so"re los
campos de la varia"le de tipo registro que aparezca a la izquierda de la
asignacin.
&ara que dos registros sean asigna"les directamente se de"en cumplir las
siguientes condiciones%
'm"os registros de"en poseer igual cantidad de campos.
+ada campo del primer registro de"e coincidir en caracter!sticas (tipo
"sico, si el campo fuese simple/ cantidad de dimensiones y tipo de sus
elementos, si fuese arreglo, etc.) con su correspondiente en la
secuencia de declaracin del segundo registro.
Los nom"res de los campos no son tenidos en cuenta al momento de
verificar si dos registros son asigna"les. $n el fragmento de cdigo que
'3
sigue se muestra la definicin de dos varia"les de tipo registro, que luego
son usadas en una asignacin en el cuerpo del programa%
var
a : registro
3
x* y : numerico
5
b : registro
3
m* n : numerico
c : vector X111Y numerico
5
inicio
b 0 3 11* 21* // corresponden a m y n respectivamente
31* ...5 // vector c inicializado con ceros
a 0 b
. . .
Arreglos de registros
Los elementos de un arreglo pueden ser de cualquier tipo de dato. '
continuacin veremos con ms detalle cmo se usan los arreglos cuando
sus elementos son registros%
var
v : vector X111Y registro
3
a* b : numerico
5
&or lo tanto, para asignar un valor al campo " del tercer elemento del
vector v se usar%
v XDY.b 0 DG
' continuacin vemos cmo puede definirse un vector en el que cada
elemento guarde datos generales de un alumno (nom"re y n#mero de
cdula) y sus notas para cierta asignatura. La cantidad de alumnos por
curso no es fijo%
'4
var
A : vector X*Y registro
3
nombre : cadenaB
cedula : numerico
notas : vector X*Y numerico
5
Luego podemos inicializar el vector ', por ejemplo, para -> alumnos%
dim &A* 2G)
&odemos tam"in, por ejemplo, inicializar el vector ' con los datos para
, alumnos%
A 0 3 3+;irta/* 12FH1HS1* 3FH* ST* 11155* // alumno no. 1
3+#ose/* 1E2F1HED* 3S1* TH* HD5 5* // alumno no. 2
3+Luisa/* 1D2DHF1D* 3T1* F2* FH5 5
5
...
.antidad de elementos de un arreglo abiertoK
Uso de la 2uncin alenGH
&ara o"tener la cantidad de elementos de un arreglo podemos usar la funcin
predefinida alen(), que opera tanto so"re arreglos a"iertos como so"re los
que tienen tamao fijo.
$l siguiente programa hace uso de alen() para recorrer dos vectores%
programa uso_alen
var
v1 : vector X11Y numerico
v2 : vector X*Y numerico
var
k : numerico
inicio
desde k01 hasta alen &P1)
3
P1 XkY 0 1
5
'5
dim &P2* 1G)
desde k01 hasta alen &P2)
3
P2 XkY 0 1
5
fin
La funcin alen*+ retorna 0 cuando el arreglo a#ierto no fue iniciali)ado a/n.
''
Operaciones con cadenas
+omo ya hemos visto, una de las operaciones "sicas con cadenas es la
concatenacin. $isten adems otras operaciones y funciones aplica"les a
ellas que son de utilidad en muchas aplicaciones. Las principales son el
acceso a los caracteres y las conversiones de tipos de datos.
Longitud de una cadenaK la 2uncin strlenGH
La longitud de una cadena puede determinarse con la funcin predefinida
strlen(). &or ejemplo,
var
s : cadena
% : numerico
inicio
s 0 +prueba/
% 0 strlen &s)
imprimir &+,n/* %)
imprimir &+,nLon%itud de cadena vacia es /* strlen &+/))
fin
imprimir
T
Lon%itud de cadena vacia es 1
',
Ca pG t ul o
9
Acceso a los caracteres de una cadena
Bna cadena puede utilizarse como si fuese un vector% cada elemento es un
carcter y puede ser referenciado por su posicin dentro del conjunto. $l
siguiente programa imprime los d!gitos del .=0 al .A0.
/*
!M#6OP!: ;ostrar en la pantalla los di%itos del ISJ al I1J &es decir*
en orden inverso) cada uno en una linea independiente.
AU!": 'se%ovia
a6CZA: 1SAdicA1SSS
*/
var
di% : cadena
k : numerico
inicio
di% 0 +112DEGTFHS/
desde k0strlen &di%) Qasta 1 paso \1
3
imprimir &+,n/* di% XkY)
5
fin
$ diferencia de los vectores, solicitar un car!cter que no e0iste *por ejemplo,
pedir el que est! en la posicin cero+ simplemente retorna la cadena vaca " no
genera error de ejecucin.
Lodi2icacin de caracteres de una cadena
Los caracteres de una cadena pueden ser tam"in modificados, es decir,
pueden ser usados a la izquierda de una asignacin. $l siguiente ejemplo
reemplaza todas las letras .a0 de una cadena por la letra ."0.
/*
!M#6OP!: "eemplazar todas las letras IaJ de una cadena por la por letra
IbJ.
AU!": 'se%ovia
*/
var
z : cadena
inicio
z 0 +6sta es una prueba/
desde k01 hasta strlen &z)
3
si & z XkY 00 IaJ )
3
z XkY 0 IbJ
'-
5
5
imprimir &+,n/* z)
fin
$l programa imprime
6stb es unb pruebb
$ diferencia de los vectores, la solicitud de asignacin a una posicin que no
e0iste *por ejemplo, el que est! en la posicin 21 cuando la cadena tiene solo 20
caracteres+ es completamente ignorada " no genera error de ejecucin.
Subcadenas
&ara tomar (copiar) una su"cadena podemos usar la funcin predefinida
su"str(), que tiene el siguiente formato%
subrutina substr &z : cadenaB p:inicial* cant : numerico) retorna cadena
donde
z : cadena 9ue proveerC los caracteres para la subcadena.
p:inicial : posici?n del primer carCcter 9ue se extraerC.
cant : cantidad de caracteres a tomar. 6ste parCmetro puede omitirse*
en cuyo caso se toman todos los caracteres desde el inicial
Qasta el .inal de z.
+adena z queda inalterada.
Si pKinicial es mayor a la longitud de la cadena, su"str() retorna una
cadena vac!a.
$l siguiente programa imprime%
1
2D
EGT
FHSA
MC86a
/*
!M#6OP!: ;ostrar el uso de subcadenas.
AU!": 'se%ovia
*/
var
z* subcad : cadena
%* k* p : numerico
'.
inicio
z 0 +12DEGTFHSAMC86a/
% 0 strlen &z)
p 0 1
k 0 1
mientras &p [ % )
3
subcad 0 substr &z* p* k)
imprimir &+,n/* subcad)
p 0 p 4 k
k 0 k 4 1
5
fin
.onversin a numFricoK la 2uncin valGH
$l valor numrico de una cadena puede o"tenerse usando la funcin
predefinida val(), toda vez que dicha cadena contenga la secuencia vlida de
caracteres para un n#mero.
$jemplo%
var
n : numerico
z : cadena
inicio
z 0 +D11/
n 0 val &z) 4 val &substr &+E1G/* 2* 1)) // n valdrC D11
...
La funcin val() retorna cero cuando reci"e una cadena que no puede
convertirse en n#mero.
,/
Subrutinas
Las su"rutinas son un componente fundamental de programacin% ellas
permiten que un pro"lema complejo sea dividido en partes ms pequeas,
comprensi"les y maneja"les. &odemos conceptualizarla como un completo
su"programa (programa ms pequeo) porque ella no solo agrupa y da un
nom"re a un conjunto de sentencias lgicamente relacionadas, sino que
adems puede tener sus propias varia"les, constantes y otros elementos.
$n SL las su"rutinas se escri"en a continuacin del programa principal. La
invocacin de una su"rutina se realiza escri"iendo su nom"re en los puntos
del programa donde su accin sea requerida.
5ependiendo de su funcin dentro del programa, eisten dos tipos de
su"rutinas% los procedimientos y las funciones. 'm"as veremos con ms en
detalle en este cap!tulo.
,1
Ca pG t ul o
1=
Mmbito de los identi2icadores
5ecimos que un identificador es global si fue declarado al inicio del programa
principal. $n cam"io, decimos que es local si fue declarado dentro de alguna
su"rutina o es un parmetro formal (Fer ms adelante el apartado C&aso de
parmetrosD).
La importancia de esta distincin radica en que%
los identificadores locales solo pueden ser utilizados (solo estn Cvisi"lesD)
dentro de la su"rutina que contiene su definicin.
los identificadores glo"ales pueden ser utilizados en cualquier parte del
programa.
+orresponden al primer grupo (glo"al) los que son declarados al inicio del
programa principal, tal como se muestra en C$structura general de un
programa en SLD.
Los considerados identificadores locales son aquellos que son declarados
dentro de su"rutinas o utilizados como parmetros formales de stas y solo
pueden ser utilizados dentro de dichas su"rutinas, a diferencia de los
glo"ales, que pueden ser utilizados en cualquier parte del programa.
Si un identificador es declarado o forma parte de los parmetros formales de
una su"rutina y su nom"re coincide con el de otro identificador declarado
glo"almente, ste #ltimo queda temporalmente inaccesi"le durante la
ejecucin de la su"rutina.
La eistencia de identificadores locales posi"ilita%
que dos identificadores puedan ser definidos con el mismo nom"re, pero
cada uno teniendo propiedades independientes% direccin de memoria,
tipo, duracin (constante, varia"le).
mejorar la legi"ilidad de las su"rutinas y fortalecer su independencia del
conteto.
,2
la escritura de su"rutinas recursivas.
$l programa que sigue muestra en la pantalla lo que sigue%
1 2 D E G
111
Zola
La primera l!nea (1 - , L >) es impresa por la su"rutina su"K1()/ la segunda
(1AA) es generada por el programa principal mientras que la tercera (8ola)
imprime la su"rutina su"K-(). +omo puede apreciarse, el valor de la varia"le
glo"al n no fue afectada por la varia"le local n de la su"rutina su"K1() pues el
compilador les asigna espacios de memoria distintos.
:ipos de subrutinas
SL soporta dos tipos de su"rutinas%
@unciones% son las que retornan un valor y pueden utilizarse como
operandos en epresiones.
,3
Su#rutinas
)*
E+em,lo de u-o de
-ubrutina-(
*
var
n . numerico
inicio
n = 100
-ub/101
im,rimir 0n1
-ub/2 023ola41
fin
subrutina -ub/101
var
n . numerico
inicio
desde n=1 hasta #
{
im,rimir 0n, 2 21
!
fin
subrutina -ub/20n . cadena1
inicio
im,rimir 025n4, n1
fin
2rograma
principal
varia#le glo#al
varia#le local
par4metro
&rocedimientos% las que no retornan un valor, y por lo tanto no pueden
usarse como parte de epresiones.
' continuacin analizamos por separado estas dos formas de su"rutinas.
"uncionesK Subrutinas 6ue retornan valor
Bna funcin es una su"rutina que produce un valor que puede ser
utilizado por la parte del programa que la llam.
$l valor producido y retornado por la funcin puede ser de cualquier tipo%
cadena, numrico, lgico, arreglos con cualquier dimensin y elementos,
registros, etc.
+omo ejemplo, a continuacin tenemos un sencillo programa que incluye
una su"rutina para o"tener la parte entera de un n#mero positivo.
/*
!M#6OP!: !btener la parte entera de un nmero real. -ara el e.ecto
se implementa la .unci?n entero&).
AU!": 'se%ovia
*/
var
x : numerico
inicio
x 0 entero &1G.2D) // x vale 1G
imprimir &x)
x 0 entero &x * 1.G) 4 entero &x) // x vale 22
imprimir &x)
imprimir & entero &1S.EG) ) // imprime 1S
fin
subrutina entero &n : numerico) retorna numerico
/*
!M#6OP!:
Calcular la parte entera de un numero positivo.
$e usa el m^todo de las restas sucesivas.
-A"A;6"!:
n : nmero del 9ue se 9uiere obtener su parte entera.
*/
,4
var
ent : numerico
inicio
ent 0 1
mientras & n `0 1 )
3
ent 0 ent 4 1
n 0 n A 1
5
retorna & ent )
fin
El valor de retorno de una funcin puede ser descartado. 'omo ejemplo vea la
funcin predefinida inc*+.
ProcedimientosK subrutinas 6ue no retornan valor
Bn ejemplo de su"rutina que no retorna valor puede encontrarse en el
!tem CSentencia de llamada a su"rutinasD.
!e2inicin de parJmetros 2ormales
Llamamos parmetros formales a los identificadores que u"icamos al inicio
de una su"rutina para indicar la cantidad y tipo de cada uno de los datos
que la su"rutina reci"e. $n la siguiente definicin
subrutina max:comun:div &a* b : numerico) retorna numerico
a y " son los parmetros formales, am"os numricos en este caso.
La sintais para la definicin de parmetros formales es similar la
declaracin de varia"les.
La siguiente podr!a ser la definicin de una su"rutina que inserta espacios
en una l!nea de tal forma que toda ella ocupe eactamente cierta cantidad
de caracteres%
subrutina a'ustar &linea : cadenaB ancQo : numerico) retorna cadena
,5
Paso de parJmetros
$isten dos formas de pasar parmetros% por valor y por referencia.
'm"os veremos a continuacin.
$or valor
La epresin que se pasa como parmetro es copiada como valor inicial
de la varia"le correspondiente en la lista de parmetros formales de la
su"rutina.
Lo que caracteriza al paso de parmetros por valor es que los cam"ios que
se hagan a la varia"le que reci"e el parmetro no se ven reflejados en el
programa que llama a la su"rutina.
' continuacin un ejemplo%
/*
!M#6OP!: ;ostrar el paso de parCmetros por valor.
AU!": 'se%ovia
*/
var
a* b : numerico
inicio
a 0 1B b 0 11
mi:sub &a* b)
imprimir &+,n/* a* c c* b)
mi:sub &a*11* bA1)
fin
subrutina mi:sub &a* b : numerico)
inicio
a 0 G
b 0 b * G
imprimir & +,n/* a* c c* b)
fin
$l programa anterior imprime%
G G1
1 11
G EG
,'
G"srvese que los cam"ios que se hicieron a las varia"les locales a y ",
parmetros formales de la su"rutina miKsu"(), no afectaron a las varia"les
glo"ales con el mismo nom"re.
$or re3erencia
+uando una varia"le se pasa por referencia, lo que en realidad se reci"e en
la su"rutina es la direccin de memoria de la varia"le original. &or ello,
cualquier cam"io que se haga al parmetro, se ve reflejado en la varia"le
original.
' continuacin un ejemplo%
/*
!M#6OP!: ;ostrar el paso de parCmetros por re.erencia.
AU!": 'se%ovia
*/
var
a* b : numerico
inicio
a 0 1B b 0 11
mi:sub &a* b)
imprimir &+,n/* a* I I* b)
mi:sub &a*11* b)
fin
subrutina mi:sub &a : numericoB ref b : numerico)
/*
a se recibe por valor* pero b por re.erencia.
*/
inicio
a 0 G
b 0 b * G
imprimir & +,n/* a* I I* b)
fin
$l programa anterior imprime%
G G1
1 G1
G 2G1
,,
G"srvese que al cam"iar el valor de la varia"le " en miKsu"(), tam"in
cam"i el valor de " en el programa principal.
Ejemplo
$l siguiente programa muestra el uso del concepto del paso de parmetros
por referencia para escri"ir una rutina general para intercam"iar el contenido
de dos varia"les numricas.
/*
!M#6OP!: ;ostrar el uso de los parCmetros por re.erencia* implementando
una subrutina 9ue intercambia el contenido de dos
variables num^ricas.
AU!": 'se%ovia
*/
var
a* b : numerico
inicio
a 0 11B b 0 21
intercambiar:num &a* b)
imprimir &a*I I* b) // imprimira 21 11
fin
subrutina intercambiar:num &ref primera:var* se%unda:var : numerico)
var
aux : numerico
inicio
aux 0 primera:var
primera:var 0 se%unda:var
se%unda:var 0 aux
fin
+omo puede o"servarse, el nom"re de la varia"le que reci"e el dato que se
pasa como parmetro no tiene porqu coincidir con el nom"re la varia"le
que se pasa como parmetro.
Subrutinas 8 arreglos abiertos
$l siguiente programa muestra el uso de arreglos a"iertos como
parmetros de su"rutinas%
,-
$rimer ejemplo
/*
!M#6OP!: ;ostrar el uso de arre%los abiertos como parCmetros de subrutinas.
AU!": 'se%ovia
*/
var
A : vector XGY numerico
M : vector X*Y numerico
inicio
A 0 31* 2* D* G* F5
M 0 A
impr:vect &A)
impr:vect &M)
impr:vect &3111* 211* D115)
fin
subrutina impr:vect &v : vector X*Y numerico)
var
k : numerico
inicio
desde k01 hasta alen &v)
3
imprimir &v XkY* + +)
5
fin
Se%undo ejemplo
$l siguiente programa desarrolla una su"rutina que produce la transpuesta de
una matriz dada. ' continuacin se muestra lo que produce%
;atriz ori%inal
11 11 12
21 21 22
D1 D1 D2
E1 E1 E2
G1 G1 G2
;atriz traspuesta
11 21 D1 E1 G1
11 21 D1 E1 G1
12 22 D2 E2 G2
/*
!M#6OP!: ;ostrar el uso de arre%los abiertos a trav^s de una .unci?n de
9ue calcula la traspuesta de una matriz.
AU!": 'se%ovia
*/
,.
var
A * : matriz X***Y numerico
.* c : numerico
inicio
A 0 3311* 11* 125*
321* 21* 225*
3D1* D1* D25*
3E1* E1* E25*
3G1* G1* G25
5
imprimir &R,n;atriz ori%inal,nR)
impr:mat &A)
0 trasp &A)
imprimir &R,n;atriz traspuesta,nR)
impr:mat &)
fin
subrutina trasp &m : matriz X***Y numerico) retorna matriz X***Y numerico
/*
!M#6OP!: -roducir la traspuesta de la matriz m.

$e asume 9ue m tiene i%ual cantidad de columnas en todas sus .ilas*
es decir* tiene +contorno/ re%ular.
*/
var
t : matriz X***Y numerico
c.* cc : numerico // cantidad de .ilas y columnas de m
k.* kc : numerico // indice de .ila y columna
inicio
c. 0 alen &m X1Y)
cc 0 alen &m)
dim &t* c.* cc)
desde k.01 hasta c.
3
desde kc01 hasta cc
3
t Xk.* kcY 0 m Xkc* k.Y
5
5
retorna & t )
fin
-/
subrutina impr:mat &m : matriz X***Y numerico)
var
.* c : numerico
inicio
desde .01 hasta alen &m)
3
desde c01 hasta alen &mX.Y)
3
imprimir &m X.* cY* N N)
5
imprimir &R,nR)
5
fin
-1
-2
"e3inicin de nombres de tipos de datos
SL proporciona un mecanismo para crear nuevos nom"res de tipos de
datos. &or ejemplo, el siguiente fragmento define un tipo de dato
C&:G5B+7GD y declara algunas varia"les de este tipo%
tipos
-"!8UC! : registro
3
codi%o : numerico
descrip : cadena
precio : numerico
5
var
monitor* teclado : -"!8UC!
lista:prod : vector X*Y -"!8UC!
$s decir, una vez definido el nom"re &:G5B+7G, podemos usarlo en
cualquier conteto donde SL requiera un tipo de dato.
Los nom"res de tipos de datos definidos por el programador pueden ser
#tiles para clarificar y3o simplificar los programas y facilitar su posterior
mantenimiento.
-3
Ca pG t ul o
11
Las reglas para nom#rar tipos de datos son las mismas "a vistas para varia#les,
constantes " dem!s identificadores.
!e2inicin de alias
$l mecanismo de definicin de nom"res de tipos de datos puede ser
utilizado para introducir alias a nom"res de tipos ya eistentes. &or
ejemplo, podemos definir
tipos
Lineaexto : cadena
y luego
var
primera:linea* se%unda:linea : Lineaexto
en cuyo caso am"as varia"les son en realidad cadenas, y por lo tanto
podrn usarse li"remente en todo conteto donde se espere una cadena.
Eemplos
' continuacin veremos dos ejemplos que hacen uso de la definicin de
nom"res de tipos de datos.
$rimer ejemplo
$l o"jetivo del siguiente programa es leer los nom"res y las notas de los
alumnos de cierta asignatura e imprimir una lista ordenada por las notas,
de mayor puntaje a menor puntaje. La cantidad de alumnos de"e ser
ingresada por el usuario.
$l programa define un tipo llamado C'LB49GD que agrupa en un
registro el nom"re y la nota de cada alumno. 5efine tam"in el tipo de
dato C'+7'D, que es un vector a"ierto de C'LB49GD.
' continuacin el programa completo. G"servemos especialmente los
puntos indicados con recuadros.
-4
programa uso:de:nuevos:tipos:1
tipos
ALU;=! : registro
3
nombre : cadena
nota : numerico
5
ACA : vector X*Y ALU;=!
var
A : ACA
inicio
leer:acta &A)
ordenar:por:nota &A)
imprimir:acta &A)
fin
subrutina imprimir:acta &A : CLA$6)
/*
Omprimir el nombre y la nota de cada alumno.
*/
var
k : numerico
inicio
desde k01 hasta alen &A)
3
imprimir &R,nR* A XkY.nombre* R,tR* A XkY.nota)
5
fin
subrutina leer:acta &ref c : ACA)
/*
Leer los nombres y notas de los alumnos.
-rimero pide cantidad de alumnos e inicializa el vector de
acuerdo a esto.
!bservar 9ue c 86M6 ser recibido por re.erencia* pues de
lo contrario los datos leidos se perderan al salir de la subrutina.
*/
var
cant* k : numerico
inicio
imprimir &+,nOn%rese cantidad de alumnos: /)
leer &cant)
dim &c* cant)
-5
imprimir &+,nA continuacion tipee nombre* nota para cada alumno,n/)
desde k01 hasta cant
3
leer & c XkY.nombre* c XkY.nota )
5
fin
subrutina ordenar:por:nota &ref A : ACA)
/*
!rdernar A* considerando las notas* de mayor a menor. 6l
al%oritmo es el de la burbu'a.
6l parametro A 86M6 ser recibido por re.erencia* pues de
lo contrario los datos leidos se perderan al salir de la subrutina.
;uestra el uso de asi%nacion entre re%istros &variable aux).
*/
var
aux : ALU;=!
k* n : numerico
% : numerico // lon%itud de A
inicio
% 0 alen &A)
desde n01 hasta &% \ 1)
3
desde k0n41 hasta %
3
si & A XnY.nota [ A XkY.nota )
3
aux 0 A XnY
A XnY 0 A XkY
A XkY 0 aux
5
5
5
fin
Se%undo ejemplo
$l siguiente programa imprime el d!a de la semana que corresponde a una
fecha dada. 5efine un nom"re de tipo de dato C@$+8'D.
/*
!M#6OP!: ;ostrar el uso de tipos de.inidos por el usuario.
AU!": 'se%ovia
*/
-'
tipos
a6CZA : registro
3
d* m* a : numerico
5
var
. : a6CZA
inicio
imprimir &R,nR* strdup &RAR* FS))
imprimir &R,n6ste pro%rama calcula el dia de la semana 9ue corresponde /*
+a una .ecQa,nR)
.0leer:.ecQa &R,nOn%rese una .ecQa &dd*mm*aaaa):R)
si & .ecQa:valida &.) )
3
imprimir &R,n8ia0R* nombre:dia:sem &calc:dia:sem &.)))
sino
imprimir &R,naecQa in%resada no es valida,nR)
5
fin
subrutina leer:.ecQa &ms% : cadena) retorna a6CZA
var
. : a6CZA
inicio
imprimir &ms%)
leer &..d* ..m* ..a)
retorna &.)
fin

subrutina .ecQa:valida &. : a6CZA) retorna lo%ico
var
mal : lo%ico
inicio
mal 0 &..a [ 1) or &..m [ 1 or ..m ` 12) or &..d [ 1 or ..d ` D1)

si & not mal )
3
si & ..m 00 2 )
3
mal 0 ..d ` 2H and not bisiesto &..a)
sino
mal 0 &..m 00 E or ..m 00 T or ..m 00 S or ..m 00 11) and ..m ` D1
5
5
retorna & not mal )
fin
-,
subrutina calc:dia:sem &. : a6CZA) retorna numerico
var
d* m* y1* y2 : numerico
inicio
si & ..m [ D )
3
m 0 ..m 4 11B
..a 0 ..a A 1
sino
m 0 ..m A 2B
5
y1 0 int &..a / 111)B
y2 0 ..a ] 111B
d 0 int & &
..d 4 int &2.T*m A 1.1) 4 y2 4 int &y2 / E)
4 int &y1 / E) A 2*y1 4 ES
) ] F
) 4 1B

retorna &d)
fin
subrutina bisiesto &a : numerico) retorna lo%ico
inicio
retorna &a ] E 00 1) and not &&a ] 111 00 1) or &a ] E11 00 1))
fin
subrutina nombre:dia:sem &d : numerico) retorna cadena
var
dsem : vector XHY cadena
inicio
dsem 0 3+domin%o/* +lunes/* +martes/* +mi^rcoles/* +'ueves/*
+viernes/* +sCbado/* +**invClido**/ 5
si & d [ 1 or d ` F )
3
d 0 H
5
retorna & dsem XdY )
fin
--
Ane,o A7 Ejemplos Selectos
Serie de "ibonacci
Emprime los primeros n trminos de la serie de @i"onacci. $l valor de n es
prove!do por el usuario.
programa .ibo
var
a* b* c : numerico
n : numericoB
inicio
leer &n)B
a 0 1B b 0 1B
si & n `0 1 )
3
imprimir &R,nR* a)B
5
si & n `0 2 )
3
imprimir &R,nR* b)B
5
n 0 n A 2B
mientras & n `0 1 )
3
c 0 a 4 bB
imprimir &R,nR* c)B
a 0 bB
b 0 cB
n 0 n A 1B
5
fin
.onversin de decimal a binario (usando restas sucesivas)
5ado un n#mero entero positivo en "ase 1A, imprimirlo en "ase -.
$l algoritmo calcula el residuo de la divisin entera usando restas sucesivas.
$l n#mero a convertir es prove!do por el usuario.
-.
programa conv:bin
var
n8ec* nMin* pot* resto* cociente : numerico
inicio
nMin 0 1
pot 0 1
imprimir &R,nOn%rese un numero decimal:R)
leer &n8ec)
mientras & n8ec ` 1 )
3
cociente 0 1
resto 0 n8ec
mientras & resto ` 2 )
3
resto 0 resto A 2
cociente 0 cociente 4 1
5
n8ec 0 cociente
si & resto 00 1 )
3
nMin 0 nMin 4 11Upot
5
pot 0 pot 4 1
5
imprimir &nMin)
fin
.onversin a heEadecimal
5ado un n#mero entero positivo en "ase 1A, imprimirlo en "ase
headecimal. La implementacin es particularmente interesante porque
utiliza constantes locales, funciones, acceso directo a caracteres de cadenas y
operador de mdulo.
var
n : numerico
Q : cadena
sl : numerico
inicio
imprimir &R,nOn%rese un numero entero positivo:R)
leer &n)
imprimir &R,nR* n* R en Qex es R* dec:a:Qex &n))
fin
./
subrutina dec:a:Qex &n : numerico) retorna cadena
const
Z6<:8OW 0 R112DEGTFHSAMC86aR
var
s : cadena
r : numerico
inicio
mientras & n `0 1T )
3
r 0 n ] 1T
s 0 Z6<:8OW Xr41Y 4 s
n 0 int &n / 1T )
5
s 0 Z6<:8OW Xn41Y 4 s
retorna & s )
fin
:abla AS.11
Emprimir la ta"la 'S+EE para los caracteres u"icados desde la posicin ,- en
adelante.
$l programa utiliza la funcin ascii() para generar los caracteres.
const
inicio:tabla 0 D2B
.in:tabla 0 2GG
O=C" 0 1T
"6LL6=! 0 N N
var
k* tope : numerico
inicio
k 0 inicio:tabla
cls&)
repetir
tope 0 k 4 O=C"
si & tope ` .in:tabla )
3
tope 0 .in:tabla
5
prt:ascii &k* tope* "6LL6=!)B
imprimir &R,nR)
k 0 tope 4 1
hasta & tope 00 .in:tabla )
fin
.1
subrutina prt:ascii &v1* v2 : numericoB r : cadena)
var
k : numerico
inicio
desde k0v1 hasta v2
3
imprimir & ascii &k)* r)
5
fin
;Nmeros Primos
Emprimir todos los n#meros primos comprendidos entre 1 y un n#mero
dado.
Se utiliza un vector de valores lgicos para ir CtachandoD los no primos.
programa =umeros-rimos
const
ACZA8! 0 "U6
=!:ACZA8! 0 aAL$6
tipos
P6C:-"O;!$ : vector X*Y lo%ico
var
= : numerico
- : P6C:-"O;!$
inicio
imprimir &R,n000 CALCUL! 86 =U;6"!$ -"O;!$ 000R)
si & pcount&) [ 1 )
3
imprimir &R,nOn%rese ltimo nmero entero a evaluar: R)B
leer &=)
sino
= 0 val &paramval &1))
5
si & int &=) [` = )
3
imprimir &R,n6l numero in%resado debe ser enteroR)
sino
dim &-* =)
calc:primos &-* =)
imprimir &R,nR)
imprimir:primos &-)
5
fin
.2
subrutina calc:primos &re. - : P6C:-"O;!$B = : numerico)
var
k* n : numerico
inicio
desde k 0 1 hasta =
3
- XkY 0 =!:ACZA8!
5
n 0 2
mientras & n 4 n [ = )
3
desde k 0 n 4 n Qasta = paso n
3
- XkY 0 ACZA8!
5
n 0 n 4 1
mientras & n [0 = and - XnY )
3
n 0 n 4 1
5
5
fin
subrutina imprimir:primos &v : P6C:-"O;!$)
var
k : numerico
inicio
desde k 0 2 Qasta alen &v)
3
si & v XkY 00 =!:ACZA8!)
3
imprimir &str &k* G* 1) )
5
5
fin
Lovimientos del al2il en un tablero de aedrez
Bsando una matriz, genera e imprime los posi"les movimientos de un alfil a
partir de la fila y columna iniciales prove!das por el usuario.
programa al.il
const
A;:AM 0 H
var
.:inic* c:inic : numerico
: vector XA;:AM*A;:AMY cadena
.3
var
k : numerico
inicio
imprimir&R,nOn%rese .ila y columna donde se encuentra el al.il:R)
leer &.:inic* c:inic)

0 3 3N.N* ...5*
...
5
X.:inic* c:inicY 0 NAN
k 0 1

mientras & k [0 A;:AM )
3
marcar &.:inic A k* c:inic A k)
marcar &.:inic A k* c:inic 4 k)
marcar &.:inic 4 k* c:inic A k)
marcar &.:inic 4 k* c:inic 4 k)
k 0 k 4 1
5
impr:tablero&)
fin
subrutina marcar &.* c : numerico)
inicio
si & &. ` 1 and . [0 A;:AM) and
&c ` 1 and c [0 A;:AM)
)
3
X.* cY 0 N-N
5
fin
subrutina impr:tablero&)
var
.* c : numerico
inicio
desde . 0 1 hasta A;:AM
3
imprimir &R,nR)
desde c 0 1 hasta A;:AM
3
imprimir & X.* cY* N N)
5
5
fin
.4
Latriz con valores en caracol
+ompletar una matriz como se muestra a continuacin%
1 - , L >
1- 1, 1L 1> H
11 1A = ? N
&ara recorrer la matriz usamos un indicador de direccin como se indica a
continuacin%
AAAAAA &1) AAA`
U d
d d
E) &2)
d d
d v
[AAAAA&D)AAAAA
programa caracol
const
;A<:aOL 0 D
;A<:C!L 0 G
var
mat : vector X;A<:aOL* ;A<:C!LY numerico
k* dir : numerico
mincol* maxcol : numerico
min.il* max.il : numerico
.il* col : numerico
inicio
min.il 0 1
mincol 0 1
maxcol 0 ;A<:C!L
max.il 0 ;A<:aOL
col 0 1B .il 0 1B dir 0 1
desde k01 hasta ;A<:aOL*;A<:C!L
3
mat X.il* colY 0 k
eval
3
caso & dir 00 1 )
inc &col)
si & col 00 maxcol )
3
dir 0 2
.5
inc &min.il)
5
caso & dir 00 2 )
inc &.il)
si & .il 00 max.il )
3
dir 0 D
dec &maxcol)
5
caso & dir 00 D )
dec &col)
si & col 00 mincol )
3
dir 0 E
dec &max.il)
5
caso & dir 00 E )
dec &.il)
si & .il 00 min.il )
3
dir 0 1
inc &mincol)
5
5
5
imprimir:matriz&)
fin
subrutina imprimir:matriz&)
var
.* c : numerico
inicio
cls&)
desde .01 hasta ;A<:aOL
3
imprimir &R,nR)
desde c01 hasta ;A<:C!L
3
imprimir &str &mat X.*cY* E* 1))
5
5
fin
.orte de control
Los alumnos de un curso li"re de ingls tienen sus notas (parciales y finales)
consignadas en registros de la sgte. manera%
.'
=ro. de Alumno* Codi%o &1Aparcial* 2Aainal)* -unta'e &1A111)
Los registros estn ordenados por nro. de alumno. La cantidad de parciales
que dieron var!a de un alumno a otro.
Las notas parciales y la final vienen en cualquier orden, ya sean primero las
parciales y luego la final o mezcladas. $iste un solo registro que contiene la
nota final.
G"s.% Los puntos se calcularn de la sgte. forma%
&untos R (LAZ promedio de los parciales) O (HAZ de eamen final).
La nota final se calcula de la sgte. manera%
de 1 a ES] 0 1
G1 a T1] 0 2
T1 a FG] 0 D
FT a SE] 0 E
SG a 111] 0 G
Se desea un programa que imprima%
a) la sgte. planilla%
=ro. Alumno -rom.-arc. 6xam.ainal -untos =ota ainal
AAAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAA AAAAAAAAAA
SSS SSS SSS SSS SSS
") $l numero del Umejor alumnoU.
$l mejor alumno se considera a aquel que hizo NAZ o ms en todos
los parciales y el final.
Si hay ms de uno, tomar el #ltimo.
.,
$jemplo%
=ro. de Alumno A Codi%o A -unta'e
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
1 1 H1
1 2 F1
1 1 S1
2 2 111
2 1 EG
2 1 E1
2 1 S1
S D 111
&lanilla a imprimir%
1 HG F1 FT E
2 GH.DD 111 HD.DD E
programa notas:.inales
var
nroAlu*
codi%o*
punta'e : numerico
%=roAlu*
suma-arc*
cant-arc*
punt6xaainal : numerico
inicio
leer & nroAlu* codi%o* punta'e )
%=roAlu 0 nroAlu
suma-arc 0 1
cant-arc 0 1
mientras & codi%o [` D )
3
si & %=roAlu [` nroAlu )
3
corte&)
5
.-
proceso&)
leer & nroAlu* codi%o* punta'e )
5
corte&)
fin
subrutina proceso&)
inicio
si & codi%o 00 1 )
3
suma-arc 0 suma-arc 4 punta'e
cant-arc 0 cant-arc 4 1
sino
punt6xaainal 0 punta'e
5
fin
subrutina corte&)
var
puntos* notaainal : numerico
inicio
puntos 0 calc:puntos&)
notaainal 0 calc:nota:.inal &puntos)
imprimir &R,n=ro. Alumno -rom.-arc. 6xam.ainal -untos/*
+ =ota ainalR)
imprimir &R,nAAAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAA/*
+ AAAAAAAAAAR)
imprimir &R,nR* %=roAlu* R R* &suma-arc/cant-arc)* R R* punt6xaainal*
R R* puntos* R R* notaainal
)
primer"e%&)
fin
subrutina calc:puntos&) retorna numerico
var
prom-arc* puntos : numerico
inicio
prom-arc 0 suma-arc / cant-arc
puntos 0 &prom-arc * E1 / 111) 4 &punt6xaainal * T1 / 111)
retorna &puntos)
fin
..
subrutina calc:nota:.inal &puntos : numerico) retorna numerico
var
nota : numerico
inicio
si & puntos `0 SG )
3
nota 0 G
sino si & puntos `0 FT )
nota 0 E
sino si & puntos `0 T1 )
nota 0 D
sino si & puntos `0 G1 )
nota 0 2
sino
nota 0 1
5
retorna &nota)
fin
.LLK 1ntFrprete para un lenguae sencillo
+4L es un intrprete para un lenguaje sencillo, con sintais vagamente similar a
&ascal. Se desarroll en SL con el o"jetivo de mostrar a alumnos de un curso
introductorio de compiladores las tcnicas para el anlisis sintctico
descendente recursivo.
$l UcdigoU generado es para una mquina de pila. Bn listado del cdigo
generado, en formato sim"lico, puede o"tenerse pasando *d como primer
parmetro del programa.
Ejemplo de uso de !ML
Lo que sigue es un ejemplo de un pequeo programa escrito en +4L. &odemos
pro"arse el funcionamiento de nuestro intrprete gra"ando el programa fuente
en un archivo llamado fi"o.cml, que luego ser prove!do a +4L como entrada.
1//
AA -ro%rama escrito en el pe9ue>o len%ua'e C;L.
AA Omprime los primeros n numeros de la serie de aibonacci
AA Observar que esto no es SL!
var
a01* b01* cB
n01B
be%in
read nB
i. & n `0 1 )
3
print aB
5
i. & n `0 2 )
3
print bB
5
n 0 n A 2B
eQile & n `0 1 ) 3
c 0 a4bB
print cB
a0bB b0cB
n 0 n A 1B
5
end
igura 4! Serie de i#onacci7 implementado en C(L
!aracter+sticas de !ML
' continuacin damos un panorama general de +4L.
Declaracin de variables
Las varia"les de"en ser declaradas antes de su uso. Siempre son numricas. 'l
momento de declararlas se puede indicar un valor inicial, que impl!citamente es
A.
Cuerpo del programa
Las sentencias ejecuta"les del programa van entre el par C"eginD..DendD.
Sentencias
Las sentencias de +4L son%
de entrada3salida% read y print. Solo pueden imprimirse valores numricos.
condicional% if, la condicin epresada entre parntesis.
ciclo% <hile, la condicin de permanencia epresada entre parntesis.
1/1
asignacin% tiene la forma Cnom"reKvaria"le R epresinD.
Expresiones
Los operadores disponi"les son%
aritmticos% suma (O), resta (*), multiplicacin (I), divisin (3), cam"io de
signo (*).
relacionales% mayor (T), mayor o igual (TR), menor (S), menor o igual (SR),
igual (RR), distinto (ST).
La precedencia de estos operadores es la usual. &ueden usarse parntesis para
especificar un orden de evaluacin particular.
$ro%rama 3uente del int>rprete
// X00000000000000000000000000000000000000000000000000000000000000000000Y
// X 6lementos para el analisis lexico%ra.ico Y
// X00000000000000000000000000000000000000000000000000000000000000000000Y
// &c) #uan $e%ovia $ilvero &'se%ovia(cnc.una.py)
tipos
L6<6;A : numerico
var
tk : L6<6;A // s%te. lexema 9ue debe ser analizado
lt : cadena // linea del texto analizado
llt: numerico // lon%itud de lt
up : numerico // ultima posicion leida dentro de lt
var
val:num : numerico // valor numerico de la constante leida
val:time : lo%ico
subcad : cadena // el componente lexico en .orma de cadena.
// 6'emplo:
// var
// a* totalB
// tendra RaR* lue%o la s%te. vez RtotalR.
tipos
O=a!:-AL:"6$6"P : registro
3
pal : cadena // Ri.R* ReQileR* etc.
lex : L6<6;A // su valor numerico simbolico
5
1/2
var
pal:reserv : vector X*Y O=a!:-AL:"6$6"P
const
$:C!=$:=U; 0 1
$:=!;M"6:PA" 0 2
$:;6=!$ 0 111
$:;A$ 0 111
$:;UL 0 112
$:8OP 0 11D
$:-A"6=:O 0 111
$:-A"6=:8 0 111
$:LLAP6:O 0 112
$:LLAP6:8 0 11D
$:;6=!" 0 121
$:;6=!":OWUAL 0 121
$:;Af!" 0 122
$:;Af!":OWUAL 0 12D
$:OWUAL 0 12E
$:8O$O=! 0 12G
$:A$OW=ACO!= 0 1D1
$:C!;A 0 1D1
$:-U=!:f:C!;A 0 1D2
":PA" 0 211
":O=OCO! 0 211
":aO= 0 212
":Oa 0 21D
":6L$6 0 21E
":gZOL6 0 21G
":"6A8 0 221
":-"O= 0 221
// Utilizados mas bien como indicadores
$:6!a 0 A1
$:=A8A 0 A2
$:6""!" 0 AD
// X00000000000000000000000000000000000000000000000000000000000000000000Y
// X 6lementos de la tabla de simbolos Y
// X00000000000000000000000000000000000000000000000000000000000000000000Y
const
;A<:$O;M!L!$ 0 D11
tipos
ipo : numerico

1/3
const
t:=U; 0 112E
t:O;6 0 112G
tipos
O=a!:$O;M : registro
3
nombre : cadena
tipo : ipo
dir : numerico
val:inicial : numerico
5
var
tabs : vector X;A<:$O;M!L!$Y O=a!:$O;M
cs : numerico // cantidad simbolos ya in%resados
// X00000000000000000000000000000000000000000000000000000000000000000000Y
// X 6lementos de la %eneracion de Rcodi%oR Y
// X00000000000000000000000000000000000000000000000000000000000000000000Y
const
;A<:C!8OW! 0 D11 // solo D11 instrucciones...
!:O=$"UCCO!=6$ 0 21
tipos
O=$"UCCO!= : numerico
O=a!:C!8OW! : registro
3
inst : O=$"UCCO!=
op : numerico
5
O=a!:O=$" : registro
3
nombre : cadena
usa:op : lo%ico
5
var
codi%o : vector X;A<:C!8OW!Y O=a!:C!8OW!
tot:inst : numerico
in.o:instr : vector X!:O=$"UCCO!=6$Y O=a!:O=$"

/*
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
A6=CO!= A6=CO!= A6=CO!= A6=CO!= A6=CO!=
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
1/4
6l Rcodi%oR %enerado corresponde a una ma9uina Qipotetica* basda en
pila* cuyas instrucciones son:
a) O=$"UCCO!=6$ R"6LACO!=AL6$R
cmp:[ : es topeA1 [ tope_
cmp:` : es topeA1 ` tope_
cmp:00 : es topeA1 00 tope_
cmp:`0 : es topeA1 `0 tope_
cmp:[0 : es topeA1 [0 tope_
cmp:[` : es topeA1 [` tope_
odas estas instrucciones deben RevaluarR la condicion* eliminar
de la pila los dos valores y apilar el resultado* como
el valor 1 &.also) o no 1 &verdadero).
b) O=$"UCCO!=6$ RA"O;6OCA$R
restar : &topeA1) A &tope)
sumar : &topeA1) 4 &tope)
mult : &topeA1) * &tope)
div : &topeA1) / &tope)
camb:si%no : Atope
odas estas instrucciones deben realizar la operacion* eliminar
de la pila los dos valores y apilar el resultado.
c) ;A=O-ULACO!= 86 LA -OLA
apilar:const : apilar el valor 9ue se encuentra en op.
apilar:valor:var : apilar el valor de la variable cuya
direccion es dir y 9ue se encuentra en op.
ivar : crear una variable en el tope de la
pila con valor inicial en op.
apilar:dir : apilar la direccion 9ue se encuentra en op.
asi%nar : copiar el valor del tope de la pila
en la direccion apuntada por &topeA1).
d) $AL!$
saltar : saltar a la direccion indicada por op.
saltar:si:.also : si valor del tope 00 1* saltar a direccion
indicada por op.
e) 6="A8A/$ALO8A
leer : leer un valor numerico y car%ar en la
direccion apuntada por op.
imprimir : imprimir el valor del tope de la pila.
.) PA"O!$
parar : terminar e'ecucion.
*/
const
C<:C;-:;6=!" 0 1
C<:C;-:;Af!" 0 2
1/5
C<:C;-:;6=!":OWUAL 0 D
C<:C;-:;Af!":OWUAL 0 E
C<:C;-:OWUAL 0 G
C<:C;-:8O$O=! 0 T
C<:;A:$U;A" 0 F
C<:;A:"6$A" 0 H
C<:;A:;UL 0 S
C<:;A:8OP 0 11
C<:;A:CA;M:$OW=! 0 11
C<:A-OLA":C!=$ 0 12
C<:A-OLA":PAL!":PA" 0 1D
C<:OPA" 0 1E
C<:A-OLA":8O" 0 1G
C<:A$OW=A" 0 1T
C<:$ALA" 0 1F
C<:$ALA":$O:aAL$! 0 1H
C<:L66" 0 1S
C<:O;-"O;O" 0 21
C<:-A"A" 0 21
// X00000000000000000000000000000000000000000000000000000000000000000000Y
// X 6lementos para la e'ecucion Y
// X00000000000000000000000000000000000000000000000000000000000000000000Y
const
;A<:;6;!"OA 0 G11 // la memoria tiene lu%ar para G11 variables
tipos
6L6;:-OLA : numerico
var
pila : vector X;A<:;6;!"OAY 6L6;:-OLA
tp : numerico
// X00000000000000000000000000000000000000000000000000000000000000000000Y
// X !tras variables Y
// X00000000000000000000000000000000000000000000000000000000000000000000Y
var
cant:error : numerico // cuantos errores se encontraron_
mostrar:inst : lo%ico
const
$6:6$-6"A 0 R$e espera R // mensa'e comun
1/'
// X00000000000000000000000000000000000000000000000000000000000000000000Y
// X -"!W"A;A -"O=CO-AL Y
// X00000000000000000000000000000000000000000000000000000000000000000000Y
inicio
cant:error 0 1
inicializar:pal:reserv&)
inicializar:scanner&)
inicializar:tabs&)
inicializar:codi%o&)
si & pudo:abrirse:.uente&) )
3
s%te:lex&)
analizar:.uente&)
si & cant:error 00 1 )
3
si & mostrar:inst )
3
imprimir:codi%o&)
sino
inicializar:interprete&)
/*
6stuve leyendo desde el arcQivo 9ue me pasaron como
parametro. A partir de aQora* debo leer del teclado.
6so se Qace con set:stdin &RR)
*/
set:stdin &RR)
e'ecutar&)
5
5
5
fin
subrutina pudo:abrirse:.uente&) retorna lo%ico
var
nomb:.uente : cadena
p:arcQivo : numerico
ok : lo%ico
inicio
ok 0 =!
si & paramval &1) 00 RAdR )
3
mostrar:inst 0 $O
p:arcQivo 0 2
sino
mostrar:inst 0 =!
p:arcQivo 0 1
5
1/,
si & pcount&) [ p:arcQivo )
3
imprimir &R,naalta especi.icar arcQivo .uente ;icroLR)
sino
nomb:.uente 0 paramval &p:arcQivo)
ok 0 set:stdin &nomb:.uente)
si & not ok )
3
imprimir &R,n=o pudo abrirse arcQivo R* nomb:.uente)
ok 0 =!
5
5
retorna & ok )
fin
// AAAAAAAAAAAAAAAAAA]]]]]]]]]]AAAAAAAAAAAAAAAAAAAA
// "UO=A$ 86L $CA==6"
subrutina inicializar:pal:reserv&)
inicio
pal:reserv 0 3 3RvarR* ":PA" 5*
3Rbe%inR* ":O=OCO! 5*
3RendR* ":aO= 5*
3Ri.R* ":Oa 5*
3RelseR* ":6L$6 5*
3ReQileR* ":gZOL6 5*
3+readR* ":"6A8 5*
3RprintR* ":-"O= 5
5
fin
subrutina inicializar:scanner&)
/*
A Ondicar 9ue aun no se leyoN nada &llt01)
A Cambiar el separador de campo a .inAdeAlinea.
8e lo contrario Rvar a*b*cBR leera Rvar aR* lue%o RbR y lue%o RcBR.
6l cambio se Qace con set:i.s&).
*/
inicio
lt 0 RR
llt 0 1
up 0 1
set:i.s &N,nN)
fin
subrutina leer:s%te:linea&)
/*
$i no es eo.* leer s%te. linea.
1/-
$i eo.* indicar tal situacion a s%te:lex&) Qaciendo llt0A1.
*/
inicio
si & not eo.&) )
3
leer &lt)
llt 0 strlen &lt)
up 0 1
sino
llt 0 A1
5
fin
subrutina es:letra &c : cadena) retorna lo%ico
var
r : lo%ico
inicio
r 0 &c `0 NaN and c [0 NzN) or
&c `0 NAN and c [0 NVN)
retorna & r )
fin
subrutina es:di%ito &c : cadena) retorna lo%ico
var
r : lo%ico
inicio
r 0 &c `0 N1N and c [0 NSN)
retorna & r )
fin
subrutina es:palabra:reserv &s : cadena
ref ipr : O=a!:-AL:"6$6"P) retorna lo%ico
/*
Muscar la cadena s en la lista de palabras reservadas.
!bservar 9ue ip. se pasa por re.erencia.
*/
var
k : numerico
enc : lo%ico
inicio
enc 0 =!
desde k01 hasta alen &pal:reserv)
3
si & s 00 pal:reserv XkY.pal )
3
ipr 0 pal:reserv XkY
enc 0 $O
1/.
k 0 alen &pal:reserv)
5
5
retorna & enc )
fin
subrutina leer:identi.&)
/*
Leer un identi.icador* es decir* una secuencia de letra se%uida
de letra o di%ito.
=o existe un limite especi.ico en la lon%itud.
$e viene a9ui si...
Caracter anterior .ue una letra &9ue esta en lt XupY).
8ado 9ue una palabra reservada luce Ri%ualR 9ue una variable*
al terminar de leer el identi.icador se veri.ica si no es
una palabra reservada* 9ue de ser* tk tendra su valor simbolico.
*/
var
pos:i : numerico
c : cadena
ipr : O=a!:-AL:"6$6"P
inicio
pos:i 0 up
repetir
inc &up)
c 0 substr &lt* up* 1)
hasta & not &es:letra &c) or es:di%ito &c)) )
dec &up)
subcad 0 substr &lt* pos:i* &up A pos:i) 4 1)
si & es:palabra:reserv &subcad* ipr) )
3
tk 0 ipr.lex
sino
tk 0 $:=!;M"6:PA"
5
fin
subrutina leer:constante:entera&) retorna cadena
var
pos:i : numerico
c : cadena
inicio
pos:i 0 up
repetir
inc &up)
11/
hasta & not &es:di%ito&c)) )
dec &up)
retorna &substr &lt* pos:i* &upApos:i) 4 1))
fin
subrutina leer:constante:numerica&)
/*
Leer una secuencia de di%itos.
$e viene a9ui si...
Caracter anterior .ue un di%ito.
!bservar 9ue a9ui no se considera el si%no.
Una constante numerica puede se entera o decimal.
=o puede usarse notacion cienti.ica.
*/
var
num:cad : cadena
inicio
tk 0 $:=A8A
num:cad 0 leer:constante:entera&)
si & substr &lt* up41* 1) 00 N.N )
3
inc &up* 2)
si & es:di%ito &substr &lt* up* 1)) )
3
num:cad 0 num:cad 4 N.N 4 leer:constante:entera&)
sino
tk 0 $:6""!"
5
5
val:num 0 val &num:cad)
si & tk 00 $:=A8A )
3
tk 0 $:C!=$:=U;
5
fin
subrutina s%te:lex&)
/*
A Odenti.ica el s%te. lexema &token).
A $i la linea se RacabaR lee otra linea* llamando a leer:s%te:linea&).
*/
var
c : cadena
inicio
tk 0 $:=A8A
subcad 0 RR
111
mientras & tk 00 $:=A8A )
3
si & up `0 llt )
3
leer:s%te:linea&)
si & llt 00 A1 )
3
tk 0 $:6!a
5
5
si & tk [` $:6!a )
3
inc &up)
eval
3
caso & c 00 NN )
B
caso & c 00 N,tN )
B
caso & c 00 N N )
B
caso & es:letra &c) )
leer:identi.&)
caso & es:di%ito &c) )
leer:constante:numerica&)
caso & c 00 N4N )
tk 0 $:;A$
caso & c 00 NAN )
si & lt Xup41Y 00 NAN )
3
up 0 llt 4 1
sino
tk 0 $:;6=!$
5
caso & c 00 N*N )
tk 0 $:;UL
caso & c 00 N/N )
tk 0 $:8OP
caso & c 00 N&N )
tk 0 $:-A"6=:O
caso & c 00 N)N )
tk 0 $:-A"6=:8
caso & c 00 N3N )
tk 0 $:LLAP6:O
caso & c 00 N5N )
tk 0 $:LLAP6:8
caso & c 00 N*N )
tk 0 $:C!;A
caso & c 00 NBN )
tk 0 $:-U=!:f:C!;A
caso & c 00 N[N )
112
si & lt Xup41Y 00 N0N )
3
tk 0 $:;6=!":OWUAL
inc &up)
sino
tk 0 $:;6=!"
5
caso & c 00 N`N )
3
tk 0 $:;Af!":OWUAL
inc &up)
sino
tk 0 $:;Af!"
5
caso & c 00 N0N )
3
tk 0 $:OWUAL
inc &up)
sino
tk 0 $:A$OW=ACO!=
5
caso & c 00 N7N )
3
tk 0 $:8O$O=!
inc &up)
sino
tk 0 $:6""!"
5
sino
tk 0 $:6""!"
subcad 0 c
5
5
5
fin
// "UO=A$ 86L -A"$6"
subrutina es:oprel &s : L6<6;A) retorna lo%ico
var
r : lo%ico
inicio
r 0 &s 00 $:;6=!" or
113
s 00 $:;6=!":OWUAL or
s 00 $:;Af!" or
s 00 $:;Af!":OWUAL or
s 00 $:8O$O=! or
s 00 $:OWUAL
)
retorna & r )
fin
subrutina es:si%no &s : L6<6;A) retorna lo%ico
var
r : lo%ico
inicio
r 0 &s 00 $:;A$ or s 00 $:;6=!$)
retorna & r )
fin
subrutina expresion&)
var
op : L6<6;A
inicio
expr:simple&)
si & es:oprel &tk) )
3
op 0 tkB
s%te:lex&)
expr:simple&)
W6=:!-:"6L &op)
5
fin
subrutina expr:simple&)
var
op : L6<6;A
inicio
sub:expr&)
mientras & es:si%no &tk) )
3
op 0 tk
s%te:lex&)
sub:expr&)
W6=:!-:;A &op)
5
fin
subrutina sub:expr&)
var
op : L6<6;A
114
inicio
.actor&)
mientras & tk 00 $:;UL or tk 00 $:8OP )
3
op 0 tk
s%te:lex&)
.actor&)
W6=:!-:;A &op)
5
fin
subrutina .actor&)
var
dir:var : numerico
inicio
eval
3
caso & tk 00 $:C!=$:=U; )
W6=:A-OLA":C!=$ &val:num)
s%te:lex&)
caso & tk 00 $:=!;M"6:PA" )
dir:var 0 ubicar:simb &subcad)
si & dir:var [` 1 )
3
W6=:A-OLA":PA" &tabs Xdir:varY.dir)
s%te:lex&)
sino
error &RPariable NR 4 subcad 4 RN no .ue declaradaR)
5
caso & tk 00 $:-A"6=:O )
s%te:lex&)
expresion&)
cQk:lex &$:-A"6=:8* RN)NR)
caso & tk 00 $:;6=!$ )
s%te:lex&)
.actor&)
W6=:CA;M:$OW=!&)
caso & tk 00 $:;A$ )
s%te:lex&)
sino
error &R$imbolo no reconocido:R)
5
fin
subrutina decl:una:var&)
var
nueva:var : O=a!:$O;M
si%no : numerico
Qay:si%no : lo%ico
inicio
115
si%no 0 1
Qay:si%no 0 aAL$6
si & tk 00 $:=!;M"6:PA")
3
si & ubicar:simb &subcad) [` 1 )
3
error &RPariable NR 4 subcad 4 RN ya .ue declaradaR)
sino
nueva:var.nombre 0 subcad
nueva:var.val:inicial 0 1
nueva:var.dir 0 1
s%te:lex&)
si & tk 00 $:A$OW=ACO!= )
3
s%te:lex&)
si & tk 00 $:;6=!$ )
3
si%no 0 A1
s%te:lex&)
Qay:si%no 0 "U6
sino si & tk 00 $:;A$ )
s%te:lex&)
Qay:si%no 0 "U6
5
si & tk 00 $:C!=$:=U; )
3
nueva:var.val:inicial 0 val:num * si%no
s%te:lex&)
sino
error &$6:6$-6"A 4 Rcontante numericaR)
5
5
5
a%re%ar:simb &nueva:var)
W6=:OPA" &nueva:var)
sino
error &$6:6$-6"A 4 Rnombre de variableR)
5
fin
subrutina decl:lista:var&)
inicio
decl:una:var&)
mientras & tk 00 $:C!;A )
3
s%te:lex&)
decl:una:var&)
5
cQk:lex &$:-U=!:f:C!;A* RNBNR)
fin
11'
subrutina decl:variables&)
inicio
decl:lista:var&)
mientras & tk 00 $:=!;M"6:PA" )
3
decl:lista:var&)
5
fin
subrutina cQk:lex &cmp : L6<6;AB ms% : cadena)
inicio
si & tk 00 cmp )
3
s%te:lex&)
sino
error &$6:6$-6"A 4 ms%)
5
fin
subrutina sent:asi%nacion&)
var
dir:var : numerico
inicio
si & dir:var [` 1 )
3
W6=:A-OLA":8O" &tabs Xdir:varY.dir)
s%te:lex&)
cQk:lex & $:A$OW=ACO!=* RN0NR)
expresion&)
W6=:A$OW=A"&)
sino
5
cQk:lex &$:-U=!:f:C!;A * RNBNR)
fin
subrutina blo9ue&)
inicio
cQk:lex &$:LLAP6:O* RN3NR)
%rupo:sentencias&)
cQk:lex &$:LLAP6:8* RN5NR)
fin
11,
subrutina sent:i.&)
var
Queco:i. : numerico
Queco:salto:a:.in:i. : numerico
inicio
s%te:lex&)
cQk:lex &$:-A"6=:O* RN&NR)
expresion&)
Queco:i. 0 dir:s%te:inst&)
W6=:$AL!:aAL$! &A1)
blo9ue&)
si & tk [` ":6L$6 )
3
W6=:C!;-L6A":$AL! &Queco:i.* dir:s%te:inst&))
sino
W6=:C!;-L6A":$AL! &Queco:i.* dir:s%te:inst&) 4 1)
Queco:salto:a:.in:i. 0 dir:s%te:inst&)
W6=:$AL! &A1)
s%te:lex&)
blo9ue&)
W6=:C!;-L6A":$AL! &Queco:salto:a:.in:i.* dir:s%te:inst&))
5
fin
subrutina sent:eQile&)
var
inicio:eQile : numerico
Queco : numerico
inicio
s%te:lex&)
inicio:eQile 0 dir:s%te:inst&)
cQk:lex &$:-A"6=:O* RN&NR)
expresion&)
Queco 0 dir:s%te:inst&)
11-
W6=:$AL!:aAL$! &A1)
blo9ue&)
W6=:$AL! &inicio:eQile)
W6=:C!;-L6A":$AL! &Queco* dir:s%te:inst&))
fin
subrutina sent:read&)
var
dir:var : numerico
inicio
s%te:lex&)
si & tk [` $:=!;M"6:PA" )
3
error &$6:6$-6"A 4 R nombre de variableR)
sino
si & dir:var 00 1 )
3
sino
W6=:L66" &tabs Xdir:varY.dir)
s%te:lex&)
5
5
fin
subrutina sent:print&)
inicio
s%te:lex&)
expresion&)
W6=:O;-"O;O"&)
fin
subrutina %rupo:sentencias&)
var
ok : lo%ico
inicio
ok 0 $O
mientras & ok )
3
eval
3
caso & tk 00 $:-U=!:f:C!;A )
s%te:lex&)
11.
caso & tk 00 $:=!;M"6:PA" )
sent:asi%nacion&)
caso & tk 00 ":Oa )
sent:i.&)
caso & tk 00 ":gZOL6 )
sent:eQile&)
caso & tk 00 ":"6A8 )
sent:read&)
caso & tk 00 ":-"O= )
sent:print&)
sino
ok 0 =!
5
5
si & not &tk 00 ":aO= or tk 00 $:LLAP6:8) )
3
error &R$entencia no reconocidaR)
5
fin
subrutina analizar:.uente&)
inicio
si & tk 00 ":PA" )
3
s%te:lex&)
decl:variables&)
5
cQk:lex &":O=OCO!* RNinicioNR)
%rupo:sentencias&)
cQk:lex &":aO=* RN.inNR)
W6=:-A"A"&)
si & tk [` $:6!a )
3
error &R-ro%rama no termina correctamenteR)
5
fin
subrutina error &s : cadena)
inicio
si & cant:error 00 1 )
3
imprimir &R,nR* lt* R,nR* strdup &R R* up)* RU R* s* R,nR)
inc &cant:error)
5
s%te:lex&)
fin
12/
// "UO=A$ 86 LA AMLA 86 $O;M!L!$
subrutina inicializar:tabs&)
inicio
cs 0 1
fin
subrutina ubicar:simb &s : cadena) retorna numerico
var
k* ubic : numerico
inicio
ubic 0 1
desde k 0 1 hasta cs
3
si & s 00 tabs XkY.nombre )
3
ubic 0 k
5
5
retorna & ubic )
fin
subrutina a%re%ar:simb &simb : O=a!:$O;M)
inicio
si & cs [ ;A<:$O;M!L!$ )
3
tabs Xinc&cs)Y 0 simb
tabs XcsY.dir 0 cs
sino
error &Rabla de simbolos llenaR)
5
fin
// AAAAAAAAAAAAAAA W6=6"ACO!= 86 RC!8OW!R AAAAAAAAAAAAAAA
subrutina inicializar:codi%o&)
var
k : numerico
inicio
tot:inst 0 1
in.o:instr XC<:C;-:;6=!" Y 0 3Rcmp:[R* =!5
in.o:instr XC<:C;-:;Af!" Y 0 3Rcmp:`R* =!5
in.o:instr XC<:C;-:;6=!":OWUAL Y 0 3Rcmp:[0R* =!5
in.o:instr XC<:C;-:;Af!":OWUAL Y 0 3Rcmp:`0R* =!5
in.o:instr XC<:C;-:OWUAL Y 0 3Rcmp:0R* =!5
in.o:instr XC<:C;-:8O$O=! Y 0 3Rcmp:[`R* =!5

121
in.o:instr XC<:;A:$U;A" Y 0 3RsumarR* =!5
in.o:instr XC<:;A:"6$A" Y 0 3RrestarR* =!5
in.o:instr XC<:;A:;UL Y 0 3RmultR* =!5
in.o:instr XC<:;A:8OP Y 0 3RdivR* =!5
in.o:instr XC<:;A:CA;M:$OW=! Y 0 3Rcamb:si%noR* =!5

in.o:instr XC<:A-OLA":C!=$ Y 0 3Rapilar:constR* $O5
in.o:instr XC<:A-OLA":PAL!":PA" Y 0 3Rapilar:valor:varR* $O5
in.o:instr XC<:OPA" Y 0 3RivarR* $O5
in.o:instr XC<:A-OLA":8O" Y 0 3Rapilar:dirR* $O5
in.o:instr XC<:A$OW=A" Y 0 3Rasi%narR* =!5
in.o:instr XC<:$ALA" Y 0 3RsaltarR* $O5
in.o:instr XC<:$ALA":$O:aAL$! Y 0 3Rsaltar:si:.alsoR* $O5
in.o:instr XC<:L66" Y 0 3RleerR* $O5
in.o:instr XC<:O;-"O;O" Y 0 3RimprimirR* =!5
in.o:instr XC<:-A"A" Y 0 3RpararR* =!5
fin
subrutina %en:cod &inst: O=$"UCCO!=B op : numerico)
inicio
si & tot:inst [ ;A<:C!8OW! )
3
inc &tot:inst)
codi%o Xtot:instY.inst 0 inst
codi%o Xtot:instY.op 0 op
sino
error &Rabla de codi%os llenaR)
5
fin
subrutina dir:s%te:inst&) retorna numerico
inicio
retorna &tot:inst 4 1)
fin
subrutina imprimir:codi%o&)
var
k : numerico
ii : O=a!:O=$"
inicio
desde k01 hasta tot:inst
3
imprimir &R,nR* str &k* 11* 1)* R,tR)
si & codi%o XkY.inst `0 1 and codi%oXkY.inst [0 !:O=$"UCCO!=6$ )
3
ii 0 in.o:instr Xcodi%o XkY.instY
122
imprimir &substr &ii.nombre 4 strdup &N N* 21)* 1* 21) )
si & ii.usa:op 00 $O )
3
imprimir &codi%o XkY.op)
5
sino
imprimir &R** Onstruccion desconocida **R)
5
5
fin
subrutina W6=:!-:"6L &l : L6<6;A)
inicio
eval
3
caso & l 00 $:;6=!" )
%en:cod &C<:C;-:;6=!"* 1)
caso & l 00 $:;Af!" )
%en:cod &C<:C;-:;Af!"* 1)
caso & l 00 $:OWUAL )
%en:cod &C<:C;-:OWUAL* 1)
caso & l 00 $:;Af!":OWUAL )
%en:cod &C<:C;-:;Af!":OWUAL* 1)
caso & l 00 $:;6=!":OWUAL )
%en:cod &C<:C;-:;6=!":OWUAL* 1)
caso & l 00 $:8O$O=! )
%en:cod &C<:C;-:8O$O=!* 1)
5
fin
subrutina W6=:!-:;A &l: L6<6;A)
inicio
eval
3
caso & l 00 $:;6=!$ )
%en:cod &C<:;A:"6$A"* 1)
caso & l 00 $:;A$ )
%en:cod &C<:;A:$U;A"* 1)
caso & l 00 $:;UL )
%en:cod &C<:;A:;UL* 1)
caso & l 00 $:8OP )
%en:cod &C<:;A:8OP* 1)
5
fin
subrutina W6=:A-OLA":C!=$ &n : numerico)
inicio
%en:cod &C<:A-OLA":C!=$* n)
fin
123
subrutina W6=:A-OLA":PA" &dir : numerico)
inicio
%en:cod &C<:A-OLA":PAL!":PA"* dir)
fin
subrutina W6=:CA;M:$OW=!&)
inicio
%en:cod &C<:;A:CA;M:$OW=!* 1)
fin
subrutina W6=:OPA" &s : O=a!:$O;M)
inicio
%en:cod &C<:OPA"* s.val:inicial)
fin
subrutina W6=:A-OLA":8O" &dir : numerico)
inicio
%en:cod &C<:A-OLA":8O"* dir)
fin
subrutina W6=:A$OW=A"&)
inicio
%en:cod &C<:A$OW=A"* 1)
fin
subrutina W6=:$AL! &dir : numerico)
inicio
%en:cod &C<:$ALA"* dir)
fin
subrutina W6=:$AL!:aAL$! &dir : numerico)
inicio
%en:cod &C<:$ALA":$O:aAL$!* dir)
fin
subrutina W6=:C!;-L6A":$AL! &dir:cod* dir : numerico)
inicio
codi%o Xdir:codY.op 0 dir
fin
subrutina W6=:L66" &dir : numerico)
inicio
124
%en:cod &C<:L66"* dir)
fin
subrutina W6=:O;-"O;O"&)
inicio
%en:cod &C<:O;-"O;O"* 1)
fin
subrutina W6=:-A"A"&)
inicio
%en:cod &C<:-A"A"* 1)
fin
// X00000000000000000000000000000000000000000000000000000000000000000000Y
// X "utinas del interprete Y
// X00000000000000000000000000000000000000000000000000000000000000000000Y
subrutina inicializar:interprete&)
inicio
tp 0 1
fin
subrutina e'ecutar&)
var
i : O=$"UCCO!=
pi : numerico // indice de instruccion 9ue esta en e'ecucion
inicio
pi 0 1
repetir
i 0 codi%o Xinc &pi)Y.inst
eval
3
caso & i 00 C<:C;-:;6=!" )
dec &tp)
si & pila XtpY [ pila Xtp41Y )
3
pila XtpY 0 1
sino
pila XtpY 0 1
5
caso & i 00 C<:C;-:;Af!" )
dec &tp)
si & pila XtpY ` pila Xtp41Y )
3
pila XtpY 0 1
sino
pila XtpY 0 1
5
125
caso & i 00 C<:C;-:;6=!":OWUAL )
dec &tp)
si & pila XtpY [0 pila Xtp41Y )
3
pila XtpY 0 1
sino
pila XtpY 0 1
5
caso & i 00 C<:C;-:;Af!":OWUAL )
dec &tp)
si & pila XtpY `0 pila Xtp41Y )
3
pila XtpY 0 1
sino
pila XtpY 0 1
5
caso & i 00 C<:C;-:OWUAL )
dec &tp)
si & pila XtpY 00 pila Xtp41Y )
3
pila XtpY 0 1
sino
pila XtpY 0 1
5
caso & i 00 C<:C;-:8O$O=! )
dec &tp)
si & pila XtpY [` pila Xtp41Y )
3
pila XtpY 0 1
sino
pila XtpY 0 1
5
caso & i 00 C<:;A:$U;A" )
dec &tp)
pila XtpY 0 pila XtpY 4 pila Xtp41Y
caso & i 00 C<:;A:"6$A" )
dec &tp)
pila XtpY 0 pila XtpY A pila Xtp41Y
caso & i 00 C<:;A:;UL )
dec &tp)
pila XtpY 0 pila XtpY * pila Xtp41Y
caso & i 00 C<:;A:8OP )
dec &tp)
pila XtpY 0 pila XtpY / pila Xtp41Y
12'
caso & i 00 C<:;A:CA;M:$OW=! )
pila XtpY 0 Apila XtpY
caso & i 00 C<:A-OLA":C!=$ )
pila Xinc &tp)Y 0 codi%o XpiY.op
caso & i 00 C<:A-OLA":PAL!":PA" )
pila Xinc &tp)Y 0 pila Xcodi%o XpiY.opY
caso & i 00 C<:OPA" )
caso & i 00 C<:A-OLA":8O" )
caso & i 00 C<:A$OW=A" )
pila Xpila XtpA1YY 0 pila XtpY
dec &tp* 2)
caso & i 00 C<:$ALA" )
pi 0 codi%o XpiY.op A 1 // A1 pues lue%o se incrementara...
caso & i 00 C<:$ALA":$O:aAL$! )
si & pila XtpY 00 1 )
3
pi 0 codi%o XpiY.op A 1 // A1 pues lue%o se incrementara...
5
dec &tp)
caso & i 00 C<:L66" )
leer & pila Xcodi%o XpiY.opY )
caso & i 00 C<:O;-"O;O" )
imprimir &R,nR* pila XtpY )
dec &tp)
caso & i 00 C<:-A"A" )
B
sino
imprimir &R,nR* R** Onstruccion desconocida **R)
i 0 C<:-A"A"
5
hasta & i 00 C<:-A"A" )
fin
12,
Ane,o &7 Subrutinas 8 3unciones
prede3inidas
Subrutinas prede2inidas
dim (arreglo, tam_dim1, tam_dim, !!!"
Enicializa un arreglo con los tamaos para cada dimensin especificados.
$jemplo%
var
;D : matriz X** ** *Y numerico
inicio
dim &;D* G* H* D)
...
+rea un matriz tridimensional de > ? ,.
imprimir (var1, var,#, varn"
Emprime los valores que se pasan como parmetros.
imprimir &a* b*11* s 4 /al%o/)
Fer la seccin CL.1.- Las cadenas de caracteresD con relacin a las secuencias
especiales.
Se pueden imprimir varia"les de cadena, numricas o lgicas. $stas #ltimas se
imprimirn como C7:B$D o C@'LS$D.
cls("
Limpia la pantalla.
leer (var1, var,#, varn"
Lee uno o mas valores y los asigna a las varia"les que se pasan como
parmetros.
$jemplo%
12-
var
n : numerico
s : cadena
inicio
leer &n* s)
...
Leer dos valores y asignar a n y s respectivamente. $l separador de campos es
la coma. $s decir, para responder a la lectura anterior se de"er tipear%
111*e'emplo de cadena
seguido de $97$:. 'l leer n#meros se ignoran los espacios que lo preceden/ al
leer cadenas no se los ignora.
Se pueden leer varia"les numricas o de cadena, pero no las que sean del tipo
lgico.
G"servacin% el separador de campo se puede cam"iar con setKifs().
Si ya no eisten datos en la entrada y se llama a leer(), se producir un error de
ejecucin.
set_ifs (c $ cadena"
$sta"lece cul carcter utilizar leer() como separador de campos.
$jemplo%
var
n : numerico
s : cadena
inicio
set:i.s &IhJ)
leer &n* s)
...
&ara responder a la lectura anterior se de"er tipear%
111h-erez* #uan
seguido de $97$:. Siendo [ el separador de campos, n valdr 1A y s C&erez,
\uanD.
12.
"unciones prede2inidas
abs (n$ numerico" retorna numerico
+alcula el valor a"soluto de n.
arctan (gr$ numerico" retorna numerico
+alcula el arco tangente de gr, que de"e estar epresado en radianes.
ascii (pos_tabla$ numerico" retorna cadena
:etorna el carcter 'S+EE que se encuentra en la posicin posKta"la.
cos (gr$ numerico" retorna numerico
+alcula el coseno de gr, que de"e estar epresado en radianes.
dec (ref n$ numerico% a $ numerico" retorna numerico
5ecrementa el valor de la varia"le n en a.
&or defecto a es 1, pero puede ser positivo o negativo.
:etorna el nuevo valor de n.
$jemplo%
n 0 11
dec &n) // es lo mismo 9ue n 0 n A 1
dec &n* 2) // es lo mismo 9ue n 0 n A 2
A Xdec &n)Y 0 D2 // n serC T y A XTY tendrC D2.
eof(" retorna logico
:etorna verdadero cuando ya no eisten datos en la entrada para ser le!dos.
e&p (n$ numerico" retorna numerico
+alcula e]n (siendo e "ase de los logaritmos naturales).
get_ifs(" retorna cadena
:etorna el carcter que leer() utilizar para separar los campos durante una
operacin de lectura.
Fea tam"in setKifs().
13/
inc (ref n$ numerico% a $ numerico" retorna numerico
Encrementa el valor de la varia"le n en a.
&or defecto a es 1, pero puede ser positivo o negativo.
:etorna el nuevo valor de n.
$jemplo%
n 0 11
inc &n) // es lo mismo 9ue n 0 n 4 1
inc &n* 2) // es lo mismo 9ue n 0 n 4 2
A Xinc &n)Y 0 D2 // n serac 1E y A X1EY tendra D2.
int (n$ numerico" retorna numerico
$trae la parte entera de n.
$jemplo%
y 0 int &D.EG) // y tendrac D
log (n$ numerico" retorna numerico
+alcula logaritmo "ase 1A de n.
lo'er (s$ cadena" retorna cadena
:etorna los caracteres alfa"ticos de s convertidos a min#sculas.
mem(" retorna numerico
:etorna la cantidad de memoria disponi"le para los programas SL, en "ytes.
ord (c$ cadena" retorna numerico
:etorna la posicin en que se encuentra en la ta"la 'S+EE el carcter que
contiene el parmetro c.
Si el valor de c contiene ms de un carcter se toma el primero.
a 0 ord &cAc) // a tendrac TG
paramval (($ numerico" retorna cadena
:etorna el W*simo parmetro que fue pasado al programa SL desde la l!nea de
comandos al momento de ser invocado. G"srvese que el valor retornado es
una cadena.
pcount(" retorna numerico
131
:etorna la cantidad de parmetros que fueron pasados al programa SL desde la
l!nea de comandos al momento de ser invocado.
pos (s1, s $ cadena$ pinicial $ numerico" retorna numerico
:etorna la posicin donde se inicia la cadena s- dentro de s1 considerando
desde el carcter de s1 que se encuentra en pinicial. Si p inicial es omitido, se
considera desde el inicio de s1. Si s- no se encuentra en s1, retorna A.
random (tope $ numerico% sem $ numerico" retorna numerico
:etorna un n#mero randmico entero mayor o igual a A y menor a tope.
$l parmetro sem es opcional. Si est presente, se reinicia el generador de
n#meros randmicos usando sem como semilla.
sec(" retorna numerico
:etorna la cantidad de segundos transcurridos desde medianoche.
set_stdin (nom_archivo $ cadena" retorna logico
+am"ia el archivo de donde leer() tomar los datos.
:etorna falso si el archivo (cuyo nom"re se pasa en nomKarchivo) no eiste o
no puede a"rirse. $n este caso adems se esta"lece como archivo de lectura la
entrada standard (usualmente el teclado).
$jemplo%
inicio
leer &n) // lee de la entrada standard* usualmente el teclado.
set:stdin &+misdatos.txt/)
leer &n) // leerC del arcQivo +misdatos.txt/ si ^ste
// pudo ser abierto
fin
set_stdout (nom_archivo, modo$ cadena" retorna logico
+am"ia el archivo de donde se imprimir() tomar los datos.
$l parmetro nomKarchivo indica el nom"re completo del archivo (incluyendo
camino) que se desea utilizar como archivo de salida.
$l parmetro modo tiene los siguientes valores y significados%
C<tD % so"reescri"ir el contenido del archivo, si ste ya eiste.
CatD % agregar al final del archivo todo lo que se imprima, sin
destruir su contenido.
132
&or defecto el parmetro modo toma el valor C<tD.
:etorna falso si el archivo (cuyo nom"re se pasa en nomKarchivo) no pudo
a"rirse. $n este caso adems se esta"lece la salida standard (usualmente la
pantalla) como destino de las llamadas a imprimir().
$jemplo%
inicio
/*
OmprimirC en la salida standard* usualmente la pantalla.
*/
imprimir &+,nZola/)
set:stdout &+saludos.txt/)
/*
OmprimirC en el arcQivo +saludos.txt/ si ^ste pudo ser abierto.
*/
imprimir &+,nAdi?s/)
fin
sin (gr$ numerico" retorna numerico
+alcula el seno de gr, que de"e estar epresado en radianes.
sqrt (n$ numerico" retorna numerico
+alcula la ra!z cuadrada de n.
str (n, a, cant_dec$ numerico% r $ cadena" retorna cadena
+onvierte a cadena el n#mero n, con cantKdec decimales (por defecto -), con un
ancho total de a caracteres (por defecto A) y, si fuera necesario, rellenando a la
izquierda con el carcter contenido en r (por defecto un espacio).
$jemplos%
n 0 12D.E1EG1
s 0 str &n) // A` +12D.E1/
s 0 str &n*11) // A` + 12D.E1/
s 0 str &n*11*D) // A` + 12D.E1G/ &redondeado7)
s 0 str &n*1*1) // A` +12D/
s 0 str &n*11*1*J*J) // A` +*******12D/
s 0 str &n*1*1) // A` +12D.E/
133
Si el numero n convertido a cadena tiene ms de a caracteres, a es ignorado.
$l signo negativo y el punto decimal son tenidos en cuenta para el clculo del
ancho total.
strdup (cadena s$ cant $ numerico" retorna cadena
:eplica la cadena s cant veces.
strlen (cadena s" retorna numerico
:etorna la cantidad de caracteres contenidos en la cadena s.
La cadena vac!a (CD) tiene longitud A.
substr (s$ cadena% inicio, cant $ numerico" retorna cadena
$trae una su"cadena de s, a partir del carcter que se encuentra en inicio, cant
caracteres.
Si el parmetro cant se omite, se etrae hasta el final de la cadena.
$jemplo%
s 0 substr &+AMC/* 1* 1) // A` +A/
s 0 substr &+AMC8/* 2) // A` +MC8/
s 0 substr &+AMC8/* G* 1) // A` +/ &cadena vacia)
tan (gr$ numerico" retorna numerico
+alcula la tangente de gr, que de"e estar epresado en radianes.
upper (s$ cadena" retorna cadena
:etorna los caracteres alfa"ticos de s convertidos a may#sculas.
val (s$ cadena" retorna numerico
:etorna el valor numrico de lo que contiene s.
:etorna A cuando lo que contiene s no puede ser interpretado como un valor
numrico.
$jemplo%
s 0 +12D.E/
n 0 val &s) // n tendrac 12D.E
n 0 val &+A12/) // n tendrac A12
n 0 val &+abc/) // n tendrac 1
134

Libro SL

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Libro SL

Cargado por

Copyright:

Formatos disponibles

Introduccin al

También podría gustarte