Definición de máquinas
intermedias
Descripción Formal
Configuración
• El estado de los componentes de la
máquina.
• Se representa como una tupla
Transición de configuraciones
Configuración Configuración’
Ejemplo sencillo
Robot en un mundo de dos dimensiones
• Dos instrucciones right, left
• Configuración
– código
– Posición del robot
• Descripción de las transiciones
– < pos , right::cont, > < pos+1 , cont >
– <pos, left::cont > < pos-1, cont>
Otro ejemplo
• Una pila
• Las instruciones son:
– Push valor
– Pop
– Plus
– Minus
– Div
– Times
• Configuración
– Pila, instrucciones
Pila: Continuación
Transiciones
•
•
•
•
•
•
< pila, push(v)::cont> < v::pila, cont>
< x::pila, pop::cont> < pila, cont>
< y,x::pila, plus::cont> < (x+y)::pila, cont>
< y,x::pila, minus::cont> < (x-y)::pila, cont>
< y,x::pila, div::cont> < (x/y)::pila, cont>
< y,x::pila, times::cont> < (x*y)::pila, cont>
Pila: Continuación
Suponga una pila que puede admitir
también booleanos
Transiciones
•
•
•
•
< y,x::pila, LT::cont> < (x<y)::pila, cont>
< y,x::pila, LTE::cont> < (x<=y)::pila, cont>
< y,x::pila, GT::cont> < (x>y)::pila, cont>
< y,x::pila, GTE::cont> < (x>=y)::pila, cont>
• < y,x::pila, EQ::cont> < (x=y)::pila, cont>
• < y,x::pila, GTE::cont> < (x!=y)::pila, cont>
Extendiendo la máquina
• Queremos agregar una memoria para
guardar valores.
• Tenemos nuevas instrucciones para
guardar elementos en la memoria y para
empilar valores guardados en la memoria.
Pila con memoria
Transiciones
•
•
•
•
•
•
•
•
< mem, pila, pushV(i)::cont> < mem, mem[i]::pila, cont>
< mem, x::pila, asgmem(i)::cont> < mem[x/i], pila, cont>
< mem, pila, push(v)::cont> < mem, v::pila, cont>
< mem, x::pila, pop::cont> < mem, pila, cont>
< mem, y,x::pila, plus::cont> < mem, (x+y)::pila, cont>
< mem, y,x::pila, minus::cont> < mem, (x-y)::pila, cont>
< mem, y,x::pila, div::cont> < mem, (x/y)::pila, cont>
< mem, y,x::pila, times::cont> < mem, (x*y)::pila, cont>
Pila con memoria: Continuación
•
•
•
•
•
•
< mem, y,x::pila, LT::cont> < mem, (x<y)::pila, cont>
< mem, y,x::pila, LTE::cont> < mem, (x<=y)::pila, cont>
< mem, y,x::pila, GT::cont> < mem, (x>y)::pila, cont>
< mem, y,x::pila, GTE::cont> < mem, (x>=y)::pila, cont>
< mem, y,x::pila, EQ::cont> < mem, (x=y)::pila, cont>
< mem, y,x::pila, GTE::cont> < mem, (x!=y)::pila, cont>
Extendiendo la máquina
• Agregamos flujos de entrada y de salida
• Se tienen funciones para leerlos
Pila con memoria y con flujos
Transiciones
•
•
•
•
•
•
•
•
•
•
< xin, out, mem, pila, get::cont> < in, out, mem, x::pila, cont>
< in,out,mem, x::pila, put::cont> < in, outx, mem,pila, cont>
< in, out, mem, pila, pushV(i)::cont> < in, out, mem, mem[i]::pila, cont>
< in, out, mem, x::pila, asgmem(i)::cont> < in, out, mem[x/i], pila, cont>
< in, out, mem, pila, push(v)::cont> < in, out, mem, v::pila, cont>
< in, out, mem, x::pila, pop::cont> < in, out, mem, pila, cont>
< in, out, mem, y,x::pila, plus::cont> < in, out, mem, (x+y)::pila, cont>
< in, out, mem, y,x::pila, minus::cont> < in, out, mem, (x-y)::pila, cont>
< in, out, mem, y,x::pila, div::cont> < in, out, mem, (x/y)::pila, cont>
< in, out, mem, y,x::pila, times::cont> < in, out, mem, (x*y)::pila, cont>
Pila con memoria: Continuación
•
•
•
•
•
•
< in, out, mem, y,x::pila, LT::cont> < in, out, mem, (x<y)::pila, cont>
< in, out, mem, y,x::pila, LTE::cont> < in, out, mem, (x<=y)::pila, cont>
< in, out, mem, y,x::pila, GT::cont> < in, out, mem, (x>y)::pila, cont>
< in, out, mem, y,x::pila, GTE::cont> < in, out, mem, (x>=y)::pila, cont>
< in, out, mem, y,x::pila, EQ::cont> < in, out, mem, (x==y)::pila, cont>
< in, out, mem, y,x::pila, GTE::cont> < in, out, mem, (x!=y)::pila, cont>
Extendiendo la máquina
• Se permiten saltos condicionales y no
condicionales.
– Ya no basta tener el código como una
secuencia de instrucciones.
– Se tiene un vector de instrucciones (COD)
– Se tiene un contador del programa (PC)
– Para claridad se tiene también la instrucción
que está en la posición PC del código.
La máquina del lenguaje simple
•
•
•
•
•
•
Memoria
Pila
Flujos de entrada y de salida
Codigo (Cod)
Contador de programa (mem)
Instrucción que se va a ejecutar (cod[PC])
Instrucciones:
Explicación
Instrucción
Push <valor>
Empila el valor en la pila
PushV <dir>
ASGMEM <dir>
PLUS
SUB
TIMES
DIV
MOD
CHSIGN
AND
OR
NOT
LT
LTE
GT
GTE
EQ
NEQ
JMP <pos>
JMPT <pos>
JMPF <pos>
GET
PUT
End
Push mem[dir]
Mem[dir]=pop()
y:= pop() , x := pop(), push(x+y)
y:= pop() , x := pop(), push(x-y)
y:= pop() , x := pop(), push(x*y)
y:= pop() , x := pop(), push(x/y)
y:= pop() , x := pop(), push(x%y)
x=pop(), push(-x);
y:= pop() , x := pop(), push(x and y)
y:= pop() , x := pop(), push(x or y)
x=pop(), push(not x);
y:= pop() , x := pop(), push( x < y)
y:= pop() , x := pop(), push( x y)
y:= pop() , x := pop(),push( x > y)
y:= pop() , x := pop(),push( x y)
y:= pop() , x := pop(), push( x = y)
y:= pop() , x := pop(),push( x != y)
Salta a <pos>
y=pop(), si y es true salta a pos
y=pop(), si y es false salta a pos
Lee del stream de entada un entero y lo deja en el tope de la pila
X := pop() , imprime x en el stream de salida
Termina la ejecución
Descripción formal
•
xE,S,Mem,Pila,Cod,pc,“Get”
E,S,Mem,x::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,x::Pila,Cod,pc,“Put”
E,Sx,Mem,v::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,Pila,Cod,pc,“Push v”
E,S,Mem,v::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,Pila,Cod,pc,“PushVd”
E,S,Mem,Mem[d]::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,v::Pila,Cod,pc, “AsgMem d”
•
E,S,Mem,y::x::Pila,Cod,pc, “plus”
E,S,Mem,(x+y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “times”
E,S,Mem,(x*y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “sub”
E,S,Mem,(x-y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “div”
E,S,Mem,(x/y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “mod”
•
E,S,Mem, x::Pila, Codigo, pc, “chgsgn”
Mem[v/d],Pila,Cod,pc+1,Cod[pc+1]
E,S,Mem,(x%y)::Pila,Cod,pc+1,Cod[pc+1]
E,S,Mem,(-x)::Pila,Cod,pc+1,Cod[pc+1]
Descripción formal
•
E,S,Mem,y::x::Pila,Cod,pc, “and”
E,S,Mem,(x and y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “or”
•
E,S,Mem, x::Pila, Codigo, pc, “not”
•
E,S,Mem,y::x::Pila,Cod,pc, “LT ”
E,S,Mem,(x<y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “GT”
E,S,Mem, (x>y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “LTE ”
E,S,Mem,(x y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “GTE”
E,S,Mem,(x y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “EQ ”
E,S,Mem,(x=y)::Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,y::x::Pila,Cod,pc, “NEQ ”
•
E,S,Mem,Pila,Cod,pc, “jmp pos”
•
E,S,Mem,true::Pila,Cod,pc, “jmpT pos”
•
E,S,Mem,false::Pila,Cod,pc, “jmpT pos”
E,S,Mem,Pila,Cod,pc+1,Cod[pc+1]
•
E,S,Mem,false::Pila,Cod,pc, “jmpF pos”
E,S,Mem,Pila,Cod,pos,Cod[pos]
•
E,S,Mem,true::Pila,Cod,pc, “jmpF pos”
E,S,Mem,Pila,Cod,pc+1,Cod[pc+1]
E,S,Mem,(x or y)::Pila,Cod,pc+1,Cod[pc+1]
E,S,Mem,(not x)::Pila,Cod,pc+1,Cod[pc+1]
E,S,Mem,(x y)::Pila,Cod,pc+1,Cod[pc+1]
E,S,Mem,Pila,Cod,pos,Cod[pos]
E,S,Mem,Pila,Cod,pos,Cod[pos]
Otra máquina
•
•
•
•
•
Memoria Global
Marcos de Ejecución
Código
Contador de programa
Pila
¿Qué se debería poder definir?
Ahora un micromundo sencillo
Considere que tenemos ciertos métodos modificadores
para el micromundo:
M1, .. . Mn
Y unas selectoras que devuelven valores relacionados con
el mundo.
S1, …, Sm
Podemos suponer que el estado de la máquina es el
estado del micromundo y el estado de las estructuras de
la máquina.
Además de las instrucciones que modifican en estado de la
máquina debe haber instrucciones que modifican el
estado del robot.
HORIZ:
VERT:
PUT:
PUTB:
PICK:
PICKB:
X =pop(), el robot se mueve horizontalmente X
X =pop(), el robot se mueve verticalmente X
X =pop(), el robot pone X fichas
X =pop(), el robot pone X globos
X =pop(), el robot recoge X fichas
X =pop(), el robot recoge Y fichas
PUSHB
Empila el número de globos que hay en la casilla donde se encuentra el robot
ANY_BALLOONS: Si hay globos en la casilla donde está empila TRUE; empila FALSE de lo
contrario
ANY_CHIPS:
Si hay una ficha en la casilla donde está empila TRUE; empila FALSE de lo
contrario
HAS_BALLOONS: Si el robot tiene globos en su bolsa empila TRUE; empila FALSE de lo
contrario
HAS_CHIPS:
Si el robot tiene fichas en su bolsa empila TRUE; empila FALSE de lo
contrario
AT_NORTH:
Si el robo testá en el extremo norte del mundo empila TRUE; empila FALSE
de lo contrario
AT_SOUTH:
Si el robot está en el extremosur del mundo empila TRUE; empila FALSE de
lo contrario
AT_EAST:
Si el robot está en el extremo este del mundo empila TRUE; empila FALSE de
lo contrario
AT_WEST:
Si el robot está en el extremo oeste del mundo empila TRUE; empila FALSE
de lo contrario
La clase robot
Summary
void moverDirs(java.awt.Point pasos)
Para mover al robot sobre el mundo
void moverHorizontal(int pasos)
Para mover el robot horizontalmente sobre el mundo
void moverVertical(int pasos)
Para mover el robot verticalmente sobre el mundo
void ponerFichas(int f)
Para poner fichas
void ponerGlobos(int g)
Para poner globos.
void recogerFichas(int f)
Para recoger fichas
void recogerGlobos(int g)
Para recoger globos
Method Summary
int contarGlobos()
Devuelve el numero de globos que hay en la posicion actual.
int contarGlobos(java.awt.Point p)
Devuelve el numero de globos que hay en el punto dado.
boolean estaAbajo()
Devuelve true si el robot se encuentra en la ultima fila del
mundo, false de lo contrario.
boolean estaArriba()
Devuelve true si el robot se encuentra en la primera fila del
mundo, false de lo contrario.
boolean estaDerecha()
Devuelve true si el robot se encuentra en la ultima columna
del mundo, false de lo contrario.
boolean estaIzquierda()
Devuelve true si el robot se encuentra en la primera columna
del mundo, false de lo contrario.
Method Summary
int getMisFichas()
Devuelve los globos que tiene el robot
int getMisGlobos()
Devuelve los globos que tiene el robot
int getN()
Devuelve la dimensión del mundo
Point getPoscion()
Devuelve la posición del robot
boolean hayFicha()
Devuelve un valor para decir si hay ficha en el punto donde
esta el robot
boolean hayFicha(java.awt.Point p)
Devuelve un valor para decir si hay ficha en un determinado
punto
boolean hayGlobos()
Devuelve true si existe por lo menos un globo en la posición
actual.