pygments.rb 0.6.3 → 1.0.0

data/vendor/pygments-main/tests/examplefiles/qbasic_example

@@ -1,2 +0,0 @@
-10 print RIGHT$("hi there", 5)
-20 goto 10

data/vendor/pygments-main/tests/examplefiles/qsort.prolog

@@ -1,13 +0,0 @@
-partition([], _, [], []).
-partition([X|Xs], Pivot, Smalls, Bigs) :-
-    (   X @< Pivot ->
-        Smalls = [X|Rest],
-        partition(Xs, Pivot, Rest, Bigs)
-    ;   Bigs = [X|Rest],
-        partition(Xs, Pivot, Smalls, Rest)
-    ).
-
-quicksort([])     --> [].
-quicksort([X|Xs]) --> 
-    { partition(Xs, X, Smaller, Bigger) },
-    quicksort(Smaller), [X], quicksort(Bigger).

data/vendor/pygments-main/tests/examplefiles/r-console-transcript.Rout

@@ -1,38 +0,0 @@
-
-R version 2.9.2 (2009-08-24)
-Copyright (C) 2009 The R Foundation for Statistical Computing
-ISBN 3-900051-07-0
-
-R is free software and comes with ABSOLUTELY NO WARRANTY.
-You are welcome to redistribute it under certain conditions.
-Type 'license()' or 'licence()' for distribution details.
-
-  Natural language support but running in an English locale
-
-R is a collaborative project with many contributors.
-Type 'contributors()' for more information and
-'citation()' on how to cite R or R packages in publications.
-
-Type 'demo()' for some demos, 'help()' for on-line help, or
-'help.start()' for an HTML browser interface to help.
-Type 'q()' to quit R.
-
-[R.app GUI 1.29 (5464) i386-apple-darwin8.11.1]
-
-> x <- function {}
-Error: syntax error
-> x <- function() {}
-> x <- function() {
-+ cat("hello")
-+ cat("world")
-+ }
-> x
-function() {
-cat("hello")
-cat("world")
-}
-> x()
-helloworld
-> 2 + 2
-[1] 4
-> 

data/vendor/pygments-main/tests/examplefiles/r6rs-comments.scm

@@ -1,23 +0,0 @@
-#!r6rs
-
-#|
-
-   The FACT procedure computes the factorial
-
-   of a non-negative integer.
-
-|#
-
-(define fact
-
-  (lambda (n)
-
-    ;; base case
-
-    (if (= n 0)
-
-        #;(= n 1)
-
-        1       ; identity of *
-
-        (* n (fact (- n 1))))))

data/vendor/pygments-main/tests/examplefiles/ragel-cpp_rlscan

