Archive for the ‘Programacion’ Category

Entendiendo la bomba fork() de bash :(){ :|:& };:

25/10/2010

La pregunta: ¿Alguien puede explicar que es el siguiente codigo en bash? :(){ :|:& };:

Respuesta: Es una funcion en bash, y mas aun, es una funcion recursiva. Es un codigo fatal para cualquier sistema sin configurar correctamente.

Una vez que sea ejecutado ese comando y si el sistema no esta correctamente configurado sera imposible continuar sin reiniciar.

Expliquemos mas detalladamente…

:() – Es el nombre de una funcion, la cual no acepta argumentos, generalmente las funciones de bash de definen como sigue:

Code:
nombre_de_funcion () {
   arg1=$1
   echo ''
   #hacemos algo $arg
}

la bomba fork() se define como sigue:

Code:
:() {
   :|: &
};:

:|: – Aca llamamos a la funcion recursivamente, y para hacerlo peor usamos un pipe para llamarla dos veces, por lo que por cada recursion estaremos llamando dos veces a la funcion.

& – Pone la funcion en segundo plano para que los hijos no mueran del todo y consuman recursos.

; – Terminamos la definicion de la funcion

: – Aca llamamos a la funcion.

Aca dejo un codigo un poco mas facil de leer:

Code:
bomba() {
   bomba | bomba &
}; bomba

=-=-=-=-=
Powered by Blogilo

Anuncios

Calcular PI desde python

18/10/2010

Aca dejo un codigo para calcular PI usando python…

Code:
#!/usr/bin/env python
# -⁻- coding: UTF-8 -*-
print "   πππππππππππ"
print "   π π     π"
print "     π     π"
print "     π     π"
print "  Pi Calcutator"
print

def arccot(x, unity):
   sum = xpower = unity // x
   n = 3    sign = -1
   while 1:
       xpower = xpower // (x*x)
       term = xpower // n
       if not term:
          break
       sum += sign * term
       sign = -sign
       n += 2
       return sum

def pi(digits):
   unity = 10**(digits + 10)
   pi = 4 * (4*arccot(5, unity) - arccot(239, unity))
   return pi // 10**10

# En este caso se calculan los 1000 primeros decimales de π. Modifica este valor para calcular los que quieras.
print pi(1000)

=-=-=-=-=
Powered by Blogilo

Compilador Cruzado (cross compiler)

04/10/2010

Un compilador cruzado o cross compiler es un compilador capaz de crear código ejecutable para otra plataforma distinta a aquélla en la que él se ejecuta. Esta herramienta es útil cuando quiere compilarse código para una plataforma a la que no se tiene acceso, o cuando es incómodo (compilar para windows ;)) o imposible compilar en dicha plataforma (como en el caso de los sistemas embebidos).

Un ejemplo de un compilador con estas posibilidades es el NASM, que puede ensamblar, entre otro formatos, ELF (para sistemas UNIX) y COM (para DOS).

Uso de los compiladores cruzados

El uso fundamental de un compilador cruzado es compilar para un entorno diferente en el que se ejecuta el compilador. Esto es muy utilizado en las siguientes situaciones:

  • Sistemas empotrados, dónde los recursos son extremadamente limitados.
  • Compilación para múltiples máquinas.
  • Necesitas un ejecutable para windows y no quieres usar windows para desarrollar. (mi caso)

Instalacion del cross-mingw en openSUSE 11.3

Lo primero es agregar el repositorio crosstoolchains a la lista de repositorios del sistema, para esto ejecutamos el comando:

Code:
[vampird@sharwyn]:~$ su - -c "zypper ar http://download.opensuse.org/repositories/CrossToolchain:/mingw/openSUSE_11.3/ repo-crosstoolchain"
Password:
Adding repository 'repo-crosstoolchain' [done]
Repository 'repo-crosstoolchain' successfully added
Enabled: Yes
Autorefresh: No
URI: http://download.opensuse.org/repositories/CrossToolchain:/mingw/openSUSE_11.3/

[vampird@sharwyn]:~$

luego actualizamos el cache y aceptamos la clave publica del repositorio con el comando:

Code:
[vampird@sharwyn]:~$ su - -c "zypper ref"
Password:
Repository 'Updates for openSUSE 11.3 11.3-1.82' is up to date.
Repository 'repo-contrib-standar' is up to date.
Retrieving repository 'repo-crosstoolchain' metadata [-]

