Está claro que el negocio de las impresoras son sus consumibles, que te los venden casi al precio de la impresora

Yo te recomiendo que hagas sabotaje al mercado de cartuchos, te compres una jeringa, bote de tinta china negra, un videotutorial de recarga de cartuchos y di adiós a la compra de cartuchos. Yo ya ni me acuerdo cuando fue la última vez que compré cartuchos para la impresora  

Es lo que vale. Es un buen portátil respecto a calidad/precio, pero olvídate de usarlo en plan gaming, ya que si lo usas par juegos tendrás que usar confguraciones de baja calidad o reducir la resolución bastante (640x480  )

Mi portátil que compré hará como 3 años tiene una confguración similar, 16 gigas DDR4, 1Tb, una GTX 940m (2015) y un i7 de sexta generación muy similar a rendimiento a ese i7. El precio fue también similar a ese, 700 y poco euros. Es un portátil de media gama, para ocio y trabajo va muy bien, pero si es sólo para juegos úsalo para juegos del 2010 para abajo.

Un portátil está bien si estudias, si eres muy viajero, siemrpe estás de mudanza y cosas así, pero si pretendes usarlo en casa el 80 o 90 por cien mejor gasta ese dinero en un ordenador de escritorio, cómpralo por piezas y tendrás un buen cacharro para gaming.

Pues deduciendo por medio de mi bola mágica, esto es Java, así que lo que tienes que hacer es tomar la referencia del objeto que quieres modificar y luego por medio de alguno de sus métodos o funciones haces lo que quieres hacer.

Esto puede venirte grande porque se ve que quieres hacer la casa por el tejado y en programación como cualquier cosa primero debes empezar por la base. Quizás deberías enfocarte al aprendizaje de Java y su POO.

Yo te recomiendo que añadas otro parámetro y que lo denomines clave, de esa forma podrás usar una clave para cifrar las palabras o textos y hacer más seguro, según el algortimo, la cifrado.

Luego te pongo un ejmeplo que ahora me tengo que ir.

Puedes usar cualquier registro en uso, es más todos los registros suelen estar usados en los procesos del sistema que comparte con tú programa pero lo habitual en asm es guardar sus estados, push o mov, y luego recuperarlos, pop o mov. Posiblemente esto te puede ir grande aunque si inviertes tiempo en aprender seguro que luego sacas eso con menos dificultad.

Por ejemplo, en la porción que muestras usas eax y lo inicias a cero mediante un xor.

Si la variable de la cadena es instr es esa la que tienes que usar no entiendo que haces con ese edx y ese ecx, no se ve en el código que contienen.

Es cierto.

Entiendo que quieres usar una función de C en NASM.

Los parámetros se pasan a las funciones como si fueran un array, en este caso es una pila. En esa pila se van pasando los parámetros por medio, como sabrás, del push. Del último al primero, por lo tanto primero debes meter el entero (n) y luego el puntero (buf). Lógicamente se entiende que sabes que son los punteros y esas cosas. En la pila de los parámetros no pasas la cadena, pasas un puntero, una dirección de memoria.

Ten cuidado porque hay manejas punteros, tienes que reservar la memoria y liberarla, y para más inri lo mismo con los registros, una vez haces un push recuerda que luego debes hacer un pop para recuperar el estado anterior a la llamada de la función.

Ejemplo (Visual Studio (0x86) + NASM Win32):

#include <iostream>
 
extern "C" void funcionEnCpp(char * cadena, int valor) {
	std::cout << "cadena=" << cadena << "valor= "<< valor << "\n";
	system("PAUSE");
}

extern _funcionEnCpp
 
section .data
    cadena:	db "Hola asm",8,0
 
section .text
 
global _main:
 
_main:	
        ; *** pasamos los parámetros ***
	mov eax, 55
	push eax ; metemos el valor	
	push cadena; metemos el puntero de la cadena
        ; ***************************
 
	call _funcionEnCpp ; llamamos la funcion
 
        ; *** vaciamos la pila ***
	pop eax
	pop eax
        ; ********************
 
	mov eax, 0 ; retornamos todo OK
	ret

