Parrot - Ejemplos de programacin

Parrot programacin es similar al lenguaje ensamblador programacin y tienes la oportunidad de trabajar en un nivel inferior. Aqu est la lista de ejemplos de programacin para que tenga en cuenta los diversos aspectos de programacin Loro.

Clsico Hola mundo!

Cree un archivo llamado hello.pir que contiene el siguiente cdigo:

.sub _main
   print "Hello world!\n"
   end
.end

A continuacin, ejecutar tecleando:

parrot hello.pir

Como era de esperar, se mostrar el texto 'Hello world!' en la consola, seguido de un carcter de nueva lnea (debido a la \n).

En el ejemplo anterior, '.sub _main' de los estados que las instrucciones que se detallan a continuacin constituyen una subrutina llamada '_main', hasta que un '.end' han encontrado. La segunda lnea contiene la instruccin de impresin. En este caso, nos estn pidiendo la variante de la instruccin que acepta una constante de cadena. El ensamblador se encarga de decidir qu variante de las instrucciones de uso para nosotros. La tercera lnea, el 'end' instrucciones, lo que provoca que el intrprete para terminar.

Utilizando Registros

Podemos modificar hola.pir a primera tienda la cadena Hello world!\n en un registro y, a continuacin, utilice el registro con la instruccin de impresin.

.sub _main
   set S1, "Hello world!\n"
   print S1
   end
.end

Aqu hemos dicho exactamente que registrarse para usar. Sin embargo, por S1 a $S1 podemos delegar la eleccin de que registrarse para usar de Parrot. Tambin es posible utilizar un = notacin en lugar de escribir las instrucciones.

.sub _main
   $S0 = "Hello world!\n"
   print $S0
   end
.end

PIR para que sea an ms legible, llamado registros pueden ser utilizados. Estos son ms tarde asignado a real registros numerados.

.sub _main
   .local string hello
   hello = "Hello world!\n"
   print hello
   end
.end

El '.local' directiva indica que el registro slo es necesario dentro de la misma unidad de compilacin (es decir, entre .sub y .final). Despus de un '.local' es un tipo. Esto puede ser int (para I registros), flotacin (para N registros), cadena (para S registros), pmc (para P registros) o el nombre de un tipo.

Resumen plazas

Este ejemplo presenta algunas ms instrucciones y sintaxis PIR. Las lneas que comienzan con # son comentarios.

.sub _main
   # State the number of squares to sum.
   .local int maxnum
   maxnum = 10

   # Some named registers we'll use. 
   # Note how we can declare many
   # registers of the same type on one line.
   .local int i, total, temp
   total = 0

   # Loop to do the sum.
   i = 1
   
loop:
   temp = i * i
   total += temp
   inc i
   if i <= maxnum goto loop

   # Output result.
   print "The sum of the first "
   print maxnum
   print " squares is "
   print total
   print ".\n"
   end
.end

PIR proporciona un poco de azcar sintctica que lo hacen ver ms alto nivel de la asamblea. Por ejemplo:

temp = i * i

Es simplemente otra forma de escribir el ms asamblea de ish:

mul temp, i, i

if i <= maxnum goto loop

Es el mismo:

le i, maxnum, loop

total += temp

Es el mismo:

add total, temp

Como regla general, cada vez que un loro instruccin modifica el contenido de un registro, que ser el primer registro cuando por escrito las instrucciones en conjunto.

Como es habitual en lenguajes ensambladores, los ciclos y las selecciones se implementan en trminos de bifurcaciones condicionales las declaraciones y etiquetas, como se ha indicado anteriormente. Aprendizaje Conjunto es uno de los lugares donde uso de goto no es una mala forma!

Nmeros de Fibonacci

La serie de Fibonacci es definido como sigue: dos nmeros, 1 y 1. A continuacin, varias veces sumar los ltimos dos nmeros de la serie para hacer el siguiente: 1, 1, 2, 3, 5, 8, 13, y as sucesivamente. La serie de Fibonacci el fib(n) es el n'th nmero de la serie. He aqu una simple Parrot programa ensamblador que considera los 20 primeros nmeros de Fibonacci:

