¿Os interesaría poder compilar vuestros antiguos fuentes escritos en IBM BASIC/BASICA, Microsoft GW-BASIC, Microsoft QBASIC, Microsoft QuickBASIC, Microsoft BASIC Compiler (PDS), o Visual Basic para DOS para Windows x86, Linux x86 o Linux x64?
En caso afirmativo, tenéis disponible QB64, un entorno de desarrollo en modo texto, similar al de QuickBASIC, con una compatibilidad casi del 100% sobre el código de éste. En mi caso, tengo multitud, por no decir cientos de pequeños programitas en BASIC para PC, y ha sido un descubrimiento totalmente revelador. Es cierto que una vez me pasé a Turbo BASIC, con su sintaxis algo diferente, se perdió la compatibilidad QB, pero para eso sigue estando Power BASIC, ¿no es cierto?
Hablando de alternativas, sabréis que además de Power BASIC, hay opciones como FreeBasic, PureBasic, etc, pero al igual que Visual Basic .NET, son dialectos derivados de BASIC, pero que implementan características más modernas de diferente índole, que los hacen incompatibles con el código antiguo.
Los ejecutables que se generan, son por tanto binarios totalmente nativos, aunque lamentablemente, requieren algunas dependencias externas como SDL para funcionar, sin duda, una pena que todavía no permitan hacer compilaciones estáticas. Pero no os desesperéis, porque QB64, está todavía en la versión 0.9, y no es un producto terminado, así que paciencia, que irán viniendo más novedades.
El entorno de desarrollo, imita al interfaz en modo texto de QBASIC y QuickBASIC, lo encuentro poco práctico, pero le da un toque retro que tiene su punto.
Sobre el caso que nos ocupa, QB64, funciona transformando el fuente BASIC a C++, que luego es compilado con G++, y enlazado con las funciones que implementan las características del lenguaje BASIC original. Está tan trabajado, que es incluso capaz de emular los sonidos de BEEP y PLAY, para que funcionen desde la tarjeta de sonido de nuestro entorno.
La velocidad de ejecución de los programas compilados, es buena. Por un lado, como digo, es código nativo, al igual que lo fuera en su día QuickBASIC o Visual BASIC for DOS, pero por otro, vamos a estar ejecutando nuestros programas diseñados para 8086, 286 o 386 de la época, en como mínimo un Pentium 4, es decir, hablamos de que en el peor de los casos, tendrán 50 veces más potencia de cálculo disponible que el original, lo que puede ser una ventaja, o bien un problema, como el caso de abajo, donde a Nibbles, hay que aumentarle los tiempos de espera si queremos que sea jugable. Por lo demás, la compilación de Nibbles.bas, no ha requerido ningún cambio en el código.
SIn querer queriendo me pongo a recordar mis tiempos de programador en QBasic aquellos tiempos horas y horas metido en el computador…
Me dio gusto de que aun exista una comunidad de programadores en qbasic y se este actualizando cada ves mas…
Yo utilizo QB64 es muy rápido. Tiene unos gráficos muy potentes con nuevas instrucciones añadidas, que permite altas resoluciones con millones de colores a voluntad del usuario.
Los tipos de datos, con nuevas instrucciones, son apabullantes: por ejemplo los arrays de strings (cadenas), teniendo suficiente memoria, te permite implementar operaciones aritméticas con «big numbers: APA».
Y todo con la misma filosofía de los clásicos de la antigüedad, pero con una potencia increíble.
Gracias por tu comentario Manuel Sánchez Carrilero. Me gustaría que pudieras darme más información sobre la velocidad de QB64. Cuando la probé con la implementación Sieve en BASIC, se comportó extremadamente lento. De hecho, fue el más lento de todos los contendientes, y el que generó ejecutables de mayor tamaño con mucha diferencia.
He aprovechado para hacer una prueba rápida, con el último snapshot de QB64 1.1, usando el mismo SIEVE.BAS que utilicé en su día. El ejecutable resultante ha sido de 1.460.224 bytes, y ha tardado en ejecutarse 74,385 segundos. El mismo programa en PB/CC 5, era un ejecutable de 15.872 bytes, y tardó en ejecutarse 10,757 segundos. Es decir, al menos con el cálculo de números primos en la Criba de Eratóstenes, sus binarios son 10 veces más grandes, y 7 veces más lentos. Actualizando Powerbasic Console Compiler a la 6.04, el ejecutable se ha visto reducido más aún, hasta los 14.336 bytes, y la ejecución ha sido ligeramente más rápida: 10,173 segundos. Similar a lo que ya verifiqué en Sieve en PB/CC 6.04.
Tampoco le veo que destaque en cuanto a configuraciones de pantalla, o funciones disponibles, pero puedo estar equivocado, por ello agradezco tu opinión.
Los Big Numbers me gusta mucho. Es muy útil, pero no he encontrado documentación al respecto, el mayor tipo de datos que veo es _UNSIGNED _INTEGER64. ¿Podrías ponerme algún enlace o ejemplo?
Muy amable por tu respuesta.
Yo utilizo QB64 únicamente como herramienta. Todo lo que pueda opinar sobre el propio software es muy subjetivo. Por eso cuando comentaba que era muy rápido, me refería a que emplea un instante en ejecutar sencillos códigos, mientras que otros Basic se atascan, pero sin nada de medidas.
Utilizando la sentencia SCREEN _NEWIMAGE(1260, 940, 32), obtengo una resolución de 1260 x 940 sobre mi pantalla de 19” con 2^24 = 256 x 256 x 256 colores, por medio de la instrucción de color _RGB(cr, cg, cb) puesta en cualquier sentencia gráfica PSET, LINE, etc.
Sobre “big number” nada se encuentra para QB64, mira tal vez:
https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic
http://www.runbasic.com/
http://fractaljourney.blogspot.com.es/2011/04/mandelbrot-ultra-zoom-6-10e185.html
Como es bien sabido los tipos SINGLE y DOUBLE que actúan muy rápidos, pueden representar valores reales enormes, pero solo con precisiones máximas de 7 y 16 dígitos, respectivamente.
El tipo _UNSIGNED _INTEGER64, como bien dices, maneja valores enteros del orden de 18 trillones, pero con precisión de tan solo 20 dígitos, etc. Todos ellos son insuficientes en lo que al número de dígitos significativos se refiere, para ciertas aplicaciones como la comentada de los “big numbers”.
Aquí, el número de caracteres (bytes) que puede, teóricamente, admitir un string es 2 Gbyte. Por otro lado el número de elementos que puede admitir un array también está en ese orden de magnitud, son pues candidatos perfectos para representar y operar con grandes números. La idea es muy sencilla: utilizar arrays de string “numéricos”, desmenuzando estos últimos en operaciones dígito a dígito como se hacía en el colegio de niños de primaria, sin necesidad de implementar librerías “ad hoc”, complicadas de manejar.
Mis felicitaciones
Saludos
Muchas gracias por las explicaciones Manuel Sánchez Carrilero. Te recomiendo que pruebes PowerBasic Console Compiler, aprovechando que es gratuito, no pierdes nada, y verás lo que es realmente velocidad.
Quisiera saber mucho más….como compilar y como ejecutar lo compilado bajo 64 bits
Mejor dicho como un minicurso
Fredi Brühl las dos primeras preguntas no tienen mucho misterio. Se descubre en pocos segundos. Por fortuna las dos preguntas se responden al mismo tiempo. Tienes un menú Run como se ve en la captura, con la opción Run que automáticamente compilará y ejecutará tu programa. Por defecto sus ejecutables son de 32 bits, así que no tendrás ningún problema ejecutándolos ni en Win32 ni en Win64.
En cuanto al minicurso me parece una idea estupenda. Cuenta conmigo para publicarlo una vez lo tengas terminado. ¡Estamos en contacto!
quisiera conseguir algun codigo fuente de qb64 utilizando el mouse en su interfaz. Creo que hay una aplicacion llamado
Inform que permite hacer menus para utilizarlos con qb64.
comentario de nuevo para modificar mil E-mail gracias
Vas bien encaminado humberto galvan, pero te falta profundizar un poco. Espero que esta guía te ayude a reconducir el proceso.
Sobre códigos fuente usando el ratón, debes revisar las funciones _MOUSEINPUT y sus relacionada: (_MOUSEX, _MOUSEY, _MOUSEBUTTON, _MOUSEWHEEL, _MOUSESHOW, _MOUSEHIDE, _MOUSEMOVE) donde encontrarás ejemplos con el código fuente:
http://www.qb64.net/wiki/index.php/MOUSEINPUT
Inform es un proyecto oficial de QB64 que implementa una herramienta RAD. Es decir, un diseñador de formularios con componentes visuales, que genera código QB64, y que se compila incluyendo la librería de Inform. En cierta forma pretende replicar lo que conocemos en Delphi/Lazarus, C++ Builder o Visual Basic, pero sobre QB. Es también parecido a Visual BASIC for DOS, sólo que las aplicaciones se ejecutan sobre modo gráfico:
https://www.qb64.org/inform/
Ya nos contarás como te ha ido y lo que estás intentando desarrollar.
Te saludo de nuevo Guti, el pasado 29 de Marzo te comente que estaba programando en Qbasic y efectivamente he seguido, aunque mucha gente critique por el hecho de considerarlo un lenguaje prehistórico, la verdad que es atractivo, yo lo utilice hace como 20 años, pero he batallado para retomarlo, hace algunos días se me dificultó como aplicar el movimiento de mouse en el proyecto que estoy iniciando pero ya lo encontre con las ideas que me diste de _MOUSEX, y _MOUSEY, el programa que estoy diseñando es un control de almacen, ó un inventario, pero no recuerdo como presentar por pantalla el catalogo de 1000 productos que le aparezcan al usuario de 20 en 20, no te pido que me digas alguna rutina, solo quiero una idea, anticipadamente te agradezco la ayuda.
HUMBERTO GALVAN CALVILLO, imagino que tienes las lineas del inventario guardadas en un array. En esa caso, si haces un bucle desde el elemento inicial, hasta el inicial + 20, podrías presentar solamente esos 20 elementos que necesitas.
Hola buenas, estoy progamando en Qb64 y teniendo una duda, he dado con tu pagina web. Quería si podrías ser tan amable de resolverme la duda (creo que puede ser fácil para ti y quitarte poco tiempo). Lo que quiero hacer es conectar una base de datos en XAMPP en otro ordenador con mysql_real_connect. Desde otro ordenador me puedo conectar phpmyadmin, pero no puedo con este programa en qb64 conectar. Muchas gracias por anticipado.
Creo que has estado haciendo las pruebas correctas Javi C.. Tienes conectividad a MySQL desde otro equipo, y eso elimina que pueda ser problema de la cuenta limitada solamente a localhost, o de firewall/puertos.
Sólo queda que el problema sea con el código, con las librerías de QB64 o con los credenciales que usas. Es difícil sin poder ver el código, y sin saber el error que te da.
Siéntete libre de publicarlo aquí.
Hola Javier. Soy compañero de Javi C., y los dos estamos bloqueados con la conexión de la base de datos XAMPP desde otro ordenador.
Cuando se ejecuta el programa desde el ordenador(servidor) donde está la base de datos funciona perfectamente, pero si ejecuta desde otro ordenador y se sustituye 127.0.0.1 por la ip del servidor, no conecta.
Gracias anticipadas.
Es código seria este:
DECLARE CUSTOMTYPE LIBRARY «mysql_helper»
FUNCTION offset_to_string$ ALIAS offset_to_offset (BYVAL offset AS _OFFSET)
FUNCTION offset_at_offset%& (BYVAL offset AS _OFFSET)
END DECLARE
‘#### download mysql.dll from http://www.qb64.net/mysql.dll (~2MB) ####
DECLARE DYNAMIC LIBRARY «mysql»
FUNCTION mysql_init%& (BYVAL always_0 AS _OFFSET)
‘MYSQL *mysql_init(MYSQL *mysql)
FUNCTION mysql_error$ (BYVAL mysql AS _OFFSET)
‘const char *mysql_error(MYSQL *mysql)
FUNCTION mysql_get_client_info$
‘ Returns a string that represents the client library version
‘ const char *mysql_get_client_info(void)
FUNCTION mysql_real_connect%& (BYVAL mysql AS _OFFSET, host AS STRING, user AS STRING, password AS STRING, db AS STRING, BYVAL port AS _UNSIGNED LONG, BYVAL unix_socket AS _OFFSET, BYVAL client_flag AS _UNSIGNED _OFFSET)
FUNCTION mysql_real_connect_dont_open%& ALIAS mysql_real_connect (BYVAL mysql AS _OFFSET, host AS STRING, user AS STRING, password AS STRING, BYVAL db AS _OFFSET, BYVAL port AS _UNSIGNED LONG, BYVAL unix_socket AS _OFFSET, BYVAL client_flag AS _UNSIGNED LONG)
‘ MYSQL *mysql_real_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd, const char *db, unsigned int port, const char *unix_socket, unsigned long client_flag)
‘ The value of host may be either a host name or an IP address. If host is NULL or the string «localhost», a connection to the local host is assumed.
‘ db is the database name. If db is not NULL, the connection sets the default database to this value.
‘ If port is not 0, the value is used as the port number for the TCP/IP connection. Note that the host parameter determines the type of the connection.
‘ If unix_socket is not NULL, the string specifies the socket or named pipe to use. Note that the host parameter determines the type of the connection.
‘ The value of client_flag is usually 0, but can be set to a combination of the following flags to enable certain features.
‘ Return Value: A MYSQL* connection handle if the connection was successful, NULL if the connection was unsuccessful. For a successful connection, the return value is the same as the value of the first parameter.
‘*** REMEMBER, ALL STRINGS PASSED MUST BE NULL ‘+CHR$(0)’ TERMINATED ***
SUB mysql_query (BYVAL mysql AS _OFFSET, mysql_command AS STRING)
FUNCTION mysql_query& (BYVAL mysql AS _OFFSET, mysql_command AS STRING)
‘ int mysql_query(MYSQL *mysql, const char *stmt_str)
‘ Executes the SQL statement pointed to by the null-terminated string stmt_str. Normally, the string must consist of a single SQL statement without a terminating semicolon (“;”) or \g. If multiple-statement execution has been enabled,
‘Returns Zero if the statement was successful. Nonzero if an error occurred.
‘*** REMEMBER, ALL STRINGS PASSED MUST BE NULL ‘+CHR$(0)’ TERMINATED ***
FUNCTION mysql_store_result%& (BYVAL mysql AS _OFFSET)
‘ MYSQL_RES *mysql_store_result(MYSQL *mysql)
‘ Returns a RESULT STRUCTURE
FUNCTION mysql_num_fields~& (BYVAL result AS _OFFSET)
‘ unsigned int mysql_num_fields(MYSQL_RES *result)
‘ To pass a MYSQL* argument instead, use unsigned int mysql_field_count(MYSQL *mysql).
‘ Returns number of columns in result set
FUNCTION mysql_num_rows&& (BYVAL result AS _OFFSET)
‘ my_ulonglong mysql_num_rows(MYSQL_RES *result)
‘ Returns the number of rows in the result set.
FUNCTION mysql_fetch_row%& (BYVAL result AS _OFFSET)
‘ MYSQL_ROW mysql_fetch_row(MYSQL_RES *result)
‘ RETURNS A ROW STRUCTURE
FUNCTION mysql_fetch_lengths%& (BYVAL result AS _OFFSET)
‘ unsigned long *mysql_fetch_lengths(MYSQL_RES *result)
‘ Returns the lengths of the columns of the current row within a result set.
‘ Returns a pointer to an array of lengths
SUB mysql_close (BYVAL mysql AS _OFFSET)
SUB mysql_free_result (BYVAL result AS _OFFSET)
END DECLARE
DIM SHARED conn AS _OFFSET
DIM columns AS LONG
REDIM SHARED DB_RESULT(columns, rows) AS STRING
conn = mysql_init(0)
IF conn = 0 THEN
PRINT «No puedo iniciar MYSQL client!»: SLEEP (0)
ELSE
PRINT «conectado a MYSQL»
END IF
DIM conexion AS _OFFSET
‘*** Abrir Base de Datos ***
conexion = mysql_real_connect(conn, «127.0.0.1», «root», «1451», «MERCA18», 0, 0, 0)
IF conexion = 0 THEN PRINT «NO HE PODIDO CONECTAR CON EL SERVIDOR»: sleep 0
En ese caso Juanjo Gómez, el problema no es el mismo que comentaba Javi C.. Él decía que desde otro ordenador sí había conectividad con phpMyAdmin.
Por tanto el problema no es de código ni de las librerías de MySQL para QB64. El problema es de conectividad.
Revisa el firewall/router/antivirus de la máquina cliente y servidor para verificar que el puerto esté abierto, y la configuración del usuario de MySQL para que acepte conexiones no solamente desde localhost.
Gracias por la respuesta Javier.
Posiblemente me haya explicado mal. Con el programa no nos podemos conectar, pero con phpmyadmin sí que podemos hacerlo desde el otro ordenador.
¿Habría que configurar algo en XAMPP para que se pudiera hacer la conexion con el programa?
En ese caso Juanjo Gómez parece que ahora coincide con lo que indicaba Javi C. inicialmente. Si tenéis conectividad a MySQL desde otra máquina con phpMyAdmin, no parece que sea un problema de puertos cerrados o bloqueados.
¿Seguro que otra máquina es capaz de conectar al MySQL? ¿Estáis usando los mismos credenciales? Porque lo que veo en el código es que conecta a localhost, que es la versión que funciona.
alguien que me pueda ayudar en qb64 , como puedo imprimir una imagen jpg o bmp a una impresora de ticket lo necesito imprimir es un LOGO antes del ticket y no se que comandos usar y como aplicarlo
gracias
Yo por ejemplo everardo flores gonzalez, pero deberás ser algo más específico acerca de la naturaleza del problema. ¿No sabes como enfocarlo? ¿Tienes código pero no funciona? ¿De qué parte tienes dudas? ¿Leer un JPEG o un BMP? ¿Imprimir un gráfico? ¿Es un problema de configuración de la impresora de tickets?
De momento para ir avanzando, supongo que si llevas tiempo con el problema ya lo habrás hecho, mírate PRINTIMAGE.
Hola, alguien pordia ayudarme. Tengo problemas para ejecutar programas de qb64 compilados en windows 10 de 64 bits. Gracias.
Probablemente sí Juan Carlos Lencina. Pero deberías dar más datos acerca de cuál es el problema que tienes al ejecutar los programas.
SI DESEAMOS UN CURSO ACTUALIZADO PERSONALIZADO POR PARTE SUYA DE QB64 O DE ALGUIEN QUE USTED NOS RECOMENDARA ?HABRÍA POSIBILIDAD? Y DONDE
Hola Javier, te dejo mis datos para comunicarme por correo contigo.
Desde a muchas gracias.
Gracias por tu mensaje y bienvenido OSKAR FRANCO. Lamentablemente con tantas cosas en las que estoy involucrado (mi trabajo, mantener este blog, mis libros y mis proyectos de código abierto), además de mi vida personal, me es imposible disponer de más tiempo para otras tareas.
Muchas gracias JUAN CARLOS LENCINA. Aquí tienes los míos:
https://www.javiergutierrezchamorro.com/contacta-conmigo/
BUEN DÍA…ESTOY INTERESADO EN ALGUIEN QUE DE CLASES ACTUALIZADAS DE QB64 EN UN TIEMPO CORTO Y RESOLVIENDO PREGUNTAS PUNTUALES…OBVIAMENTE EL TIEMPO ES PAGADO…ME PODRÍA DESPLAZAR HACIA DONDE ME INDICARA YA QUE NO HAY MANUALES ACTUALIZADOS QUE CONTENGAN TODO SOBRE ESTA NUEVA VERSIÓN…PODRÍA SER ALGUIEN QUE USTED ME SEÑALE YA QUE SEGÚN ENTIENDO SU TIEMPO ESTÁ TOTALMENTE COPADO…SERÍA UN CURSO INTENSIVO DE UN PAR DE DÍAS Y PIENSO QUE QUEDARÍA LISTO…GRACIAS
Tienes razón Fredi, la documentación de QB64 no es lo mejor del mundo. No conozco a nadie que toque profesionalmente esta herramienta, lo siento. Si las dudas son puntuales, tal vez podrías probar en su foro.
BUENAS TARDES SOY UN PROGRAMADOR AUTODIDACTA DE BASIC Y AHORA QB64 Y ESTOY INTENTANDO MODIFICAR LAS PROPIEDADES DE MI IMPRESORA DESDE MIS PROGRAMAS PERO NO LO CONSIGO.
ME GUSTARÍA SABER SI ALGUIEN PUEDE AYUDARME.
GRACIAS
Bienvenido carlos abraham. Por lo que veo hay bastante gente en tu situación, supongo que ya lo has debido ver en los comentarios.
Saludos.
Buenas tardes. He encontrado su blog, que me resulta de gran ayuda, buscando información sobre QB64.
Hace tiempo que no programo. Lo último en VB 6.0 que dejó de funcionar hace mucho. Querría recuperar antiguos algoritmos escritos para Qbasic 4.5 y revivirlos en QB64.(los de Vbasic los doy por perdidos).
Va todo bien salvo por una importante dificultad que casi seguramente no proviene de QB64 sino de alguna configuración en la selección de codificación de texto en Windows 10 de 64 bits.
Concretamente no puedo escribir texto en español que contenga vocales acentuadas, ñ o caracteres de ASCII extendido. Como ejemplo, tanto en modo de edición como en el resultado de la ejecución, al intentar algo como:
PRINT “Cañón”
en el IDE y en la ventana de salida se muestra:
Ca±on
La “á” ha sido sustituida por “a” (sin tilde) y la “ñ” por “±”
He probado intentando cambiar en QB64 la configuración de:
Language – > Code-page for ASCII-UNICODE mapping (Default; CP437)
por otros valores, pero no se puede realizar cambio alguno (o no sé hacerlo).
El mismo problema he tenido con FreeBASIC de Andre Victor, bajo licencia GNU. En este dialecto, que por lo demás funciona bien, intenté cambiar UTF-8 por otros valores sin resultado.
En una versión de Qbasic 4.5 ejecutada mediante DOSBOX, los resultados sí son los esperados. Pero resulta incómodo y con las limitaciones de un lenguaje anticuado en prestaciones como: resolución de gráficos, manejo de números de menor tamaño y otros; además del gran inconveniente, insalvable, de que los .EXE compilados no son compatibles con Windows.
Si no consigo resolver esta cuestión la única alternativa es recurrir a versiones de Visual Studio Express, que requieren un aprendizaje de su entorno y sintaxis muy complicado. Siempre teniendo en cuenta que mi objetivo es poco más que de entretenimiento. O desistir de disponer de mis programas.
Gracias por su blog y por la atención que me presta.
Un saludo.
El tema es bastante engorroso Nicolás García R., porque QB64, al igual que Windows NT en adelante, incluyendo el 10, trabajan en Unicode. La cosa es convertir esos carácteres a unicode. Aunque el soporte de QB64 es bastante malo, aquí y en sus foros dan algunas pistas: https://www.qb64.org/wiki/Code_Pages
Para: Javier Gutiérrez Chamorro (Guti)
Buenas tardes.
Gracias por su respuesta.
He visitado el enlace que me ha enviado y los que allí se relacionan.
Como Ud. indica el tema es engorroso, laberíntico. Diría que quedan demasiados huecos sin resolver por los diseñadores de sistemas operativos a efectos de configuración asequible de equipos por parte de los usuarios finales. No es infrecuente abrir ficheros de texto de distintas fuentes o con distintos editores y encontrar estos problemas de codificación.
La cuestión es que con el remapeo de caracteres que allí se desribe se resuelven algunas situaciones a base de un esfuerzo grande al escribir un programa.
Pero esa reasignación de caracteres Unicode a ASCII-extendido deja sin resolver el problema que afecta al IDE y/o al sistema operativo completo; es decir, puedo hacer que al escribir un texto, reasignando los caracteres de uno en uno, la salida sea la deseada; pero al pulsar una tecla el signo recibido sigue siendo el que la configuración “code-page” tenga asignada a nivel interno.
Además (no lo he probado) quedaría por resover el problema en la dirección opuesta, es decir, recibir un texto ASCII y remapear de nuevo para que se muestre en pantalla el unicode correspondiente.
Analizar el texto de un libro completo se me hace una tarea inabordable.
En cualquier caso, sus indicaciones me aclaran cómo funciona este tema y cómo resover situaciones puntuales. Seguiré probando.
Gracias de nuevo.
Un saludo.
En efecto Nicolás García R.. Me da la impresión que el desarrollo de QB64 no tuvo en cuenta estos problemas. Y sí, es engorroso convertir de una página de códigos ANSI a una página de códigos UNICODE. Quizás mi consejo sería que probaras Powerbasic.
Siguiendo su recomendación he echado un vistazo a PowerBasic. Parece un proyecto realmente impresionante. En el manual que ofrecen (varios PDF, 800 + pág.), encuentro cosas muy interesantes como el IDE gráfico que incorpora para programación de eventos, amplio tipo de variables con números de una precisión enorme, herramientas de depuración muy elaboradas, un amplio conjunto de funciones y otras características. Todo un lenguaje profesional para los que no quieran .NET.
En contra encuentro alguna cosilla que otra. En modo gráfico no veo opción de dibujar un círculo, con coordenadas del centro, radio y color; se ofrece ELLIPSE, que ha de dibujarse definiendo el rectángulo que la circunscribe… ¡Un lío! He dibujado muchos círculos (y arcos) en Turbo Basic, QB 45, VBasic 6.0… Y he necesitado dibujar muy, muy poquitas elipses. Tampoco encuentro una función similar a PSET x, y, c para un simple punto, o POINT (X,Y) para obtener datos de un pixel. En .NET (primeras versiones) había que dibujar un círculo con radio 1 ?!.
No ofrecen versión de prueba más que para la versión de compilación en entorno DOS.
Del vistazo, tengo la sensación de que el aprendizaje de PowerBasic, por su potencia, no sería fácil/rápido.
FreeBasic, Basic!, Oli Basic, QB7… y toda una pléyade de intentos que no suelen tener demasiada acogida.
El mundo de Java, imponiendo su modelo de programación orientada a Objetos y toda su parafernalia, cuando sólo se quiere un programa sencillito y corto para algo puntual. También existía otro entorno similar a VBasic: SHARDEVELOP, igualmente abandonado ya.
QB 64 es un lenguaje estupendo si se obvian algunos detalles. Para muchas cosas lo seguiré usando.
Gracias.
Nicolás García R. PowerBasic tiene dos productos, PB/CC, es decir el compilador de consola, que hereda de Turbo Basic/Powerbasic para DOS, y en el que el aprendizaje no es complicado, y PB/Win que se basa en la API de Windows y tiene bastante tela. Yo soy un fan de PB, lástima que no haya tenido el desarrollo y la difusión que merece.
En cuanto a los círculos, bueno, no te sería difícil crear una función que transformara el clásico X, Y (centro) y R (radio) a los nuevos parámetros. De hecho el manual lo explica bastante bien, porque esa es otra, en PB la documentación siempre ha estado a la altura.
Other XPRINT functions, namely those involved with the drawing of curves (XPRINT ARC, XPRINT ELLIPSE, and XPRINT PIE), utilize the concept of a «bounding rectangle» to determine their size and position on the host printer page. A bounding rectangle is defined as the smallest rectangle which can be drawn around the circle or ellipse. For example, let’s say you wish to draw a circle centered at position (200,200), which has a radius of 50 pixels. The upper left corner (x1,y1) of the bounding rectangle would be at (150,150), while the lower right corner of the bounding rectangle would be at (250,250).
Hola. Quiero revivir algunos programas que elaboré en Qb hace más de 20 años. Observo que con QB64 solo se pueden leer programas en texto y no en ejecutable como creo se podía grabar y leer antes para ocupar menos espacio. Entonces, muchos de mis programas no puedo leerlos porque están en ejecutable. Es así o existe manera de hacerlo y no lo he detectado?
Salvador Díaz, bienvenido a este espacio. QB64 es un entorno de desarrollo bastante compatible con QB. Del mismo modo que en QB conservando el ejecutable no podrías modificar su código, con QB64 ocurre lo mismo.
Por suerte si buscas sólo poderlos ejecutar en Windows es mucho más sencillo, ya que tienes DOSBox, un emulador de DOS desde el que poder ejecutar tus programas.
Si quieres lectura adicional, hace unos años hice algo parecido:
– Recuperando programas antiguos: Conclusiones
– Recuperando programas antiguos: Los programas
– Recuperando programas antiguos: El proceso
Hola Javier, tengo problemas con la impresión en papel qb64 He consultado a microsoft y me dijeron que la única función es LPRINT, no admite PRINT # … para ellos debo configurar en windows 10 por un puerto virtual con NET USE lo que no se como manejar son los caracteres comprimidos , normales y expandidos. Tienes tu conocimiento de ello?
Recuerdo LPRINT y LPRINT USING Juan Carlos Lencima, pero como hace tiempo que uso Powerbasic tampoco es que esté demasiado familiarizado.
Quisiera plantear una duda que no puedo resolver. He preparado una rutina de errores que se dispara con el comando ON ERROR, ya sabeis. La he puesto a prueba haciendo una simulación con el comando ERROR para los 76 posibles errores y funciona perfectamente, salvo para un caso. El error 11, «División by cero». En este caso se dispara una rutina interna de QB que me avisa del error pero me obliga a aceptar y si acepto sale del programa, lo finaliza.
La he probado en un sencillo programa que solo tiene mi rutina y repite lo mismo. Es un error de QB64 o mio?
Tiene solución?
Por cierto QB64 funciona muy bien aunque ya he visto algún que otro error (pocos es verdad, pero los hay)
Gracias
Como veo que estamos un poco vagos este sábado por la mañana Luis Coloma Fernandez, he replicado tu programa y lo he ejecutado sobre el último QB64, la versión 1.4 para x64:
On Error GoTo ErrorHandler
For iError% = 0 To 71
Error iError%
Next
ErrorHandler:
Print «Error»; Err; «on program file line»; _ERRORLINE
Resume Next
Efectivamente ocurre lo que tu dices, la división por cero no es capturada y muestra un MessageBox del sistema, probablemente generado por el propio runtime C de QB. Es decir, un bug en toda regla.
Para asegurarme, lo he «portado» a PowerBasic Console Compiler 6.04:
Function PBMain()
On Error GoTo ErrorHandler
For iError% = 0 To 71
Error iError%
Next
ErrorHandler:
Print «Error»; Err; «on program file line»; Erl; «description»; Error$
Resume Next
End Function
En donde se ha ejecutado como se esperaba, interceptando todos los tipos de errores. Por cierto que el EXE generado por QB64 eran 2MB., mientras que el de PB/CC son 11KB. Si los cálculos no me fallan eso es algo así como 200 veces más pequeño.
Dejo pendiente verificar el comportamiento con QB/Basic PDS o VBDOS, que me temo será también correcto.
Pues sigo pendiente por si hubiera alguna novedad. ¿No tiene solución? Aunque sea una chapucilla para salir del paso.
Muchas gracias por tu agilidad y claridad en responder.
Un saludo Javier.
Para mi la solución es evidente ciberalfil. QB64 no deja de ser un juguete. Para cosas serias lo suyo es una herramienta de desarrollo de calidad profesional. Incluso FreeBasic me parece mejor que QB64.
Bueno, gracias.
Gracias a ti ciberalfil. Ya nos contarás que tal continúa tu proyecto.
Tras unas horas investigando, y en las próximas semanas se publicará el análisis detallado, la explicación está documentada: «Note: Don’t use error codes under 97 or over 200 as QB64 may respond to those errors and interrupt the program.»
Eso no explica el porqué se comporta diferente a QBASIC y QuickBASIC; pero ahí está.
No hay más que ver esta prueba de hace años: https://www.javiergutierrezchamorro.com/sieve-en-basic/
Plenamente de acuerdo Gonzalo. Gracias por la referencia.
GUTI. HE LEIDO TUS COMENTARIOS. SOY PEDRO HERNANDEZ,INGENIERO,JUBILADO.TENGO MUCHOS PROGRAMAS TECNICOS DESARROLLADOS EN QB45 Y LOS ESTOY PASANDO AL QB64 PARA TRABAJAR EN WINDOWS. HECHO DE MENOS «EL DEPURADOR» (PARADA EN UNA LINEA E INSPECCION DE LAS VARIABLES).ME HARÍAS UN GRAN FAVOR SI PUDIERAS ACLARARME CÓMO HACERLO. NA SABES LAS HORAS QUE LLEVO INTENTANDOLO! GRACIAS ANTICIPADAS! UN CORDIAL SALUDO
Bienvenido PEDRO HERNANDEZ GRAN. Que yo sepa QB64 no tiene depurador integrado, es decir, es mucho más limitado que el QuickBasic origianal de 1988. Es por eso que recomiendo no usarlo y en breve veremos algún ejemplo más de los motivos. Estate atento al blog.
Hay un añadido para QB64 que se llama vWATCH64 y te permitirá ir depurando paso a paso tu programa. No es una solución integrada como sí que ofrecía el QBASIC/Quick BASIC de Microsoft pero te ayudará.
alguien sabe si se puede cargar 2 archivos a la vez como en qbasic un archivo para el programa principal y el otro para
funciones y procedimientos para llamarlos al programa principal?
Bienvenido carlos. A diferencia de QBASIC que no lo soportaba (QuickBASIC si lo hacía), QB64 soporta la directiva $INCLUDE, así que no tendrás ningún problema en hacerlo. Sólo es cuestión de indagar un poco:
Referencia de $INCLUDE en qb64.org
Referencia de $INCLUDE en qb64.net
How do I link modules or include SUB procedures in QB64? en qb64.org
Como comentaba, aquí va la actualización: El curioso bug de QB64 (on error).
Hola, soy un aficionado a programar básic desde tiempos del básica, gwbasic, quickbasic, qbasic. Programo mis juegos en QB64 creándose sus respectivos ejecutables .exe.
Pero hay alguna manera de crear ejecutables para Android con QB64?
Bienvenido Juan. Lo desconozco, pero estando familiarizado con la base de QB64 lo dudo sinceramente. Android es una plataforma que no se parece en nada a Windows, OSX o Linux que son las que soportan, que requiere un toolchain bastante más complejo que un simple GCC.
Ok, gracias. Me había parecido ver navegando por internet algún comentario de que se podía… Pero yo también lo dudaba mucho.
Por lo que he visto hubo varios intentos de hacerlo allá por 2016 Juan, todos ellos abandonados. Efectivamente la tarea no era nada fácil, y la base de código de QB64 podríamos decir que tampoco la mejor.
Indudablemente QB64 fracasa con los códigos de teclado más-menos,¿, y tilde. (A OTRO COMPI COMPI).
Bienvenido Carlitos. Ojalá que su problema fuera solamente ese. Échale un vistazo a El curioso bug de QB64 (on error).
Debo admitir que a finales de los 2000, cuando surgía QB64 aún con el nombre de QB32 me pareció prometedor, de hecho FreeBASIC estaba en pañales. Sin embargo el tiempo pasaba, y el soporte a QB64 se frenaba notablemente. Y ojo, que no es una crítica, creéme que plenamente consciente de lo que representa desarrollar software libre.