New repository or package signing key received:
Key ID: 83245F71163CDAB4
Key Name: CrossToolchain:mingw OBS Project <CrossToolchain:mingw@build.opensuse.org>
Key Fingerprint: E688CDF91615FAAD6138E72883245F71163CDAB4
Key Created: Tue Jan 22 18:45:46 2008
Key Expires: Thu Apr 1 17:45:46 2010 (EXPIRED)
Repository: repo-crosstoolchain

Do you want to reject the key, trust temporarily, or trust always? [r/t/a/?] (r): a
Retrieving repository 'repo-crosstoolchain' metadata [done]
Building repository 'repo-crosstoolchain' cache [done]
Repository 'repo-emulators' is up to date.
Repository 'repo-games' is up to date.
Repository 'repo-java' is up to date.
Repository 'repo-kde4-core' is up to date.
Repository 'repo-kde4-extra' is up to date.
Repository 'repo-kde4-playground' is up to date.
Repository 'repo-kde4-updateapps' is up to date.
Repository 'repo-local' is up to date.
Repository 'repo-mozilla' is up to date.
Repository 'openSUSE-11.3-Non-Oss' is up to date.
Repository 'openSUSE-11.3-Oss' is up to date.
Retrieving repository 'repo-pacman' metadata [done]
Building repository 'repo-pacman' cache [done]
Retrieving repository 'openSUSE-11.3-Source' metadata [done]
Building repository 'openSUSE-11.3-Source' cache [done]
Repository 'repo-vlc' is up to date.
Retrieving repository 'repo-wine' metadata [done]
Building repository 'repo-wine' cache [done]
All repositories have been refreshed.
[vampird@sharwyn]:~$

y por ultimo instalamos el cross compiler con el comando:

Code:
[vampird@sharwyn]:~$ su - -c "zypper in cross-mingw-gcc"
Password:
Loading repository data...
Reading installed packages...
Resolving package dependencies...

The following NEW packages are going to be installed:
 cross-mingw-binutils cross-mingw-gcc cross-mingw-runtime cross-mingw-w32api 

4 new packages to install.
Overall download size: 23.9 MiB. After the operation, additional 174.4 MiB will be used.
Continue? [y/n/?] (y): y
Retrieving package cross-mingw-w32api-3.8-12.1.x86_64 (1/4), 1.3 MiB (21.5 MiB unpacked)
Retrieving: cross-mingw-w32api-3.8-12.1.x86_64.rpm [done (49.5 KiB/s)]
Installing: cross-mingw-w32api-3.8-12.1 [done]
Retrieving package cross-mingw-runtime-3.11_20061202_1-6.1.x86_64 (2/4), 547.0 KiB (11.8 MiB unpacked)
Retrieving: cross-mingw-runtime-3.11_20061202_1-6.1.x86_64.rpm [done (35.4 KiB/s)]
Installing: cross-mingw-runtime-3.11_20061202_1-6.1 [done]
Retrieving package cross-mingw-binutils-2.16.91_20060119_1-6.1.x86_64 (3/4), 969.0 KiB (8.1 MiB unpacked)
Retrieving: cross-mingw-binutils-2.16.91_20060119_1-6.1.x86_64.rpm [done (95.7 KiB/s)]
Installing: cross-mingw-binutils-2.16.91_20060119_1-6.1 [done]
Retrieving package cross-mingw-gcc-3.4.5_20060117_1-5.1.x86_64 (4/4), 21.1 MiB (132.9 MiB unpacked)
Retrieving: cross-mingw-gcc-3.4.5_20060117_1-5.1.x86_64.rpm [done (225.9 KiB/s)]
Installing: cross-mingw-gcc-3.4.5_20060117_1-5.1 [done]
[vampird@sharwyn]:~$

ahora solo falta un pequeño retoque para que quede comodo de usar, a que me refiero, los binarios del cross-mingw se instalan en /opt/cross/bin y los nombres:

Code:
[vampird@sharwyn]:~$ ls /opt/cross/bin/
i386-mingw32msvc-addr2line  i386-mingw32msvc-dlltool  i386-mingw32msvc-gcc-3.4.5  i386-mingw32msvc-objcopy  i386-mingw32msvc-strings
i386-mingw32msvc-ar         i386-mingw32msvc-dllwrap  i386-mingw32msvc-gccbug     i386-mingw32msvc-objdump  i386-mingw32msvc-strip
i386-mingw32msvc-as         i386-mingw32msvc-g++      i386-mingw32msvc-gcov       i386-mingw32msvc-ranlib   i386-mingw32msvc-windres
i386-mingw32msvc-c++        i386-mingw32msvc-g77      i386-mingw32msvc-ld         i386-mingw32msvc-readelf
i386-mingw32msvc-cpp        i386-mingw32msvc-gcc      i386-mingw32msvc-nm         i386-mingw32msvc-size
[vampird@sharwyn]:~$