# Some simple code to print some Fibonacci numbers

        print   "The first 20 fibonacci numbers are:\n"
        set     I1, 0
        set     I2, 20
        set     I3, 1
        set     I4, 1
        
REDO:   eq      I1, I2, DONE, NEXT

NEXT:   set     I5, I4
        add     I4, I3, I4
        set     I3, I5
        print   I3
        print   "\n"
        inc     I1
        branch  REDO
DONE:   end

Este es el cdigo equivalente en Perl:

print "The first 20 fibonacci numbers are:\n";

my $i = 0;
my $target = 20;
my $a = 1;
my $b = 1;

until ($i == $target) {
   my $num = $b;
   $b += $a;
   $a = $num;
   print $a,"\n";
   $i++;
}

NOTA: Es un buen punto de inters, uno de los ms cortos y, sin duda, la ms hermosa manera de imprimir una serie de Fibonacci en Perl es perl -le '$b=1; print $a+=$b, mientras que print $b+=$a'.

Clculo factorial recursivo

En este ejemplo, definimos una funcin factorial y llamar de forma recursiva para calcular el factorial.

.sub _fact
   # Get input parameter.
   .param int n

   # return (n > 1 ? n * _fact(n - 1) : 1)
   .local int result

   if n > 1 goto recurse
   result = 1
   goto return

recurse:
   $I0 = n - 1
   result = _fact($I0)
   result *= n

return:
   .return (result)
.end


.sub _main :main
   .local int f, i

   # We'll do factorial 0 to 10.
   i = 0
   
loop:
   f = _fact(i)

   print "Factorial of "
   print i
   print " is "
   print f
   print ".\n"

   inc i
   if i <= 10 goto loop

   # That's it.
   end
.end

Echemos un vistazo a la _fact sub primero. Un punto en el que se evoca con respecto a las anteriores es por qu los nombres de subrutinas, todos comienzan con un carcter de subrayado. Esto se hace simplemente como una manera de mostrar que la etiqueta es global y no particular mbito de una subrutina. Esto es importante ya que las etiquetas se hace visible a otras subrutinas.

La primera lnea, .param int n, especifica que esta subrutina toma un parmetro de entero y que nos gustara hacer referencia al registro que fue aprobada por el nombre n para el resto de la sub.

Gran parte de lo que sigue se ha visto en ejemplos anteriores, aparte de la lnea siguiente:

result = _fact($I0)

Esta nica lnea de PIR en realidad representa unas cuantas lneas de modo PASM. En primer lugar, el valor del registro $I0 se mueve en el registro correspondiente para que sea recibido como un parmetro de entero por la _fact funcin. Otros que estn relacionados con registros, a continuacin, configurar, seguido por _fact que se invoca. A continuacin, una vez _fact devuelve el valor devuelto por _fact se coloca en el registro le da el nombre.

Justo antes de que el .fin de la _fact sub, .directiva de retorno se utiliza para garantizar el valor almacenado en el registro, denominado resultado se coloca en el registro correcto para que se vea como un valor de retorno en el cdigo que llama al sub.

La llamada a _fact en principal funciona de la misma forma como el recursivo llamar a _fact dentro de la _fact sub s mismo. El nico bit restantes de la nueva sintaxis es :principal, escrito despus de .sub _main. De forma predeterminada, PIR se supone que la ejecucin comienza con la primera sub en el archivo. Este comportamiento se puede modificar mediante el marcado de la subcomisin para iniciar con :principales.

Compilacin de PBC

Para compilar PIR a bytecode, utilice el distintivo -o y especificar un archivo de salida con la extensin .pbc.

Parrot -o factorial.cpp factorial.pir

PIR vs. PASM

PIR puede transformarse en PASM ejecutando:

parrot -o hello.pasm hello.pir

El modo PASM para el ejemplo final tiene este aspecto:

_main:
   set S30, "Hello world!\n"
   print S30
end

PASM no maneja asignacin de registros o proporcionar apoyo para registros. Tambin no tiene el .sub y .final las directivas, en lugar de una etiqueta en el inicio de las instrucciones.

Print Page