Habemus [code]

Genial. : -)
Probémoslo.

 
extern int puts(char* str);

int main(int argc,char* argv[]) { 
 puts("Cabe la posibilidad de tener sintaxis de colores?");
 return 0;
}

Console.WriteLine("Hello MV!");

Gracias Pollo.

Vamos a ver si aguanta las sucesiones de parentesis de Scheme/Lisp:

(define (hola) (word "Hola, mundo!"))

Haskell r00lz

lol = ['o','l','l','e','h']

hi [] = []
hi x:xs = tail(xs)++x


hi lol

PD: Que bueno :_D

funciona para todos o esta limitado por chocopuntos?

Bien ^^

[img]http://www.media-vida.net/images/avatar/29211.gif[/img]
[spoiler]brau brau brau[/spoiler] #1

Estaba probando tags dentro de tags xD

[code]puts 'hola mundo'

puts 'hola mundo'[/code]

Mola, tenrdrá algún bug que haga que se raye?

[b]Esto es negrita [/b]
                             <baaaaa> tabulado </baaaaaa>
[img]http://www.portalbonsai.com/images/20060107072559tia.jpg[/img]

/ \

[] [/] 
 

[/code]
[/code]

[code]
 

Um, no se me cierra nunca por mucho que ponga [/code] :\
[/code][/code][/code][/code]
[/code]
[/code]

[/code]

 hello world 
a
  a
    a
      a

galletah