Bueno, fallo, fallo no se puede considerar que sea. Mi conclusión es que debes hacerlo de otra forma, ya que el problema radica cuando el puntero del ratón queda fuera de la ventana y se pierde el foco. Entonces en ese momento para forzar la recuperación del foco usas SDL_CaptureMouse() y ésto permite que los eventos del ratón se puedan seguir capturando fuera de la ventana. Esa parte es la responsable del comportamiento errático del arrastre. Yo conseguí reducirlo un poco, pero ocasionalmente me daba ese salto por ejemplo al pasar el cursor cuando salía del marco por encima del borde de la ventana de la terminal.

#include <SDL2/SDL.h>
#include <stdio.h>
 
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 200
 
static bool salida = false;
 
int main(int argc, char* args[]) {
    SDL_Window* window = NULL;
    SDL_Surface* screenSurface = NULL;
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        fprintf(stderr, "could not initialize sdl2: %s\n", SDL_GetError());
        return 1;
    }
    window = SDL_CreateWindow(
			    "hello_sdl2",
			    SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
			    SCREEN_WIDTH, SCREEN_HEIGHT,
			    SDL_WINDOW_SHOWN);
 
    if (window == NULL) {
        fprintf(stderr, "could not create window: %s\n", SDL_GetError());
        return 1;
    }
    screenSurface = SDL_GetWindowSurface(window);
    SDL_FillRect(screenSurface, NULL, SDL_MapRGB(screenSurface->format, 0xFF, 0xFF, 0xFF));
    SDL_UpdateWindowSurface(window);
 
    int xPos,yPos,xMPosN,yMPosN;
    static bool bMouseClicked=false, bMouseMoving=false;
    static int xMPos=0,yMPos=0;
    char buffer [50];
    while(!salida){
 
        SDL_Event event;
        while( SDL_PollEvent(&event) ) {
 
            switch(event.type ){
 
                case SDL_MOUSEBUTTONDOWN:
                    if(event.button.button == SDL_BUTTON_LEFT){
                        if (!bMouseClicked) {
                            bMouseClicked=true;
                            SDL_GetMouseState(&xMPos,&yMPos);
                            SDL_GetWindowPosition(window,&xPos,&yPos);
                        }
                    }
 
                break;
                case SDL_MOUSEBUTTONUP:
                    if (bMouseClicked) { // Impedimos que entre varias veces
                        if(event.button.button == SDL_BUTTON_LEFT){
                            bMouseClicked=false;
                            SDL_CaptureMouse(SDL_FALSE);
                        }
                    }
 
                break;
                case SDL_MOUSEMOTION:
 
                    if(bMouseClicked) bMouseMoving = true;
                break;
                case SDL_QUIT:
                    salida = true;
            } // fin switch
 
        } // fin loop de eventos
 
        // renderizamos o dibujamos
        if(bMouseClicked && bMouseMoving){
            SDL_CaptureMouse(SDL_TRUE); // Se desabilita al perder el foco
            SDL_GetMouseState(&xMPosN,&yMPosN);
            xPos-=(xMPos-xMPosN);
            yPos-=(yMPos-yMPosN);
            SDL_SetWindowPosition(window,xPos,yPos);
        }
        sprintf (buffer, "xM=%d yM=%d / xW=%d yW=%d / xCM=%d yCM=%d", xMPosN, yMPosN, xPos, yPos, xMPos, yMPos);
        SDL_SetWindowTitle(window,buffer);
        bMouseMoving = false;
        SDL_Delay(10);
    }
    //SDL_CaptureMouse(SDL_FALSE);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}

Vale, pensaba que querías corregir el salto molesto ese que en el último gif ya no se apreciaba.

Bueno, como no tengo nada que hacer es posible que haga una prueba en una máquinita virtual que tengo con un Ubuntu con gnome. Ya te cuento entonces,

Al final funcionó a la manera de CalgaryCorpus. Claro al no hacer un else seguía detectando el evento de pulsado e interfería al mover con el ratón pulsado.

Entonces queda cerrado el tema.

Gracias CalgaryCorpus por tú colaboración