por lo cual yo siempre agrego alias a los usados en mi archivo ~/.bashrc, los alias serian los siguientes:
alias cross-gcc=’/opt/cross/bin/i386-mingw32msvc-gcc’
alias cross-g++=’/opt/cross/bin/i386-mingw32msvc-g++’
alias cross-strip=’/opt/cross/i386-mingw32msvc/bin/strip’

=-=-=-=-=
Powered by Blogilo

Oracle cambia la cadena “vendor” en JDK7

27/09/2010

Hasta ahora las cadenas de propiedades eran éstas:

java.vendor = Sun Microsystems Inc.
java.vendor.url = http://java.sun.com/
java.vm.vendor = Sun Microsystems Inc.
java.specification.vendor = Sun Microsystems Inc.
java.vm.specification.vendor = Sun Microsystems Inc.

A partir de JDK7, en cambio nos encontraremos:

java.vendor = Oracle Corporation
java.vendor.url = http://java.oracle.com/
java.vm.vendor = Oracle Corporation
java.specification.vendor = Oracle Corporation
java.vm.specification.vendor = Oracle Corporation

Esto puede parecer una tonteria, pero ya muchas aplicaciones (como Eclipse) tuvierón problemas pues hacian chequeo del valor de estas cadenas, a partir de ahora, toca cambiar… (para bien…. o para mal…)

=-=-=-=-=
Powered by Blogilo

Eliminando el molesto caracter ^M

27/09/2010

Varias veces me ha pasado de que al tratar de ejecutar algun script o compilar algun programa que me han pasado me da errores, al hacer un cat al archivo veo que esta lleno de caracteres “^M” propios de que el archivo fue creado (o incluso estado) en sistemas windows, un ejemplo es:

Code:
[vampird@sharwyn]:~/devel$ cat p.py 
#!/usr/bin/env python^M
^M
import sys^M
import myfile^M
^M
print 'Hello world!'^M
print sys.platform^M
print myfile.title^M
[vampird@sharwyn]:~/devel$

Esto tiene una solucion muy sencilla… simplemente ejecutamos sobre el el comando dos2unix

Code:
[vampird@sharwyn]:~/devel$ whatis dos2unix
dos2unix (1)         - DOS/MAC to UNIX and vice versa text file format converter
[vampird@sharwyn]:~/devel$ dos2unix p.py 
dos2unix: converting file p.py to UNIX format ...
[vampird@sharwyn]:~/devel$ ./p.py 
Hello world!
linux
The Meaning of Life
[vampird@sharwyn]:~/devel$

=-=-=-=-=
Powered by Blogilo

Creacion de librerias dinamicas en C/C++

23/08/2010

Las librerias dinamicas son aquellas que se cargan en el momento de ejecutar el programa, no estan incluidas en el, lo cual genera ejecutables mas pequeños

Para crear una libreria dinamica (*.so) debemos compilarla utilizando la opcion -fPIC y enzamblarla usando la opcion -shared

Dejo un ejemplo:

liv.h:
#ifndef LIV_H
#define LIV_H

int f (int n);

#endif

liv.cpp:
#include "liv.h"

int f (int n) {
   return (n > 1) ? (n * f(n - 1)) : 1;
} // f

main.cpp:
#include <iostream>
using std::cout;
using std::endl;
#include "liv.h"

int main () {
   cout << "5! = " << f(5) << endl;
   return 0;
} // main

Compilamos utilizando los siguientes comandos:

Code:
[vampird@sharwyn]:~/devel/c++$ export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:`pwd`
[vampird@sharwyn]:~/devel/c++$ g++ -fPIC -c liv.cpp
[vampird@sharwyn]:~/devel/c++$ g++ -shared -o libliv.so liv.o
[vampird@sharwyn]:~/devel/c++$ g++ main.cpp -o main -L. -lliv

Primeros pasos con GDB

01/07/2010

