Th %%prettify JSPWikiStyle adds syntax colouring and line numbering to all the enclosed {{{code blocks}}}.

If you want to prettify all the code blocks of a page, it is sufficient to put one %%prettify around the whole page, or add [{SET page-styles='prettify'}] to your page. You can also use %%prettify-nonum to only prettify the code and hide the line numbers.

Prettify is based on Google's code prettifier and automatically recognises the language of the code block. It should recognise a number of languages including C and friends, Java, Python, Bash, SQL, HTML, XML, CSS, Javascript, and Makefiles. It works passably on Ruby, PHP and Awk and a decent subset of Perl, but, because of commenting conventions, doesn't work on Smalltalk, Lisp-like, or CAML-like languages.

Usage#

Default with line numbers 

%%prettify
{{{
main() {
  printf("%u", 1024);
}
}}}
/%

main() {
  printf("%u", 1024);
}
Or without line numbers 
%%prettify-nonum
{{{
main() {
  printf("%u", 1024);
}
}}}
/%

main() {
  printf("%u", 1024);
}

Examples#

Wiki Markup#

!Title

Here is __some__ wiki ''markup'' text. Linking to this [Prettify Sourcecode]
* list item
* list item
* list item

|table |table
|table |table

Bash#

#!/bin/bash

# Fibonacci numbers
# Writes an infinite series to stdout, one entry per line
function fib() {
  local a=1
  local b=1
  while true ; do
    echo $a
    local tmp=$a
    a=$(( $a + $b ))
    b=$tmp
  done
}

# output the 10th element of the series and halt
fib | head -10 | tail -1

C#

#include <stdio.h>

/* the n-th fibonacci number.
 */
unsigned int fib(unsigned int n) {
  unsigned int a = 1, b = 1;
  unsigned int tmp;
  while (--n >= 0) {
    tmp = a;
    a += b;
    b = tmp;
  }
  return a;
}

main() {
  printf("%u", 1024);
}

C++#

#include <iostream>

using namespace std;

//! fibonacci numbers with gratuitous use of templates.
//! \param n an index into the fibonacci series
//! \param fib0 element 0 of the series
//! \return the nth element of the fibonacci series
template <class T>
T fib(unsigned int n, const T&amp; fib0) {
  T a(fib0), b(fib0);
  while (--n >= 0) {
    T tmp(a);
    a += b;
    b = tmp;
  }
  return a;
}

int main(int argc, char **argv) {
  cout << fib(10, 1U);
}

Java#

package foo;

import java.util.Iterator;

/**
 * the fibonacci series implemented as an Iterable.
 */
public final class Fibonacci implements Iterable<Integer> {
  /** the next and previous members of the series. */
  private int a = 1, b = 1;

  public Iterator<Integer> iterator() {
    return new Iterator<Integer>() {
      /** the series is infinite. */
      public boolean hasNext() { return true; }
      public Integer next() {
        int tmp = a;
        a += b;
        b = tmp;
        return a;
      }
      public void remove() { throw new UnsupportedOperationException(); }
    };
  }

  /**
   * the n<sup>th</sup> element of the given series.
   * @throws NoSuchElementException if there are less than n elements in the
   *   given Iterable's {@link Iterable#iterator iterator}.
   */
  public static <T>
  T nth(int n, Iterable<T> iterable) {
    Iterator<? extends T> it = iterable.iterator();
    while (--n > 0) {
      it.next();
    }
    return it.next();
  }

  public static void main(String[] args) {
    System.out.print(nth(10, new Fibonacci()));
  }
}

Javascript#

/**
 * nth element in the fibonacci series.
 * @param n >= 0
 * @return the nth element, >= 0.
 */
function fib(n) {
  var a = 1, b = 1;
  var tmp;
  while (--n >= 0) {
    tmp = a;
    a += b;
    b = tmp;
  }
  return a;
}

document.write(fib(10));

Perl#

#!/usr/bin/perl

use strict;
use integer;

# the nth element of the fibonacci series
# param n - an int >= 0
# return an int >= 0
sub fib($) {
  my $n = shift, $a = 1, $b = 1;
  ($a, $b) = ($a + $b, $a) until (--$n < 0);
  return $a;
}

print fib(10);

Python#

#!/usr/bin/python2.4

def fib():
  '''
  a generator that produces the elements of the fibonacci series
  '''

  a = 1
  b = 1
  while True:
    a, b = a + b, a
    yield a

def nth(series, n):
  '''
  returns the nth element of a series,
  consuming the earlier elements of the series
  '''

  for x in series:
    n = n - 1
    if n <= 0: return x