void __fastcall TFormMenu::FormMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  if(bBorrar->Marked){
    int i;
    if(buscaDibujo(X,Y,i)){
      dibujos.erase(&dibujos[i]);
      Refresh();
    }
  }

             __ \ / __
            /  \ | /  \
                \|/
           _,.---v---._
  /\__/\  /            \
  \_  _/ /              \ 
    \ \_|           @ __|
     \                \_
      \     ,__/       /
    ~-~`~-~~-~~-~~-~-~/-~-~

Queremos sintaxis coloreada para lenguaje whitespace

............................................________
....................................,.-‘”...................``~.,
.............................,.-”...................................“-.,
.........................,/...............................................”:,
.....................,?......................................................\,
.................../...........................................................,}
................./......................................................,:`^`..}
.............../...................................................,:”........./
..............?.....__.........................................:`.........../
............./__.(.....“~-,_..............................,:`........../
.........../(_....”~,_........“~,_....................,:`........_/
..........{.._$;_......”=,_.......“-,_.......,.-~-,},.~”;/....}
...........((.....*~_.......”=-._......“;,,./`..../”............../
...,,,___.\`~,......“~.,....................`.....}............../
............(....`=-,,.......`........................(......;_,,-”
............/.`~,......`-...............................\....../\
.............\`~.*-,.....................................|,./.....\,__
,,_..........}.>-._\...................................|..............`=~-,
.....`=~-,_\_......`\,.................................\
...................`=~-,,.\,...............................\
................................`:,,...........................`\..............__
.....................................`=-,...................,%`>--==``
........................................_\..........._,-%.......`\
...................................,<`.._|_,-&``................`\

(defglobal 
	?*mensaje* = ""
	)

(deftemplate plantilla
	(slot letra
		(type SYMBOL)
	)
	(slot morse
		(type STRING)
	)
)

;Hechos iniciales, contiene el abecedario morse y un disparador para la entrada por teclado.
(deffacts iniciales
	(plantilla (letra a) (morse "*-"))
	(plantilla (letra b) (morse "-***"))
	(plantilla (letra c) (morse "-*-*"))
	(plantilla (letra d) (morse "-**"))
	(plantilla (letra e) (morse "*"))
	(plantilla (letra f) (morse "**-*"))
	(plantilla (letra g) (morse "--*"))
	(plantilla (letra h) (morse "****"))
	(plantilla (letra i) (morse "**"))
	(plantilla (letra j) (morse "*---"))
	(plantilla (letra k) (morse "-*-"))
	(plantilla (letra l) (morse "*-**"))
	(plantilla (letra m) (morse "--"))
	(plantilla (letra n) (morse "-*"))
	(plantilla (letra o) (morse "---"))
	(plantilla (letra p) (morse "*--*"))
	(plantilla (letra q) (morse "--*-"))
	(plantilla (letra r) (morse "*-*"))
	(plantilla (letra s) (morse "***"))
	(plantilla (letra t) (morse "-"))
	(plantilla (letra u) (morse "**-"))
	(plantilla (letra v) (morse "***-"))
	(plantilla (letra w) (morse "*--"))
	(plantilla (letra x) (morse "-**-"))
	(plantilla (letra y) (morse "-*--"))
	(plantilla (letra z) (morse "--**"))
	)


(defrule entrada
	=>
	(printout t "Escriba el mensaje en lenguaje morse (/ es el espacio): ")
	(bind ?men (readline))
	(assert (mensaje ?men))
	)
	
(defrule tipo1 "Regla que se dispara mentras se vayan encontrando '/' en el mensaje"
	(not (traduciendo)) 
	(not (fin))
	?e <- (mensaje ?men&:(numberp (str-index "/" ?men)))
	=>
	(retract ?e)
	(bind ?pos (str-index "/" ?men)) ;Capturamos la posición de la primera barra
	(bind ?trozo (sub-string 1 (- ?pos 1) ?men)) ;En trozo metemos la cadena que hay ANTES de la barra (excluida)
	(bind ?men (sub-string (+ ?pos 1) (length ?men) ?men)) ;En men ahora metemos la cadena que hay DESPUÉS de la barra (excluida)
	(assert (mensaje ?men)) ;Reafirmamos el mensaje
	(assert (trozo ?trozo)) ;Afirmamos el trozo que se va a traducir
	(assert (traduciendo)) ;Se afirma un hecho que permite disparar la regla de traducción
)	
	
(defrule tipo2  "Esta regla se dispara cuando sólo encuentra una cadena sin '/'"
	(not (traduciendo)) ;El hecho (traduciendo) es un disparador de las reglas de cada letra
	(not (fin))	 ;El hecho(fin) indica que no queda más cadena que leer
	?e <- (mensaje ?men&:(not (numberp (str-index "/" ?men))))
	=>
	(retract ?e) ;El mensaje se borra, ya que no queda nada más que extraer
	(assert (trozo ?men)) ;Afirma el hecho con la última cadena
	(assert (fin)) ;Afirma un hecho para controlar que no es necesario extraer más
	(assert (traduciendo)) ;Se Afirma el hecho que dispara la regla de traducción
	)
		
(defrule traduce "Regla que se dispara cuando le dan paso las reglas tipo 1 y 2 y encuentra en el abecedario una equivalencia al trozo extraído"
	?e <-(traduciendo)
	?d <-(trozo ?morse)
	(plantilla (letra ?letra) (morse ?morse))
	=>
	(bind ?*mensaje* (str-cat ?*mensaje* ?letra))
	(retract ?d)
	(retract ?e)
	)

(defrule imprimir "Regla que se dispara cuando el mensaje ha sido traducido por completo"
	(not (traduciendo))
	?e <- (fin)
	(not (mensaje ?))
	=>
	(printout t "El mensaje dice: " crlf ?*mensaje* crlf)
	)

/*******************************************/

;;Función de prueba x^2+2x
(define (f x)
  (+
   (* x x)
   (* 2 x)
   )
  )

;;Función que obtiene el término k de la fórmula
;;de simpson para el cálculo numérico de integrales.
;;Nota: por cuestiones prácticas, no devuelve el número
;;multiplicado por lo que tenga que estarlo (4, 0 ó 1).
(define termino-simpson 
  (lambda (funcion a h k)
    (funcion (+ a (* h k)))
    )
  )

;;Función que calcula el valor de la integral
;;de la función f, en el intervalo [a, b] y con
;;n divisiones de éste.
(define simpson-iterativo
  (lambda (f a b n)
    (define paso (/ (- b a) n))
    (do
        (
         (i 0 (+ i 1))
         (resultado 0 (+ resultado (* (cond
                                        ((or (= i 0) (= i n)) 1.0)
                                        ((even? i) 2.0)
                                        (else 4.0)
                                        )
                                      (termino-simpson f a paso i)
                                      )
                         )
                    )
         )
      ((= (- i 1) n) (* (/ paso 3) resultado))
      )
    )
  )

Bueno, salvo las líneas largas, está de puta madre. Con cuidar un poco lo que peguemos, bastará. Nuevamente se lo agradezco a pollo ^_

Yo espero que pongais una ayuda o algo en la zona de posteo para todos los tags que pongais.Aunque sea una ventanita que se abra.

Este lo puedo usar o es como el de imagenes que se necesita un limite de post.

y compilador online para todos y cada uno
de los lenguajes del universo mundiá