Este documento pretende ser una breve y sencilla guía práctica al depurador GDB (http://gnu.org). A lo largo de esta guía, usaremos como ejemplo un sencillo programa cuyo código se muestra a continuación:

#include <stdio.h>

int main() {
   int v = 0, i = 0;
   for (i = 0; i < 5; i++) {
      v += i;
   } /* for */
   printf("Resultado: %i\n", v);
   return 0;
} /* main */

Lo primero que hemos de hacer es compilar dicho programa con la opción “-ggdb” para que se incluya la información necesaria para la depuración. Si el programa está guardado en un archivo

[vampird@Sharwyn]:~/devel/C$ gcc -ggdb -o test test.c

Una vez compilado, podemos comenzar la depuración invocando a gbd con el nombre del archivo compilado.

[vampird@Sharwyn]:~/devel/C$ gdb test
GNU gdb (GDB) SUSE (6.8.91.20090930-2.4)
Copyright (C) 2009 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-suse-linux".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /home/vampird/devel/C/test...done.
(gdb)

La línea “(gdb)” nos indica que el depurador está listo para empezar a procesar nuestras órdenes. El primer comando que veremos es (l)ist. Este comando muestra el código fuente del programa que estoy depurando.

(gdb) l
1      #include <stdio.h>
2
3         int main() {
4         int v = 0, i = 0;
5         for (i = 0; i < 5; i++) {
6            v += i;
7         } /* for */
8         printf("Resultado: %i\n", v);
9         return 0;
10     } /* main */
(gdb)

Para ejecutar el programa, utilizamos el comando (r)un. Como aún no hemos puesto ningún punto de ruptura, el programa se ejecutará entero.

(gdb) r
Starting program: /home/vampird/devel/C/test
Resultado: 10
Program exited normally.
(gdb)

Vamos a colocar ahora un punto de ruptura. Como su nombre indica, un punto de ruptura es un punto donde la ejecución de nuestro programa se detiene. Para colocar un punto de ruptura utilizamos el comando (b)reakpoint seguido de la línea donde queremos ponerlo.

(gdb) b 6
Breakpoint 1 at 0x400553: file test.c, line 6.
(gdb)

Ya tenemos un punto de ruptura en la línea 9. Si ahora ejecutamos el programa se detendrá cuando llegue a esa línea.

(gdb) r
Starting program: /home/vampird/devel/C/test
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb)

Para continuar la ejecución del programa utilizamos el comando (c)ontinue. En nuestro ejemplo, el programa se volverá a detener en el mismo punto de ruptura.

(gdb) c
Continuing.
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb) c
Continuing.
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb) c
Continuing.
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb) c
Continuing.
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb) c
Continuing.
Resultado: 10
Program exited normally.
(gdb)

Puesto que tenemos un punto de ruptura en el bucle y este da 5 vueltas, hemos tenido que continuar 5 veces para ejecutar el programa completo. También es posible ejecutar el programa línea a línea con el comando (n)ext.

(gdb) r
Starting program: /home/vampird/devel/C/test
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb) n
5 for (i = 0; i < 5; i++) {
(gdb) n
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb)

En cualquier momento podemos ver el valor de una variable con el comando (p)rint seguido del nombre de la variable.

(gdb) p v
$1 = 0
(gdb) c
Continuing.
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb) c
Continuing.
Breakpoint 1, main () at test.c:6
6 v += i;
(gdb) p v
$2 = 3
(gdb)

Para eliminar un punto de ruptura utilizamos el comando delete y el número del punto a eliminar. En nuestro ejemplo

(gdb) delete 1

Por último, para salir del depurador utilizamos el comando (q)uit.

Hay mucha más información disponible tanto en la página del manual como en los archivos info:

$ man gdb
$ info gdb

También puede utilizarse interfaces gráficos para trabajar con GB de manera más cómoda. Uno de esos interfaces es DD y puede descargarse en http://sourceforge.net/projects/ddd/

=-=-=-=-=
Powered by Blogilo

5 interesantes novedades de GCC 4.5

30/06/2010

El Proyecto GNU anunció la publicación de la nueva versión de su suite de compiladores: la GNU Compiler Collection (GCC) 4.5.0. Ésta, como es natural, trae consigo nuevas características y mejoras con respecto a la serie 4.4.x. Pues a continuación te listo cinco que hallé de lo más interesante:

1. Multiprecisión