print nth(fib(), 10)

XML#

<!DOCTYPE series PUBLIC "fibonacci numbers">

<series base="1" step="s(n-2) + s(n-1)">
  <element i="0">1</element>
  <element i="1">1</element>

  <element i="2">2</element>
  <element i="3">3</element>
  <element i="4">5</element>
  <element i="5">8</element>

  ...
</series>

HTML#

<html>
  <head>
    <title>Fibonacci number</title>

  </head>
  <body>
    <noscript>
      <dl>
        <dt>Fibonacci numbers</dt>
        <dd>1</dd>

        <dd>1</dd>
        <dd>2</dd>
        <dd>3</dd>
        <dd>5</dd>

        <dd>8</dd>
        &amp;hellip;
      </dl>
    </noscript>

    <script type="text/javascript"><!--
function fib(n) {
  var a = 1, b = 1;
  var tmp;
  while (--n >= 0) {
    tmp = a;
    a += b;
    b = tmp;
  }
  return a;
}

document.writeln(fib(10));
// -->

    </script>
  </body>
</html>

PHP#

<html>
  <head>
    <title><?= 'Fibonacci numbers' ?></title>

    <?php
      // PHP has a plethora of comment types
      /* What is a
         "plethora"? */
      function fib($n) {
        # I don't know.
        $a = 1;
        $b = 1;
        while (--$n >= 0) {
          echo "$a\n";
          $tmp = $a;
          $a += $b;
          $b = $tmp;
        }
      }
    ?>
  </head>
  <body>
    <? fib(10); ?>
  </body>
</html>

SQL#

/* A multi-line
 * comment */
'Another string /* Isn\'t a comment',
"A string */"
-- A line comment
SELECT * FROM users WHERE id IN (1, 2.0, +30e-1);
-- keywords are case-insensitive.
-- Note: user-table is a single identifier, not a pair of keywords select * from user-table where id in (x, y, z);

LUA#

-- Examples from the language reference
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]

3   3.0   3.1416   314.16e-2   0.31416E1   0xff   0x56

-- Some comments that demonstrate long brackets
double_quoted = "Not a long bracket [=["
--[=[ quoting out
 [[ foo ]]
 [==[does not end comment either]==]
]=]
past_end_of_comment
--]=]

-- Example code courtesy Joseph Harmbruster
#
do
  local function ssgeneral(t, n, before)
    for _, h in ipairs(incs) do
      for i = h + 1, n do
        local v = t[i]
        for j = i - h, 1, -h do
          local testval = t[j]
          if not before(v, testval) then break end
          t[i] = testval; i = j
        end
        t[i] = v
      end 
    end
    return t
  end

  function shellsort(t, before, n)
    n = n or #t
    if not before or before == "<" then return ssup(t, n)
    elseif before == ">" then return ssdown(t, n)
    else return ssgeneral(t, n, before)
    end
  end
  return shellsort
end

LISP#

; -*- mode: lisp -*-

(defun back-six-lines () (interactive) (forward-line -6))
(defun forward-six-lines () (interactive) (forward-line 6))

(global-set-key "\M-l" 'goto-line)
(global-set-key "\C-z" 'advertised-undo)
(global-set-key [C-insert] 'clipboard-kill-ring-save)
(global-set-key [S-insert] 'clipboard-yank)
(global-set-key [C-up] 'back-six-lines)
(global-set-key [C-down] 'forward-six-lines)

(setq visible-bell t)
(setq user-mail-address "foo@bar.com")
(setq default-major-mode 'text-mode)

(setenv "TERM" "emacs")
(c-set-offset 'case-label 2)
(setq c-basic-offset 2)
(setq perl-indent-level 2)
(setq delete-key-deletes-forward t)
(setq indent-tabs-mode nil)

;; Text mode
(add-hook 'text-mode-hook 
  '(lambda ()
     (turn-on-auto-fill)
   )
)

;; Fundamental mode
(add-hook 'fundamental-mode-hook 
  '(lambda ()
     (turn-on-auto-fill)
   )
)

OCAM and F##

(*
 * Print the 10th fibonacci number
 *)

//// A line comment
"A string";;
(0, 125, 0xa0, -1.0, 1e6, 1.2e-3);;  // number literals

#if fibby
  let
    rec fib = function (0, a, _) -> a
                     | (n, a, b) -> fib(n - 1, a + b, a)
  in
    print_int(fib(10, 1, 1));;
#endif

This page (revision-5) was last changed on 01-May-2016 12:15 by Dirk Frederickx  Top