Bueno, pues mi acer one no lee tarjetas, genial, encontre este tutorial en el que basicamente tienes que cambiar en /etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT=”quiet splash”
por esta otra linea
GRUB_CMDLINE_LINUX_DEFAULT=”quiet splash pciehp.pciehp_force=1″
Y siempre que arranques con la tarjeta metida pues te la reconoce, en caso contratio, pues metela y reinicia again.
El espectaculo en si se llama Otsoko, por la compañia Gaitzerdi
Siguiendo mi espiral cultirizante (de la mano de mi guia espiritual) acabamos en la alameda viendo un remake del clasico de caperucita. Bueno, ya sabeis como va esto del teatro moderno, mas o menos a la mitad me di cuenta de que era caperucita porque habia una chica vestida de rojo, y una abuelita … y un par de lobos.
La cosa prometía pero bien, comenzaron entre el publico, con luces en la columna vertebral y bozales, gruñendo, ladrando y en muletas. Vamos, que lo petó.
Luego pusieron un monton de palos en un escenario movil, y lo mejor es que se subieron y brincaron y hicieron algo parecido a pool-dancing (léa creia que lo de la danza vertical no era por eso, pero bueno … ). Luego prendieron fuego al suelo
y se pusieron a jugar a los coches locos, lo que tambien estuvo bien.
Finalmente se pusieron a bailar mientras les echaban agua. Lo que también estuvo muy bien 
.
Para mas informacion pinchar aqui
Fuimos (léa, yo y sus compis del centro de artes escenicas) al Lope de Vega a ver este espectaculo de clown. y WOw, estan loquiiiiiiiiiiiiisimos. Los notas pusieron una telaraña gigante sobre nuestras cabezas y tiraron miles de millones de papelitos como si fuera nieve, y corrieron entre el publico mojandolos a todos con botellas de agua. Loquiiiiiiisimos , y a l final se les fue la olla y simularon un alud, y realmente, era un alud de papelitos mogollooooooooonicos. Vamos, que nos lo pasamos genial, Om se me olviaba, al final tiraban al publico unas bolas gigantes!!!!!. y bueno, pues a rebotar dentro del teatro, no se de donde las sacaron, pero habia algunas realmente grandes!!!!
Aqui van algunas fotos sacadas al final del espectaculo con mi htc-magic.
Así es amigos, al quitar la tarifa plana vodafone 12€ en mi fantástico HTC Magic, me quede sin enviar/recibir mms, despues de una llamada (58 cents) al 22155 (servicio técnico de vodafone para adsl) y de un rato me dieron esta solución
menu -> ajustes -> conexiones inalambricas ->redes moviles -> apn ->
menu -> APN nuevo.
Introducir los siguientes parametros:
nombre: mms gprs
APN: mms.vodafone.net
Nombre usuario: wap@wap
contraseña: wap 125
servidor: http://mmsc.vodafone.es/servlets/mms
proxy MMS: 212.073.032.010
Puerto MMS: 80
MCC: 214
MNC: 01
Los demas valores dejarlos en blanco. En verdad es la misma que te trae por defecto salvo el proxy, pero bueno, es gratis tener mas de uno …
Y ya tendreis mms de nuevo en vuetro movil.
== Compilador ==
===Análisis Léxico ===
=== Análisis Sintático ===
===Resolución de Nombres ===
=== Análisis Semántico ===
Funciones del Análisis Semántico
====AS_Literal ====
Asignamos a cada Token final un nodo de su tipo
Atr_Expr AS_Literal (AST lit){
AST tipo = null;
switch ( lit.getType() ) {
case LIT_ENTERO:
tipo = #(#[ENTERO, "entero"]);
break;
case LIT_REAL:
tipo = #(#[REAL, "real"]);
break;
case LIT_CAR:
tipo = #(#[CARACTER, "caracter"]);
break;
case CIERTO:
tipo = #(#[LOGICO, "logico"]);
break;
case FALSO:
tipo = #(#[LOGICO, "logico"]);
break;
case NULO:
tipo = #(#[NULO, "nulo"]);
break;
default:
Errores = true;
GestorErrores.printString(“AS_Literal, no valido “,lit);
break;
}
return new Atr_Expr(tipo, false, true);
}
====AS_AccesoSimple====
Resolvemos cada acceso dependiendo del tipo del que sean.
Atr_Expr AS_Acceso_Simple (AST dec){
if (dec == null){
Errores = true; GestorErrores.printString(“La declaracion es NULL”);
return null;
}
switch ( dec.getType() ) {
case MODULO:
Errores = true; GestorErrores.printString(“Aqui no se deberia Acceder a Modulo”,dec);
return null;
case CLASE:
return new Atr_Expr(dec, false, false);
case ATRIBUTO:
return new Atr_Expr(dec.getFirstChild().getNextSibling(), true, true);
case METODO:
return new Atr_Expr(dec.getFirstChild(), false, false);
case PARAMETRO:
return new Atr_Expr(dec.getFirstChild().getNextSibling(), false, true);
case VARIABLE_LOCAL:
return new Atr_Expr(dec.getFirstChild().getNextSibling(), true, true);
default:
Errores = true;
GestorErrores.printString(“Declaracion de Acceso no valido”);
return null;
}
}
==== AS_Asignacion ====
;*Aqui es donde comprobamos que las dos ramas son del mismo TIPO
void AS_Asignacion(Atr_Expr e1, Atr_Expr e2){
if(e2 == null || e1 == null){
Errores = true;
GestorErrores.printString(“Se esperaba un valor distinto de null”);
}else {
*;Comprobamos LVal y RVal
if (!e1.getLVal()){
Errores = true; GestorErrores.printString(“No tiene LVal: “+ e1.getTipo().getText(), e1);
}
if (!e2.getRVal()){
Errores = true; GestorErrores.printString(“No tiene RVal: “+ e2.getTipo().getText(), e2);
}
*;Comprobamos que sean del mismo tipo
if (!e1.getTipo().equals(e2.getTipo())){
if (e1.getTipo().getType() == CLASE){
if (e2.getTipo().getType() != NULO){
Errores = true;
GestorErrores.printString(“Solo se puede asignar una CLASE “+ e1.getTipo().getText()+” != “+ e2.getTipo().getText(), e1);
}
}else{
Errores = true; GestorErrores.printString(“Diferentes tipos: “+ e1.getTipo().getText()+” != “+ e2.getTipo().getText(), e1);
}
*;Ahora comprobamos especificamente a FORMACION
}else {
if (e1.getTipo().getType() == FORMACION){//TODO comparar recursivamente equaltree es mu chano, hacer una comprobacion MEJOR
if ( !e1.getTipo().equalsTree(e2.getTipo())){
Errores = true; GestorErrores.printString(“Diferentes tipos en FORMACION: “+ e1.getTipo().getText()+” != “+ e2.getTipo().getText(), e1 );
}
}
*;Y a Clase
if (e1.getTipo().getType() == CLASE){
if (e2.getTipo().getFirstChild().getType() == CLASE){
e2.setAST(e2.getTipo().getFirstChild().getNextSibling());
}
if(!e1.getTipo().getFirstChild().equals(e2.getTipo().getFirstChild())){
Errores = true; GestorErrores.printString(“Diferentes tipos de CLASE: “+ e1.getTipo().getFirstChild().getText()+” != “+ e2.getTipo().getFirstChild().getText(), e1);
}
}
}
}
}
==== AS_Condicion ====
*;RVal
void AS_Condicion (Atr_Expr e){
if (!e.getRVal()){
Errores = true; GestorErrores.printString(“AS_Condicion, No tiene RVal: “,e);
}
*;Mismo Tipo
if (e.getTipo().getType() != LOGICO){
Errores = true; GestorErrores.printString(“AS_Condicion, NO es del tipo Logico: “,e);
}
}
==== AS_Devolucion ====
*;RVal
int AS_Devolucion (AST tipo_dev, Atr_Expr e, int cont_dev){
if (!e.getRVal()){
Errores = true;
GestorErrores.printString(“No tiene RVal: “,e);
}
*;Que devuelva algo
if (cont_dev == -1){
Errores = true;
GestorErrores.printString(“No devuelve NADA: “,tipo_dev);
}
*;Si es tipo formación que sea la misma FORMACION
if (tipo_dev.getType() == FORMACION){
if (!tipo_dev.equalsTree(e.getTipo())){
Errores = true;
GestorErrores.printString(“Diferentes tipos de Formaciones “+e.getTipo().getText()+” != “+tipo_dev.getText(), tipo_dev);
}
}
*;Si es tipo clase que sea la misma CLASE ó NULO
if (tipo_dev.getType() == CLASE){
if (e.getTipo().getType() != NULO)// Si devuelve un nulo tiene que ser una CLASE
if (!tipo_dev.getFirstChild().equalsTree(e.getTipo().getFirstChild())){
Errores = true;
GestorErrores.printString(“Diferentes Clases “+e.getTipo().getText()+” != “+tipo_dev.getFirstChild().getText(), tipo_dev);
}
*;Que el TIPO_DEVUELTO sea del mismo tipo que el esperado
}else if (!tipo_dev.equals(e.getTipo())){
Errores = true;
GestorErrores.printString(“NO devuelve el tipo esperado: “+e.getTipo().getText()+” != “+ tipo_dev.getText(), tipo_dev);
}
;*Aumentamos en uno para que se sepa que al menos hay un dev
return cont_dev + 1;
}
==== AS_Acceso_Objeto ====
*;Comprobamos que la RAIZ sea de tipo CLASE
Atr_Expr AS_Acceso_Objeto (Atr_Expr atr_raiz, AST raiz, AST atrib){
AST tipo_raiz = atr_raiz.getTipo();
if (tipo_raiz.getType() != CLASE){//lo busco en la tabla de simbolos
Simbolo s = t.buscar_simbolo_esp(tipo_raiz.getText(),t.getAmbitoModulo());
if (s != null){//Conseguimos su declaracion
tipo_raiz = s.getDeclaracion();
}else{//error no es una clase
Errores = true; GestorErrores.printString(tipo_raiz.getText()+” No es de tipo CLASE”,atrib);
return null;
}
}
*;Comprobamos que la RAIZ sea de una clase INSTANCIABLE
AST aux = raiz.getFirstChild().getNextSibling().getFirstChild().getNextSibling();
if (aux.getType() == CLASE){
if (tipo_raiz.getFirstChild().getNextSibling().getType() != INST){
Errores = true;
GestorErrores.printString(tipo_raiz.getFirstChild().getNextSibling().getText()+” NO declarada INSTANCIABLE”, tipo_raiz );
return null;
}
}
*;Comprobamos que lo accecido PERTENECE a la clase
aux = tipo_raiz.getFirstChild().getNextSibling().getNextSibling();
while (aux != null){
if (aux.getType() == METODO){ //Es METODO
if (aux.getFirstChild().getFirstChild().equals(atrib)){
break;
}}else{ //Atributo
if (aux.getFirstChild().equals(atrib)){
break;
}
}
aux = aux.getNextSibling();
}
;*Ahora comprobamos que EXISTE y es VISIBLE
if (aux == null){ //No lo encontramos, fallo y salimos.
Errores = true; GestorErrores.printString(“El atributo: “+atrib.getText()+”, no pertenece a la clase”, tipo_raiz);
return null;
}else{//Ahora comprobamos que es visible
if(aux.getFirstChild().getNextSibling().getNextSibling().getType() != VISIBLE){
Errores = true; GestorErrores.printString(“El atributo “+atrib.getText()+” no es visible”, aux);
}
;*Devolvemos según lo encontrado
//Miramos a ver que es
if(aux.getType() == METODO){
return new Atr_Expr(aux.getFirstChild(),false,false);
}else{ //Es un Atributo
return new Atr_Expr(aux.getFirstChild().getNextSibling(),true,true);
}
}
}
==== AS_Llamada ====
Atr_Expr AS_Llamada(Atr_Expr atr_raiz, LinkedList expresiones){
ListIterator it = expresiones.listIterator();
if (atr_raiz == null){
Errores = true;
GestorErrores.printString(“La raiz deberia ser != NULL”);
return null;
}
;*Comprobamos que la RAIZ sea tipo PROTOTIPO
if (atr_raiz.getTipo().getType() != PROTOTIPO){
Errores = true; GestorErrores.printString(“La raiz no es un Metodo es :”+atr_raiz.getTipo().getText());
return null;
}
;*Ahora comprobamos los parametros formales y los que le paso coinciden en tipo
AST par_f = atr_raiz.getTipo().getFirstChild().getNextSibling().getFirstChild();
Atr_Expr par_r = null;
while(it.hasNext() && par_f != null){
par_r = (Atr_Expr)it.next();
if (par_r.getTipo().getType() == CLASE){
if(!par_f.getFirstChild().getNextSibling().getFirstChild().equalsTree(par_r.getTipo().getFirstChild())){//TODO equaltree??
Errores = true;
GestorErrores.printString(“El parametro formal “+ par_f.getFirstChild().getNextSibling().getFirstChild().getText()+” No se esperaba :”+par_r.getTipo().getFirstChild().getText());
}
}else{
if(!par_f.getFirstChild().getNextSibling().equalsTree(par_r.getTipo())){
Errores = true;
GestorErrores.printString(“El parametro formal “+ par_f.getFirstChild().getNextSibling().getText()+” No se esperaba :”+par_r.getTipo().getText());
}
}
par_f = par_f.getNextSibling();
}
;*Ahora comprobamos si coinciden en el numero
int numeroHijosFormales = atr_raiz.getTipo().getFirstChild().getNextSibling().getNumberOfChildren();
int numeroHijosReales = expresiones.size();
if (numeroHijosFormales < numeroHijosReales){
Errores = true;
GestorErrores.printString("En la llamda de: "+atr_raiz.getTipo().getFirstChild().getText()+", Hay mas parametros reales que formales", atr_raiz);
return null;
}else if (numeroHijosFormales > numeroHijosReales){
Errores = true;
GestorErrores.printString(“En la llamda de: “+atr_raiz.getTipo().getFirstChild().getText()+”, Hay mas parametros formales que reales”,atr_raiz);
return null;
}else{
;*Devolvemos el tipo esperado (prototipo return)
return new Atr_Expr(atr_raiz.getTipo().getFirstChild().getNextSibling().getNextSibling().getFirstChild(), false, true);
}
}
==== AS_Acceso_Tabla ====
Atr_Expr AS_Acceso_Tabla(Atr_Expr atr_raiz, LinkedList expresiones){
ListIterator it = expresiones.listIterator();
;*Comprobamos que es de tipo FORMACION
if (atr_raiz.getTipo().getType() != FORMACION){
Errores = true;
GestorErrores.printString(“La raiz no es una Formacion”,atr_raiz);
}
;*Ahora comprobamos los parametros formales y los que le paso coinciden en tipo
int tam = 0;
while(it.hasNext()){
tam++;
Atr_Expr d = (Atr_Expr)it.next();
if(d == null){
Errores = true;
GestorErrores.printString(“Se esperaba un valor distinto de null”,atr_raiz);
}else{
if(d.getTipo().getType() != ENTERO){
Errores = true;
GestorErrores.printString(“Se esperaba Entero”,atr_raiz);
}
}
}
;*Comprobamos que coinciden en Numero.
if (atr_raiz.getTipo().getFirstChild().getNumberOfChildren() != tam){
Errores = true; GestorErrores.printString(“Numero de argumentos no coinciden, se esperaban :”+tam, atr_raiz);
return null;
}
;*Le pongo RVal y LVal de la raiz.
return new Atr_Expr(atr_raiz.getTipo().getFirstChild().getNextSibling(),atr_raiz.getLVal(), atr_raiz.getRVal());
}
==== AS_Exp_Bin_Arit ====
;*Comprobamos que los dos tienen RVal
Atr_Expr AS_Exp_Bin_Arit(Atr_Expr l1, Atr_Expr l2){
if(!l1.getRVal()){
Errores = true; GestorErrores.printString(“No tiene RVal”, l1);
}
if (!l2.getRVal()){
Errores = true; GestorErrores.printString(“No tiene RVal”, l2);
}
;*Comprobamos que los dos sean del mismo tipo
if (!l1.getTipo().equals(l2.getTipo())){
Errores = true; GestorErrores.printString(l1.getTipo().getText()+” != “+l2.getTipo().getText(),l1);
}
*;Comprobamos que sea O entero o real
if((l1.getTipo().getType() != ENTERO) && (l1.getTipo().getType() != REAL)){
Errores = true; GestorErrores.printString(“Se esperaba Entero o Real”, l2);
return null;
}
*;RVal LVal
return new Atr_Expr(l1.getTipo(), false, true);
}
====AS_Exp_Bin_Log ====
*;Comprobamos que los dos tienen RVal
Atr_Expr AS_Exp_Bin_Log(Atr_Expr l1, Atr_Expr l2){
if(!l1.getRVal()){
Errores = true;
GestorErrores.printString(“No tiene RVal”, l1);
}
if (!l2.getRVal()){
Errores = true;
GestorErrores.printString(“No tiene RVal”, l2);
}
*;Comprobamos que los dos sean del mismo TIPO
if (!l1.getTipo().equals(l2.getTipo())){
Errores = true;
GestorErrores.printString(l1.getTipo().getText()+” != “+l2.getTipo().getText());
}
*;Comprobamos que sea ENTERO o REAL
if(l1.getTipo().getType() != LOGICO){
Errores = true;
GestorErrores.printString(“Se esperaba Logico”, l1);
return null;
}
*;RVal LVal
return new Atr_Expr(l1.getTipo(), false, true);
}
====AS_Exp_Bin_Rel====
=====IGUAL o DISTINTO=====
Atr_Expr AS_Exp_Bin_Rel(Atr_Expr e1, Atr_Expr e2, AST op){
if (e1 == null || e2 == null || op == null){
Errores = true;
GestorErrores.printString(“Encontrado NULL”);
return null;
}
;*Comprobamos RVal
if(!e1.getRVal()){
Errores = true; GestorErrores.printString(“No tiene RVal”, e1);
}
if (!e2.getRVal()){
Errores = true; GestorErrores.printString(“No tiene RVal”, e2);
}
;*Comprobamos que sean del mismo TIPO
if (!e1.getTipo().equals(e2.getTipo())){
Errores = true; GestorErrores.printString(e1.getTipo().getText()+” != “+e2.getTipo().getText(),e1);
}
;*Si es de tipo CLASE
if((e1.getTipo().getType() == CLASE) && !(e1.getTipo().equals(e2.getTipo()))){
Errores = true;
GestorErrores.printString(“Clases distintas “+e1.getTipo().getText()+” != “+e2.getTipo().getText(), e1);
return null;
}
;*Si es de tipo FORMACION
if (e1.getTipo().getType() == FORMACION && !(e1.getTipo().equalsTree(e2.getTipo()))){
Errores = true; GestorErrores.printString(“Diferentes tipos de FORMACION”, e1);
return null;
}
;*Si es de tipo LOGICO
if ((e1.getTipo().getType() == CLASE) || (e1.getTipo().getType() == LOGICO) || (e1.getTipo().getType() == FORMACION)){
if ((op.getType() != IGUAL) && (op.getType() != DISTINTO)){
Errores = true;
GestorErrores.printString(“Para las Clases o Logicos o Formaciones solo se aceptan == o !=”);
return null;
}
}
;*LOGICO, RVal LVal
return new Atr_Expr(#(#[LOGICO, "logico"]), false, true);
}
=====OTRAS=====
Atr_Expr AS_Exp_Bin_Rel(Atr_Expr e1, Atr_Expr e2){
if (e1 == null || e2 == null){
Errores = true;
GestorErrores.printString(“Encontrado NULL”);
return null;
}
;*Comprobamos RVal
if(!e1.getRVal()){
Errores = true;
GestorErrores.printString(“No tiene RVal”, e1);
}
if (!e2.getRVal()){
Errores = true;
GestorErrores.printString(“No tiene RVal”, e2);
}
*;Que sean del mismo TIPO
if (!e1.getTipo().equals(e2.getTipo())){
Errores = true;
GestorErrores.printString(e1.getTipo().getText()+” != “+e2.getTipo().getText(),e1);
}
*;Si es de tipo CLASE
if((e1.getTipo().getType() == CLASE) && (e1.getTipo().getFirstChild().equals(e2.getTipo().getFirstChild()))){
Errores = true;
GestorErrores.printString(“Clases distintas “+e1.getTipo().getText()+” != “+e2.getTipo().getText(),e1);
return null;
}
*;Si es de tipo FORMACION
if (e1.getTipo().getType() == FORMACION){
Errores = true;
GestorErrores.printString(“No puede ser de tipo FORMACION”, e1);
return null;
}
;*LOGICO, RVal LVal
return new Atr_Expr(#(#[LOGICO, "logico"]), false, true);
}
”’NOTAS:”’hay que hacer el equalsTree empepinao: clases (getFC), formacion equaltree (y si es una clase el tipo base?? pues no furula, equaltree a lado izq y al tipo base si es una clase miramos el nombre, si no pos equaltree)
====AS_Exp_Una_Arit====
*;Comprobamos que tiene RVal
Atr_Expr AS_Exp_Una_Arit(Atr_Expr e){
if(!e.getRVal()){
Errores = true;
GestorErrores.printString(“No tienen Rval”, e);
}
*;Que sea de tipo ENTERO REAL
if ((e.getTipo().getType() != ENTERO) && (e.getTipo().getType() != REAL)){
Errores = true;
GestorErrores.printString(“No es ni Entero ni Real”,e);
}
*;Devolvemos el tipo, LVal, RVal
return new Atr_Expr(e.getTipo(),false,true);
}
====AS_Exp_Una_Log====
*;Comprobamos RVal
Atr_Expr AS_Exp_Una_Log(Atr_Expr e){
if(!e.getRVal()){
Errores = true;
GestorErrores.printString(“No tienen Rval”, e);
}
*;Que sea de tipo LOGICO
if (e.getTipo().getType() != LOGICO){
Errores = true;
GestorErrores.printString(“No es de tipo logico”, e);
}
*;Devolvemos el tipo y LVal, RVal
return new Atr_Expr(e.getTipo(),false,true);
}
=== Generación de Código ===
= Api de [[Jamaica]].=
== Instalación ==
Pagina de Descarga del puglin de eclipse para CORBA [http://www.orbzone.org/?page_id=68]
=== Ubuntu.===
*Descomprimir
*buscar el .jar
*meterlo en
/usr/lib/eclipse/plugins
* Reiniciar Eclipse
=== Arch ===
*Descomprimir
*buscar el .jar
*meterlo en
/usr/share/eclipse/plugins
* Reiniciar Eclipse
== Servicios CORBA ==
*Implementan funciones de bajo nivel de uso habitual
*Interfaz estandarizada
*Implementación de cada servicio es opcional
*Algunos servicios definidos en estándar:
**Servicio de nombres
**Servicio de localización
**Servicio de eventos
**Servicio de propiedades
== Notas Generales ==
===Permite definir:===
*Interfaces, compuestas por
**Atributos
**Operaciones
*Tipos y constantes
*Excepciones
*Agrupaciones de todo lo anterior (módulos)
===Aspectos léxicos===
*Mayúsculas y minúsculas:
**en un mismo ámbito, dos identificadores no se pueden diferenciar sólo en su uso
*Toda declaración termina en “;”
*Comentarios:
**Estilo C++: // comentario hasta final de línea
**Estilo C: /* Comentario hasta cierre de comentario */
*Existe preprocesador léxico:
#define, #include, #ifdef…#endif, #ifndef…#endif, etc.
*Normalmente: archivos con terminación “.idl”
== Tipo Interfaz ==
*Es un tipo compuesto en IDL
*Define una interfaz de objetos
*Mapping: se traduce a una interfaz Java
**El traductor genera cierta infraestructura para cada interfaz
Sintaxis de la declaración básica:
interface nombre
{
// declaración de atributos
[readonly] attribute tipo nombre_atributo;
readonly attribute long contador;
attribute string nombre;
// declaración de operaciones
[oneway] tipo nombre_operacion (modo tipo nombre_param1, …);
long calculo (in long a, in long b);
void generar (inout long clave, out string resultado);
oneway void registrar (in string nombre);
};
*No existen
**Constructores
**Destructores
**Modificadores de acceso (private, public, protected)
*Mapping atributos:
**Una operación de lectura y otra de escritura (si no readonly)
interface nombre
{
attribute contador
…
interface nombre
{
int contador(); // Accessor
void contador(int value); // Mutator
…
interface nombre
{
readonly attribute long contador;
..
interface nombre
{
int contador(); // Accessor
…
== Tipos Predefinidos ==
*void : void
*boolean : boolean
*char : char
*wchar : char
*float : float
*double : double
*long double : double
*long : int
*long long : long
*unsigned long : int
*unsigned long long : long
*short : short
*unsigned short : short
*octet : byte
*string : String
== Constantes ==
* Sintaxis:
const tipo nombre = valor;
*Se pueden declara
**Dentro de una interfaz
**Fuera de cualquier interfaz
*Mapping:
const tipo nombre=valor;
interface nombre
{
public static final tipo value=valor;
}
interface nombreInterface
{
const tipo nombre=valor;
…
}
interface nombreInterface
{
public static final tipo nombre=valor;
…
}
== Tipos Compuestos ==
*Sintaxis
enum nombre_enumerado {literal1, literal2, … literaln};
*Mapping
public class nombre_enumerado implements org.omg.CORBA.portable.IDLEntity
{
private int __value;
…
public static final int _literal1 = 0;
public static final nombre_enum literal1 = new nombre_enum(_literal1);
…
protected nombre_enum (int value)
{
__value = value;
…
}
=== Enumerados ===
*No se puede suponer relación de orden entre los literales
nombre_enumerado var1= nombre_enumerado.literal1;
nombre_enumerado var2= var1;
…
if (var1 == var2) //Cierto si var1 y var2 apuntan al mismo objeto
=== Estructuras ===
*Sintaxis
struct nombre_structura
{
tipo1 campo1;
…
tipon campon;
};
*Mapping
public final class nombre_struct implements org.omg.CORBA.portable.IDLEntity
{
public tipo1 campo1 = …;
…
public nombre_struct (tipo1 _campo1, …)
{
campo1 = _campo1;
…
} …
== Creación de tipos==
*Sintaxis
typedef tipo nombre_tipo;
*Uso principal: tipos contenedores
**Sólo se pueden crear mediante typedef
== Tipos Contenedores ==
===Arrays===
*Los atributos de tipo array deben declararse mediante typedef
*Sintaxis
typedef tipo_base tipo_array [tamaño];
…
interface I
{
attribute tipo_array atributo1;
…
};
*Tamaño de array siempre es fijo
===Secuencias===
*Secuencia: sucesión de elementos del mismo tipo (lista)
*Los atributos de tipo secuencia deben declararse mediante typedef
*Dos tipos de secuencias:
**Limitadas (bounded)
**Ilimitadas (unbounded)
*Sintaxis
typedef sequence
typedef sequence
…
interface I
{
attribute tipo_secuencia atributo1;
…
*¡Una referencia nula a un array java no es una secuencia ni un array válido!
== Herencia ==
*IDL soporta herencia múltiple
*Sintaxis
interface A interface B
{ {
… …
}; };
interface C:A,B
{
…
};
*Los métodos no se pueden…
**Sobrecargar
**Redefinir
**Ocultar
*Si se emplea herencia múltiple: no se puede heredar de clases con nombres coincidentes de atributos y/o operaciones
== Excepciones ==
*Las operaciones de los objetos CORBA pueden lanzar excepciones
**Excepciones se lanzan en servidor y se capturan en cliente
*IDL permite por tanto:
**Declarar tipos de excepciones
**Declarar qué excepciones puede lanzar cada operación
*Sintaxis de declaración de tipo excepción:
exception nombre
{
tipo_campo1 campo1;
tipo_campo2 campo2;
…
};
exception otraexcepcion { };
*Sintaxis de declaración de excepciones lanzadas por una operación
interface nombre_interface
{
tipo nombre_oper (modo tipo nombre_param1, …) raises (excep1, excep2…);
…
};
*Mapping
exception nombre
{
tipo_campo1 campo1;
tipo_campo2 campo2;
…
};
== Módulos ==
*Módulo=agrupación lógica de declaraciones en IDL
**Puede contener declaraciones de todo lo expuesto hasta el momento (incluso módulos)
*Sintaxis
module nombre
{
// declaraciones IDL
…
};
*Mapping: paquetes Java
**Por cada módulo, se genera un paquete de mismo nombre
**Todo lo declarado en dicho módulo se incluye dentro de dicho paquete
== Uso del Traductor idlj ==
Terminología:
*Sirviente (servant): Objeto que implementa una (o varias) interfaces IDL.
*Servidor (server): Programa que crea sirvientes y los hace accesible a los clientes.
*Cliente (client): Programa que hace uso de algún sirviente
Sirviente de puede crear de dos formas:
*Herencia
*Delegación
Línea de comandos de idlj (versión 3.2 o posterior):
idlj [opciones] archivos.idl
=== Opciones más habituales===
*fclient: genera sólo infraestructura para lado cliente.
*fserver: genera sólo infraestructura para construir lado servidor mediante herencia.
*fserverTIE: genera sólo infraestructura para construir lado servidor mediante delegación.
*fall: genera infraestructura para lados cliente y servidor (lado servidor mediante herencia)
*fallTIE: genera infraestructura para lados cliente y servidor (lado servidor mediante delegación)
*oldImplBase: genera infraestructura para lado servidor basado en BOA en lugar de POA
=== Archivos generados tanto para lado cliente como servidor===
* *Operations.java:
Intefaz Java resultante de aplicar las reglas de mapping IDL a Java a la interfaz traducida.
* *.java:
**Interfaz CORBA que verán los clientes
**Hereda de *Operations (tiene todas las operaciones de Interfaz)
**Hereda de org.omg.CORBA.Object (superclase común a todos los objetos CORBA)
=== Archivos generados para lado cliente:===
*_*Stub.java:
**Se usa de forma transparente (actúa como representante local en el cliente del objeto CORBA remoto).
**Sólo necesaria para compilar.
**Obsérvese que implementa las operaciones de la interfaz.
* *Holder.java:
**Clase que actúa como clase corbertura
**Se genera una clase Holder para cada…
***Tipo definido por usuario en IDL
***Tipo predefinido, si es necesario (por ejemplo, por usarse como argumento out/inout)
**Contiene:
***atributo “value”
***Constructores
* *Helper.java:
**Clase abstracta que se genera en mismas circunstancias que clase Holder.
**Proporciona algunos métodos útiles para la manipulación del tipo.
método narrow()
== API de Jamaica ==
Referencia a Instrucciones de Jamaica [http://www.koders.com/java/fid0822E1FC7F97F9C9E71EE0D57E75300D6AE9789E.aspx?s=mdef%3ainsert] [http://www.koders.com/info.aspx?c=ProjectInfo&pid=51FCBXUX92GLVFLU8LYU2D2F4E]
Para compilar
Bcel[http://www.lsi.us.es/docencia/get.php?id=2209]
Common-lang[http://www.lsi.us.es/docencia/get.php?id=2210]
Jamaica[http://www.lsi.us.es/docencia/get.php?id=2208]
Fichero .bat para ensamblar[http://www.lsi.us.es/docencia/get.php?id=2236]
== Reglas Léxicas en Jamaica ==
* Comentarios Igual que en Java
* Identificadores Igual que en Java
* Palabras reservadas Igual que en Java
– int
– short
– long
– double
– float
– String
– …
* Tipos de datos Igual que en Java
* Macros
Comienzan por %
* Las instrucciones ByteCode y Macros no terminan en ;
== Paquetes y Clases ==
Se definen igual que en Java. Cada clase en un fichero.ja con la siguiente estructura.
package nombrePaquete ;
(import paquetesImportados)* // de base tenemos java.lang, java.io, java.util
[public|private] class NombreClase{
atributos
metodos
}
Los atributos se declaran igual que en java, pero NO se pueden inicializar en la declaración.
Cuidado con las Formaciones.
formacion 10 entero b => int b[10] esto no reservaría espacio, habria que llamar a un constructor.
Cuando una clase no tiene constructor podemos usar el constructor de la clase padre == Métodos == == Instrucciones == === Carga de Constantes === === Accesos a variables y parámetros === aload_0 === Operaciones con Arrays === int iarr[4]; int a[3][3]; === Acceso a Atributos === ClaseNoInstanciable.atr1 = Objeto1.atr2; === Instrucciones de tipos de datos === ====Tipos de Datos ==== ====Comprobar tipos==== === Creación de Objetos === int a[9]; String S[8]; === Creacion de Arrays Multidimensionales === === Instrucciones Aritmeticas Logicas === ==== Incremento==== === Manipulación de la Pila === === LLamadas a métodos === a.m(3*a); === Instrucciones de saltos Incondicionales === === Instrucciones de salto Condicionales === si (a <=3) entonces{ ==== Comparación de Objetos y Saltos ==== ==== Comparación de Long, Float y Double ==== == Macros == ===set=== ===object=== ===arrays===
%default_constructor
*Prototipo Igual que Java
* El cuerpo (Dec_Variable | [Etiqueta:] Instruccion)* (ClausulaCatch)*
int m1(int a){
…
}
– Declaración de Variables igual que en java
– Declaración de Variables deben declararse antes de su uso.
– Los parametros se tratan igual que las variables.
– Instrucciones son ByteCode o macros.
* Clausula Catch para capturar/manipular excepciones
catch [NombreClase] (EtiquetaIni, EtiquetaFin)
EtiquetaMan
– NombreClase : Tipo de excepción, si no se especifica captura java.lang.throwables.
– EtiquetaMan: Comienzo del bloque de manipulación.
– EtiquetaIni, EtiquetaFin:Comienzo y fin del bloque de captura.
=== Notación de Instrucciones ===
(PilaAntes => PilaDespues)
Cargar -> Apila en la cima de la pila
Almacenar -> Extrae un elemento de la cima.
*aconst_null: carga la referencia ( … => …,null)
*bipush: carga entero byte ( … => …,numero)
*iconst_m1: carga entero -1 ( … => …,-1)
*sipush numero: carga entero short ( … => …,numero)
*lconst_0|1: carga long 0|1 ( … => …,0)|( … => …,1)
*fconst_0|1|2: carga float 0|1|2 ( … => …,0.0)|( … => …,1.0)|( … => …,2.0)
*dconst_0|1: carga double 0|1 ( … => …,0)|( … => …,1)
*ldc valor: carga valor en la cima
ldc 3 //iconst_3
ldc 12983 //int
ldc 5.5 //double
ldc (float)5.5//float
*
*
var = par;
iload par (… => …,par)
istore var (…,par => …)
aload this //carga una referencia al objeto actual (…=>…,this)
*
*
*arraylength -> carga el nº de compònentes de un array (…, refArray => …,numComponentes)
iarr[3] = iarr[1];
aload iarr //(…=>…,iarr)
iconst_3 // (…iarr=>…iarr,3)
aload iarr // (…iarr,3=>…iarr,3,iarr)
iconst_1 // (…iarr,3,iarr=>…iarr,3,iarr,1)
iaload //(…iarr,3,iarr,1=>…iarr,3,iarr[1])
iastore // (…iarr,3,iarr[1]=>…)
a[2][3];
aload a // (…=>…,a)
iconst 2 // (..,a=>…,a,2)
aaload // (…,a,2=>…,a[2])
iconst 3 // (…,a[2]=>…,a[2],3)
iaload // (…,a[2],3=>…,a[2][3])
====Atributo no estático====
Necesita tener cargada la referencia a los objetos
*getfield nombreAtributo tipoAtributo: (…,refObjeto=>…,valorAtributo)
*putfield nombreAtributo tipoAtributo: Almacena el valor de un atributo (…,refObjeto,valor=>…)
====Atributo estático. ====
*getstatic NombreClase.nombreAtributo tipoAtributo:
Carga un atributo estático NombreClase.atributo(…=>…,valorAtributo)
*putstatic NombreClase.nombreAtributo tipoAtributo:
Almacena un valor en un atributo estático (…,valor => …)
aload Objeto1 // (…=>…,Objeto1)
getfield atr2 int // (…,Objeto1=> …,Objeto1.atr2)
aload ClaseNoInstanciable
putstatic ClaseNoInstanciable.atr1 int // (…,Objeto1.atr2=>…)
*d : double
*l : long
*i : int
*a : ref
====Conversion de tipos numericos====
* De entero a: (long,float,byte,short)
i2l i2f i2b i2s
* De long a : (int,floar,double)
l2i l2f l2d
* De float a : (int,long,double)
f2i f2l f2d
* De dobule a: (int,long,float)
d2i d2l d2f
*instaceof nombreClase
(…,refObjeto=> …,0) Si objeto No pertenece a una Clase
(…,refObjeto=> …,1) Si objeto Si pertenece a una Clase
*new nombreClase :
Crea un objeto en el monton y apila una refencia aél.
(…=>…,refObjeto)
A a;
a = crear(A);
new A // (…=>…,A)
astore a // (…,A=> …)
=== Creación de Arrays Unidimensionales ===
*newarray tipoPrimitivo :
crea un array del tipoPrimitivo en el montón y apila una referencia.
(…,numElementos => …,refArray)
*anewarray nombreClase :
crea un array de objetos en el monton y apila una referencia.
(…,numComponentes=>…,refArray)
bipush 9 // (…=>…,9)
newarray int //(…,9=>…,refArray)
astore a // (…,refArray=> …)
bipush 8 // (…=>…,8)
anewarray String // (…,8=>…,refArray)
astore S // (…,refArray=> …)
*multyarray tipo_datos([])+ nº dimensiones: (…,Componente1,Componente2,…=>…,refArray)
byte b[10][8];
bipush 10 // (…=>…,10)
bipus 8 // (…,10 => …,10,8)
multinewarray byte[][] 2 (…,10,8=>…,refArray)
astore b // (…,refArray=>…)
==== Aritmeticas ====
*
*
*
*
*
==== Logicas====
*and (…,op1,op2 => op1&&op2)
*or (…,op1,op2 => op1||op2)
*xor (…,op1,op2 => op1xorop2)
*iinc variable incremento
iinc a 3
* pop (…, x => …)
* dup (…,x => …,x,x)
* swap (…,x,y => …,y,x)
Antes de la llamada hay que cargar la referencia al objeto y los parametros reales. (…,reObjeto,parReal1,…,parRealN => …,refObjeto,parReal1,…,parRealN,varLocal1,…,varLocalN,)
Al hacer la llamada se cambia de frame activo al frame del método.
*(invokevirtual | invokespecial | invokestatic) [NombreClase.]nombreMetodo Signatura
** (invokevirtual | invokespecial | invokestatic) : metodo no estático | super clase o constructor | metodo estático.
** Signature : ([TipoDato(, TipoDato)*])TipoDato, rango y dominio.
invokevirtual elemento.modificar(int) void //cambia el frame activo
invokespecial super() void
aload a // (…=>…,this)
iconst_3 // (…,this => …,this,3)
iload a // (…,this,3 => …,this,3,a)
imul // (…,this,3,a => …,this,a*3)
invokevirtual m(int) void (…,this,3*a => …,this,3*a,VARIABLES LOCALES)
*goto etiqueta : Salto a la etiqueta.
*return : vuelta de procecimiento.
*
*jsr etiqueta : salto subrutina dentro de un metodo.
*ret : vuelta de una subrutina.
==== Salto Condicional ====
*if_icmp
** -1|0|1 : menor | igual | mayor
**
...
}
//suponemos que a<=3 ya se ha resuelto
if_icmgt etiqueta1
...
etiqueta1:
* if_acmpeq etiqueta (...,refObj1,refObj2 => …)
* if_acmpne etiqueta (…,refObj1,refObj2 => …)
* if_null etiqueta (…,refObj1 => …)
* if_nonull etiqueta (…,refObj1 => …)
*lcomp (…,op1,op2 => …,-1|0|1)
*fcomp (…,op1,op2 => …,-1|0|1)
*dcomp (…,op1,op2 => …,-1|0|1)
===print ===
*(%print|%println) [out|err] [par(, par)*]
** par: cualquier cosa que vayamos a escribir
%println a,” “,3
%load Par // (… => …, par)
%load a // (…,par => …,par,a) no me preocupa lo que sea, yo solo lo cargo
%load 3 // (…,par.,a => …,par.,a,3)
* %set Par = Par
a = 3;
%set a = 3
%set a = 3 * b //ERROR!!!!
Se usa para CREAR objetos, invoca al contructor y devuelve una referencia al objeto creado.
* %object NombreClase (… => …,refObjeto)
* array [NombreClase | TipoPredefinidoSimple] ([CteEntera])+ (… => …,refArray)
%array int[3][4]
*array_iterate NombreArray VarIndice %end_iterate
int[] arr;
int indx;
%array int [4]
astore arr
%array_iterate arr idx
%println “arr[",indx,"]=”,arr[idx]
%end_iterate
Así es amigos, el cabrón peta al hacerlo desde la web, quien se lo iba a pensar.
Para hacerlo manualmente te lo bajas de aqui , luego lo copias en (mi caso)
sudo cp ejade.tar /usr/lib/eclipse/plugins/
sudo tar -xf /usr/lib/eclipse/plugins/ejade.tarsudo rm /usr/lib/eclipse/plugins/ejade.tar
Así es amigos, se te ha jodido el GRUB, pues aqui tienes una guía resumida de como hacerlo, cortesía Ubuntu. Así que nos bajamos una live de Ubuntu/Kubuntu la que mas te guste, y abrimos un terminal.
Necesitamos saber donde esta la particion / de Ubuntu. (una pista, no es ntfs ...) $ sudo fdisk -l Device Boot Start End Blocks Id System /dev/sda1 * 1 2550 20482874+ 83 Linux /dev/sda2 2551 2678 1028160 82 Linux swap / Solaris /dev/sda3 2679 5228 20482875 83 Linux .... (en mi caso sda1) Ahora la montamos$ sudo mount /dev/sda1 /mnt$ sudo mount --bind /dev /mnt/dev
Ya tenemos todo lo que necesitamos montado, pues ahora con chroot cambiamos el espacio de trabajo (a la particion perdida de ubuntu) y ejecutamos el configurador del grub
$ sudo chroot /mnt
# grub-install --recheck /dev/sda
(Notese que es sda, sin ningun numero detras).
# update-grubReiniciar y Listo.
Otra cosa, si se arranca una terminal de grub tal que así.
grub> find /boot/grub/stage1
con lo que salga aqui (en mi caso (hd0,0) ) , lo ponemos en
grub> root (hd0,0)
grub> setup (hd0)
si lo hemos echo bien saldran mensajitos de SUCCESS
grub> quitEsto deberia de solucionar vuestros problemas.
Para mas información, la guía ofical de Ubuntu en español.
“When countries capable of absorbing environmental refugees are at or beyond their carrying capacity, every individual on the planet becomes a potential environmental refugee with no place to go” (Cairns, 2002: 34).
Y no lo digo solo yo ….