Para ser compilado, ahora GCC solicita la biblioteca Multiprecision (MPC) para hacer aritmética de números complejos con un nivel de precisión arbitrariamente alto y ofrecer resultados con redondeo adecuado. Como efecto colateral, GCC será capaz de generar resultados correctos independientemente de la implementación de la biblioteca matemática o la precisión de punto flotante de la plataforma donde se realice la compilación.

2. Optimización

Hay un nuevo paso de optimización de código. GCC ahora intentará cambiar el prototipo de las funciones para evitar el paso de parámetros que presume no serán utilizados. De este modo, sólo pasarán las partes relevantes de las estructuras de datos y se convertirán los argumentos pasados por referencia a argumentos pasados por valor cuando sea posible. Esta opción de optimización estará habilitada a partir de la bandera -O2 del compilador, así como en la optimización para reducir el tamaño del código con -Os, aunque puede invocarse manualmente a través de la bandera -fipa-sra.

3. Detección de errores

Si GCC encuentra que la directiva #include no incluye el nombre de la biblioteca, entonces terminará inmediatamente. Así ya no verás más esa interminable cascada de errores causada por declaraciones (e.g., macros, funciones) que no se encuentren definidas en ninguna parte.

4. Estándar ISO C++0x

Mejoras en el soporte experimental del estándar ISO C++0x. Entre ellas, soporte para raw strings literals, es decir, aquellas que no reconocen secuencias de escape, de C++ en este caso. Al igual que en lenguajes de scripts como Perl y Python, el soporte para raw strings hará que su tratamiento no sea una tarea engorrosa para el programador.

5. Plugins

Ahora es posible extender con mayor facilidad las funcionalidad del compilador sin tener que modificar el código fuente. ¿Cómo? Mediante plugins, al igual que hace mucho del software de escritorio que utilizamos hoy en día. Con la opción -fplugin=mi_plugin.so le pedirás a GCC que cargue el objeto compartido mi_plugin.so y lo ejecute como parte del compilador.

Comentario final

GCC versión 1.0 fue liberada el 23 de mayo de 1987, hace casi 24 años. Hoy, en su versión 4.5.0 llega con un excelente estado de salud: las mejoras que incluye no pueden decirnos lo contrario. Y esta es una gran noticia para el software libre.

=-=-=-=-=
Powered by Blogilo

Introduccion a cmake

08/06/2010

CMake es una excelente herramienta para generar Makefiles, y no solo eso tambien genera soluciones de Kdevelop, Code::Blocks, Visual Studio entre muchas otras. Así que me puse a investigar y resulta que CMake es trivial de usar, hasta yo lo pude usar!!!

1. Hello World: El código fuente

Usaremos este código que muestra CMake para compilar y enlazar un programa principal con una librería extra generada por nosotros mismos. La siguiente estructura de directorios es la que hay que crear:

[vampird@Sharwyn]:~/devel/C/holaMundoCMake$ tree
.
|-- CMakeLists.txt
|-- build
`-- src
    |-- main.cpp
    `-- milib
        |-- CMakeLists.txt
        |-- milib.cpp
        `-- milib.h

3 directories, 5 files
[vampird@Sharwyn]:~/devel/C/holaMundoCMake$

La idea aqui es que vamos a generar un pequeño programita a partir del codigo en main.cpp y de la libreria milib.cpp, el código de main.cpp es muy sencillo:

main.cpp:

#include "milib.h"

int main (int argc, char** argv) {
   printf("Hola mundo desde main\n");
   hola(2);

   return 0;
} // main

Y lo que hace es cargar el header milib.h que es donde está definida la función hola().

milib.h:

#include <stdio.h>

//Prototipo de funcion
void hola (int);

milib.cpp:

#include "milib.h"

// Implementacion de la funcion
void hola (int veces) {
   int i = 0;
   while (i < veces) {
      printf("[%u] Hola Mundo, desde 'milib'\n" , i);
      i++;
   } // while
} // hola

El código es realmente trivial (si no lo comprendes mejor ni sigas leyendo). Hasta este punto no hemos usado nada de CMake ni hemos creado Makefiles ni nada. El código bien podríamos compilarlo a mano.

2. Hello World: Los archivos CMakeLists.txt para CMake

Hay un archivo de CMake en holaMundoCMake/CMakeLists.txt y hay otro en holaMundoCMake/src/milib/CMakeLists.txt, éstos son los archivos clave para CMake. Con los comentarios se explican solos.

holaMundoCMake/CMakeLists.txt:

cmake_minimum_required(VERSION 2.8)
# El nombre del proyecto "HELLO".
# CMake genera automaticamente una variable llamada
# HELLO_SOURCE_DIR que puede llamarse usando
# ${HELLO_SOURCE_DIR} con la ruta del codigo
# lo mismo con ${HELLO_BINARY_DIR} para binarios
project (HELLO)
# Le decimos donde poner los binarios de librerias y ejecutables
# CMake admite instrucciones partidas en varias lineas
set (LIBRARY_OUTPUT_PATH ${HELLO_BINARY_DIR}/build/lib
     CACHE PATH "Directory for Libraries")
set (EXECUTABLE_OUTPUT_PATH ${HELLO_BINARY_DIR}/build/bin
     CACHE PATH "Directory for Executables")
# Decimos a CMake que haga recursion a los siguientes directorios
# en orden de aparicion
add_subdirectory (src/milib)
# Directorios que debe incluir, ademas de los estandar.
include_directories (${HELLO_SOURCE_DIR}/src/milib/)
# Directorios para el enlazador, ademas de los estandar
# Para este ejemplo no los necesitamos ya que la unica libreria
# adicional es 'milib' y ya sabe donde encontrarla pues el mismo
# la genera
#link_directories (aqui pones mas rutas separadas por espacios)
# Decirle que queremos un ejecutable llamado holaMundo
# y le decimos el source para que lo compile
add_executable (holaMundo src/main.cpp)
# Tenemos una libreria adicional llamada milib, enlazarla
target_link_libraries (holaMundo milib)

El segundo CMakeLists sirve para compilar la libreria milib y es mucho mas corto:

holaMundoCMake/src/milib/CMakeLists.txt

# Agregar una libreria llamada milib generada poru un cpp
# se pueden agregar muchas librerias con varios add_library
# Se deben listar todos los archivos fuente
add_library (milib milib.cpp milib.h)

3. Hello World: Generar Makefiles con CMake y compilar.

En GNU/Linux el modo por default es generar Makefiles, así que entramos al directorio build que actualmente está vacío y generamos los Makefiles:

[vampird@Sharwyn]:~/devel/C/holaMundoCMake/build$ cmake ../CMakeLists.txt 
-- The C compiler identification is GNU
-- The CXX compiler identification is GNU
-- Check for working C compiler: /usr/bin/gcc
-- Check for working C compiler: /usr/bin/gcc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/vampird/devel/C/holaMundoCMake
[vampird@Sharwyn]:~/devel/C/holaMundoCMake/build$

Listo, ya estan los Makefiles generados, ahora a compilar con make:

[vampird@Sharwyn]:~/devel/C/holaMundoCMake$ make
[ 50%] Building CXX object src/milib/CMakeFiles/milib.dir/milib.cpp.o
Linking CXX static library ../../build/lib/libmilib.a                                                                        
[ 50%] Built target milib                                                                                                    
[100%] Building CXX object CMakeFiles/holaMundo.dir/src/main.cpp.o
Linking CXX executable build/bin/holaMundo                                                                                   
[100%] Built target holaMundo                                                                                                
[vampird@Sharwyn]:~/devel/C/holaMundoCMake$

En el directorio build/bin se encuentra el binario holaMundo,

[vampird@Sharwyn]:~/devel/C/holaMundoCMake$ cd build/bin/
[vampird@Sharwyn]:~/devel/C/holaMundoCMake/build/bin$ ls
holaMundo
[vampird@Sharwyn]:~/devel/C/holaMundoCMake/build/bin$ ./holaMundo 
Hola mundo desde main
[0] Hola Mundo, desde 'milib'
[1] Hola Mundo, desde 'milib'
[vampird@Sharwyn]:~/devel/C/holaMundoCMake/build/bin$

¡Listo! ¿Quién dijo que habría que generar Makefiles a mano? Generar CMakeLists.txt es mucho mas fácil y mas intuitivo.

KBasic

07/12/2009

KBasic es un poderoso lenguaje de programacion, el cual es simple, intuitivo y facil de aprender. Es un lenguaje nuevo que combina VB.NET™, Visual Basic®, Visual Basic for Application® y Java™.

Ademas soporta la sintaxis de VB.NET™.

KBasic significa QtBasic, pero QBasic ya esta en uso y QtBasic no es del todo permitido, otras posibilidades pueden ser KoolBasic o KDEBasic.

=-=-=-=-=
Powered by Bilbo Blogger