@@ -1,280 +0,0 @@
-/*
- * Lexes Ragel input files.
- *
- * @LANG: c++
- *
- * Test works with split code gen.
- */
-
-#include <iostream>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-using namespace std;
-
-void escapeXML( const char *data )
-{
-	while ( *data != 0 ) {
-		switch ( *data ) {
-			case '<': cout << "&lt;"; break;
-			case '>': cout << "&gt;"; break;
-			case '&': cout << "&amp;"; break;
-			default: cout << *data; break;
-		}
-		data += 1;
-	}
-}
-
-void escapeXML( char c )
-{
-	switch ( c ) {
-		case '<': cout << "&lt;"; break;
-		case '>': cout << "&gt;"; break;
-		case '&': cout << "&amp;"; break;
-		default: cout << c; break;
-	}
-}
-
-void escapeXML( const char *data, int len )
-{
-	for ( const char *end = data + len; data != end; data++  ) {
-		switch ( *data ) {
-			case '<': cout << "&lt;"; break;
-			case '>': cout << "&gt;"; break;
-			case '&': cout << "&amp;"; break;
-			default: cout << *data; break;
-		}
-	}
-}
-
-inline void write( const char *data )
-{
-	cout << data;
-}
-
-inline void write( char c )
-{
-	cout << c;
-}
-
-inline void write( const char *data, int len )
-{
-	cout.write( data, len );
-}
-
-
-%%{
-	machine RagelScan;
-
-	word = [a-zA-Z_][a-zA-Z_0-9]*;
-	integer = [0-9]+;
-	hex = '0x' [0-9a-fA-F] [0-9a-fA-F]*;
-
-	default = ^0;
-	EOF = 0;
-
-	# Handles comments in outside code and inline blocks.
-	c_comment := 
-		( default* :>> '*/' )
-		${ escapeXML( fc ); }
-		@{ fret; };
-
-	action emit {
-		escapeXML( ts, te-ts );
-	}
-
-	#
-	# Inline action code
-	#
-
-	ilscan := |*
-
-		"'" ( [^'\\] | /\\./ )* "'" => emit;
-		'"' ( [^"\\] | /\\./ )* '"' => emit;
-		'/*' {
-			write( "/*" );
-			fcall c_comment;
-		};
-		'//' [^\n]* '\n' => emit;
-
-		'{' {
-			write( '{' );
-			inline_depth += 1; 
-		};
-
-		'}' {
-			write( '}' );
-			/* If dropping down to the last } then return 
-			 * to ragel code. */
-			if ( --inline_depth == 0 ) {
-				write( "</inline>\n" );
-				fgoto rlscan;
-			}
-		};
-
-		default => { escapeXML( *ts ); };
-	*|;
-
-	#
-	# Ragel Tokens
-	#
-
-	rlscan := |*
-		'}%%' {
-			if ( !single_line ) {
-				write( "</section>\n" );
-				fgoto main;
-			}
-		};
-
-		'\n' {
-			if ( single_line ) {
-				write( "</section>\n" );
-				fgoto main;
-			}
-		};
-
-		# Word
-		word {
-			write( "<word>" );
-			write( ts, te-ts );
-			write( "</word>\n" );
-		};
-
-		# Decimal integer.
-		integer {
-			write( "<int>" );
-			write( ts, te-ts );
-			write( "</int>\n" );
-		};
-
-		# Hexidecimal integer.
-		hex {
-			write( "<hex>" );
-			write( ts, te-ts );
-			write( "</hex>\n" );
-		};
-
-		# Consume comments.
-		'#' [^\n]* '\n';
-
-		# Single literal string.
-		"'" ( [^'\\] | /\\./ )* "'" {
-			write( "<single_lit>" );
-			escapeXML( ts, te-ts );
-			write( "</single_lit>\n" );
-		};
-
-		# Double literal string.
-		'"' ( [^"\\] | /\\./ )* '"' {
-			write( "<double_lit>" );
-			escapeXML( ts, te-ts );
-			write( "</double_lit>\n" );
-		};
-
-		# Or literal.
-		'[' ( [^\]\\] | /\\./ )* ']' {
-			write( "<or_lit>" );
-			escapeXML( ts, te-ts );
-			write( "</or_lit>\n" );
-		};
-
-		# Regex Literal.
-		'/' ( [^/\\] | /\\./ ) * '/' {
-			write( "<re_lit>" );
-			escapeXML( ts, te-ts );
-			write( "</re_lit>\n" );
-		};
-
-		# Open an inline block
-		'{' {
-			inline_depth = 1;
-			write( "<inline>{" );
-			fgoto ilscan;
-		};
-
-		punct {
-			write( "<symbol>" );
-			escapeXML( fc );
-			write( "</symbol>\n" );
-		};
-		
-		default;
-	*|;
-
-	#
-	# Outside code.
-	#
-
-	main := |*
-
-		"'" ( [^'\\] | /\\./ )* "'" => emit;
-		'"' ( [^"\\] | /\\./ )* '"' => emit;
-
-		'/*' {
-			escapeXML( ts, te-ts );
-			fcall c_comment;
-		};
-
-		'//' [^\n]* '\n' => emit;
-
-		'%%{' { 
-			write( "<section>\n" );
-			single_line = false;
-			fgoto rlscan;
-		};
-
-		'%%' {
-			write( "<section>\n" ); 
-			single_line = true; 
-			fgoto rlscan;
-		};
-
-		default { 
-			escapeXML( *ts );
-		};
-
-		# EOF.
-		EOF;
-	*|;
-}%%
-
-%% write data nofinal;
-
-void test( const char *data )
-{
-	std::ios::sync_with_stdio(false);
-
-	int cs, act;
-	const char *ts, *te;
-	int stack[1], top;
-
-	bool single_line = false;
-	int inline_depth = 0;
-
-	%% write init;
-
-	/* Read in a block. */
-	const char *p = data;
-	const char *pe = data + strlen( data );
-	const char *eof = pe;
-	%% write exec;
-
-	if ( cs == RagelScan_error ) {
-		/* Machine failed before finding a token. */
-		cerr << "PARSE ERROR" << endl;
-		exit(1);
-	}
-}
-
-#define BUFSIZE 2048
-
-int main()
-{
-	std::ios::sync_with_stdio(false);
-
-	test("hi %%{ /'}%%'/ { /*{*/ {} } + '\\'' }%%there\n");
-
-	return 0;
-}

data/vendor/pygments-main/tests/examplefiles/ragel-cpp_snippet

@@ -1,2 +0,0 @@
-	%% write init;
-	/* Read in a block. */

data/vendor/pygments-main/tests/examplefiles/regex.js

@@ -1,22 +0,0 @@
-// regex
-
-blah(/abc/);
-x = /abc/;
-x = /abc/.match;
-
-// math
-
-blah(1/2); //comment
-x = 1 / 2 / 3;
-x = 1/1/.1;
-
-// broken
-
-x=/1/;
-x=1/a/g;
-x=a/a/g;
-
-// real-world
-
-var x = 1/(1+Math.sqrt(sum)); // convert to number between 1-0
-return Math.round((num / den) * 100)/100;

data/vendor/pygments-main/tests/examplefiles/reversi.lsp

@@ -1,427 +0,0 @@
-#!/usr/bin/env newlisp
-;; @module reversi.lsp
-;; @description a simple version of Reversi: you as white against newLISP as black
-;; @version 0.1 alpha August 2007
-;; @author cormullion
-;;
-;; 2008-10-08 21:46:54
-;; updated for newLISP version 10. (changed nth-set to setf)
-;; this now does not work with newLISP version 9!
-;;
-;; This is my first attempt at writing a simple application using newLISP-GS.
-;; The game algorithms are basically by 
-;; Peter Norvig http://norvig.com/paip/othello.lisp
-;; and all I've done is translate to newLISP and add the interface...
-;;
-;; To-Do: work out how to handle the end of the game properly...
-;; To-Do: complete newlispdoc for the functions
-
-(constant 'empty 0) 
-(constant 'black 1) 
-(constant 'white 2)
-(constant 'outer 3) ; squares outside the 8x8 board
-
-(set '*board* '()) ; the master board is a 100 element list
-(set '*moves* '()) ; list of moves made
-
-; these are the 8 different directions from a square on the board
-
-(set 'all-directions '(-11 -10 -9 -1 1 9 10 11))
-
-; return a list of all the playable squares (the 8 by 8 grid inside the 10by10
-
-(define (all-squares)
-  (local (result)
-     (for (square 11 88)
-        (if (<= 1 (mod square 10) 8)
-           (push square result -1)))
-result))
-
-; make a board
-
-(define (make-board)
-  (set '*board* (dup outer 100))
-  (dolist (s (all-squares))
-     (setf (*board* s) empty)))
-
-; for testing and working at a terminal
-
-(define (print-board)
-  (print { })
-  (for (c 1 8)
-     (print c))
-  (set 'c 0)
-  (for (i 0 99)
-     (cond
-        ((= (*board* i) 0) (print {.}))
-        ((= (*board* i) 1) (print {b}))
-        ((= (*board* i) 2) (print {w})))
-     (if (and (<= i 88) (= (mod (+ i 1) 10) 0)) ; newline
-        (print "\n" (inc c))))
-  (println "\n"))
-
-; the initial starting pattern
-
-(define (initial-board)
-  (make-board)
-  (setf (*board* 44) white)
-  (setf (*board* 55) white)
-  (setf (*board* 45) black)
-  (setf (*board* 54) black))
-
-(define (opponent player)
-  (if (= player black) white black))
-
-(define (player-name player)
-  (if (= player white) "white" "black"))
-  
-(define (valid-move? move)
-  (and 
-     (integer? move)
-     (<= 11 move 88)
-     (<= 1 (mod move 10) 8)))
-
-(define (empty-square? square)
-  (and
-     (valid-move? square)
-     (= (*board* square) empty)))
-     
-; test whether a move is legal. The square must be empty
-; and it must flip at least one of the opponent's piece
-
-(define (legal-move? move player)
-  (and 
-     (empty-square? move)
-     (exists (fn (dir) (would-flip? move player dir)) all-directions)))
-
-; would this move by player result in any flips in the given direction?
-; if so, return the number of the 'opposite' (bracketing) piece's square
-
-(define (would-flip? move player dir) 
-  (let 
-     ((c (+ move dir)))
-     (and 
-        (= (*board* c) (opponent player))
-        (find-bracketing-piece (+ c dir) player dir))))
-  
-(define (find-bracketing-piece square player dir)
-  ; return the square of the bracketing piece, if any
-  (cond
-     ((= (*board* square) player) square)
-     ((= (*board* square) (opponent player))
-        (find-bracketing-piece (+ square dir) player dir))
-     (true nil)))
-
-(define (make-flips move player dir)
-  (let 
-     ((bracketer (would-flip? move player dir))
-      (c (+ move dir)))
-  (if bracketer
-     (do-until (= c bracketer)
-        (setf (*board* c) player)
-        (push c *flips* -1)
-        (inc c dir)))))
-
-; make the move on the master game board, not yet visually
-
-(define (make-move move player)
-  (setf (*board* move) player)
-  (push move *moves* -1)
-  (set '*flips* '()) ; we're going to keep a record of the flips made
-  (dolist (dir all-directions)
-     (make-flips move player dir)))
-
-(define (next-to-play previous-player)
-  (let ((opp (opponent previous-player)))
-     (cond
-        ((any-legal-move? opp) opp)
-        ((any-legal-move? previous-player)
-           (println (player-name opp) " has no moves")
-           previous-player)
-        (true nil))))
-        
-; are there any legal moves (returns first) for this player?
-(define (any-legal-move? player)
-  (exists (fn (move) (legal-move? move player)) 
-     (all-squares)))
-
-; a list of all legal moves might be useful
-(define (legal-moves player)
-  (let ((result '()))
-     (dolist (move (all-squares))
-        (if (legal-move? move player)
-           (push move result)))
-  (unique result)))
-
-; define any number of strategies that can be called on to calculate
-; the next computer move. This is the only one I've done... - make 
-; any legal move at random!
-
-(define (random-strategy player)
-  (seed (date-value))
-  (apply amb (legal-moves player)))
-
-; get the next move using a particular strategy
-
-(define (get-move strategy player)
- (let ((move (apply strategy (list player))))
-  (cond
-     ((and
-        (valid-move? move)
-        (legal-move? move player))
-            (make-move move player))
-     (true  
-        (println "no valid or legal move for " (player-name player) )
-        nil))
-  move))
-
-; that's about all the game algorithms for now
-; now for the interface
-
-(if (= ostype "Win32")
-   (load (string (env "PROGRAMFILES") "/newlisp/guiserver.lsp"))
-   (load "/usr/share/newlisp/guiserver.lsp")
-)
-
-(gs:init)
-(map set '(screen-width screen-height) (gs:get-screen))
-(set 'board-width 540)
-; center on screen
-(gs:frame 'Reversi (- (/ screen-width 2) (/ board-width 2)) 60 board-width 660 "Reversi")
-(gs:set-border-layout 'Reversi)
-
-(gs:canvas 'MyCanvas 'Reversi)
-  (gs:set-background 'MyCanvas '(.8 .9 .7 .8))
-  (gs:mouse-released 'MyCanvas 'mouse-released-action true)
-
-(gs:panel 'Controls)
-  (gs:button 'Start 'start-game "Start")
-
-(gs:panel 'Lower)
-  (gs:label 'WhiteScore "")
-  (gs:label 'BlackScore "")
-
-(gs:add-to 'Controls 'Start )
-(gs:add-to 'Lower 'WhiteScore 'BlackScore)
-(gs:add-to 'Reversi 'MyCanvas "center" 'Controls "north" 'Lower "south")
-
-(gs:set-anti-aliasing true)
-(gs:set-visible 'Reversi true)
-
-; size of board square, and radius/width of counter
-(set 'size 60 'width 30)
-
-; initialize the master board
-
-(define (initial-board)
-  (make-board)
-  (setf (*board* 44) white)
-  (setf (*board* 55) white)
-  (setf (*board* 45) black)
-  (setf (*board* 54) black)  
-)
-
-; draw a graphical repesentation of the board
-
-(define (draw-board)
-  (local (x y)
-     (dolist (i (all-squares))
-        (map set '(x y) (square-to-xy i))
-        (gs:draw-rect 
-           (string x y) 
-           (- (* y size) width ) ; !!!!!!
-           (- (* x size) width )
-           (* width 2)
-           (* width 2)
-           gs:white))))
-
-(define (draw-first-four-pieces)
-  (draw-piece 44 "white")
-  (draw-piece 55 "white")
-  (draw-piece 45 "black")
-  (draw-piece 54 "black"))
-
-; this next function can mark the legal moves available to a player
-
-(define (show-legal-moves player)
-  (local (legal-move-list x y)
-     (set 'legal-move-list (legal-moves player))
-     (dolist (m (all-squares))
-        (map set '(x y) (square-to-xy m))
-        (gs:draw-rect 
-           (string x y) 
-           (- (* y size) width ) ; !!!!!!
-           (- (* x size) width )
-           (* width 2)
-           (* width 2)
-           (if (find m legal-move-list) gs:blue gs:white)
-        )
-     )
-  )
-)
-
-; convert the number of a square on the master board to coordinates
-
-(define (square-to-xy square) 
-  (list (/ square 10) (mod square 10)))
-
-; draw one of the pieces
-
-(define (draw-piece square colour)
-  (local (x y)
-  (map set '(x y) (square-to-xy square))
-  (cond 
-     ((= colour "white") 
-        (gs:fill-circle 
-           (string x y) 
-           (* y size)  ; !!!!!!! y first, cos y is x ;-)
-           (* x size) 
-           width
-           gs:white))
-     
-     ((= colour "black") 
-        (gs:fill-circle 
-           (string x y) 
-           (* y size) 
-           (* x size) 
-           width
-           gs:black))
-     
-     ((= colour "empty") 
-        (gs:draw-rect 
-           (string x y) 
-           (- (* y size) width ) 
-           (- (* x size) width )
-           (* width 2)
-           (* width 2)
-           gs:white))
-  )))
-
-; animate the pieces flipping
-
-(define (flip-piece square player)
-; flip by drawing thinner and fatter ellipses 
-; go from full disk in opposite colour to invisible
-; then from invisible to full disk in true colour
-  (local (x y colour)
-     (map set '(x y) (square-to-xy square))
-     ; delete original piece
-     (gs:delete-tag (string x y))
-     (set 'colour (if (= player 2) gs:black gs:white )) 
-     (for (i width  1 -3)
-        (gs:fill-ellipse 
-           (string x y {flip} i) 
-           (* y size) ; y first :-) !!! 
-           (* x size) 
-           i 
-           width
-           colour)
-        (sleep 20)  ; this might need adjusting...
-        (gs:delete-tag (string x y {flip} i))
-     )
-     (set 'colour (if (= player 2) gs:white gs:black))
-     (for (i 1 width 3)
-        (gs:fill-ellipse 
-           (string x y {flip} i) 
-           (* y size) ; :-) !!! 
-           (* x size) 
-           i 
-           width
-           colour)
-        (sleep 20)  
-        (gs:delete-tag (string x y {flip} i))
-     )
-     ; draw the piece again
-     (gs:fill-circle 
-           (string x y) 
-           (* y size)
-           (* x size) 
-           width
-           colour)
-  )
-)
-
-(define (do-move move player)
-  (cond 
-     ; check if the move is good ...
-     ((and (!= player nil)
-           (valid-move? move)
-           (legal-move? move player))
-           
-           ; ... play it
-              ; make move on board
-              (make-move move player)
-              ; and on screen
-              (draw-piece move (player-name player))
-              (gs:update)
-              ; do flipping stuff
-              
-              ; wait for a while
-              (sleep 1000)
-  
-              ; then do flipping
-              (dolist (f *flips*)
-                 (flip-piece f player))
-              
-              (inc *move-number*)
-              (draw-piece move (player-name player))
-              (gs:update)
-
-              ; update scores
-              (gs:set-text 'WhiteScore 
-                 (string "White: " (first (count (list white) *board*))))
-              (gs:set-text 'BlackScore
-                 (string "Black: " (first (count (list black) *board*))))
-              )
-     ; or return nil
-     (true 
-           nil)))
-
-; the game is driven by the mouse clicks of the user
-; in reply, the computer plays a black piece
-; premature clicking is possible and possibly a bad thing...
-
-(define (mouse-released-action x y button modifiers tags)
-  ; extract the tag of the clicked square
-  (set 'move (int (string (first tags)) 0 10))
-  (if (do-move move player)
-     (begin
-        (set 'player (next-to-play player))
-        ; there is a training mode - legal squares are highlighted
-        ; you can uncomment the next line...
-        ; (show-legal-moves player)
-        (gs:update)
-        
-        ; wait for black's reply
-        (gs:set-cursor 'Reversi "wait")
-        (gs:set-text 'Start "black's move - thinking...")
-        ; give the illusion of Deep Thought...
-        (sleep 2000)
-        ; black's reply
-        ; currently only the random strategy has been defined...
-        (set 'strategy random-strategy)
-        (set 'move (apply strategy (list player)))
-        (do-move move player)
-        (set 'player (next-to-play player))
-        ; (show-legal-moves player) ; to see black's moves
-        (gs:set-text 'Start "your move")
-        (gs:set-cursor 'Reversi "default")
-        (gs:update))))
-
-(define (start-game)
-  (gs:set-text 'Start "Click a square to place a piece!")
-  (gs:disable 'Start)
-  (set 'player white))
-
-(define (start)
-  (gs:set-text 'Start "Start")
-  (gs:enable 'Start)
-  (set  '*move-number* 1
-        '*flips* '())
-  (initial-board)
-  (draw-board)
-  (draw-first-four-pieces))
-
-(start)
-
-(gs:listen)