pygments.rb 0.6.3 → 1.0.0

data/vendor/pygments-main/tests/examplefiles/intsyn.sig

@@ -1,286 +0,0 @@
-(* Internal Syntax *)  
-(* Author: Frank Pfenning, Carsten Schuermann *)
-(* Modified: Roberto Virga *)
-
-signature INTSYN =
-sig
-
-  type cid = int			(* Constant identifier        *)
-  type mid = int                        (* Structure identifier       *)
-  type csid = int                       (* CS module identifier       *)
-
-
-  type FgnExp = exn                     (* foreign expression representation *)
-  exception UnexpectedFgnExp of FgnExp
-                                        (* raised by a constraint solver
-					   if passed an incorrect arg *)
-  type FgnCnstr = exn                   (* foreign constraint representation *)
-  exception UnexpectedFgnCnstr of FgnCnstr
-                                        (* raised by a constraint solver
-                                           if passed an incorrect arg *)
-
-  (* Contexts *)
-
-  datatype 'a Ctx =			(* Contexts                   *)
-    Null				(* G ::= .                    *)
-  | Decl of 'a Ctx * 'a			(*     | G, D                 *)
-    
-  val ctxPop : 'a Ctx -> 'a Ctx
-  val ctxLookup: 'a Ctx * int -> 'a
-  val ctxLength: 'a Ctx -> int
-
-  datatype Depend =                     (* Dependency information     *)
-    No                                  (* P ::= No                   *)
-  | Maybe                               (*     | Maybe                *)
-  | Meta				(*     | Meta                 *)
-
-  (* expressions *)
-
-  datatype Uni =			(* Universes:                 *)
-    Kind				(* L ::= Kind                 *)
-  | Type				(*     | Type                 *)
-
-  datatype Exp =			(* Expressions:               *)
-    Uni   of Uni			(* U ::= L                    *)
-  | Pi    of (Dec * Depend) * Exp	(*     | Pi (D, P). V         *)
-  | Root  of Head * Spine		(*     | H @ S                *)
-  | Redex of Exp * Spine		(*     | U @ S                *)
-  | Lam   of Dec * Exp			(*     | lam D. U             *)
-  | EVar  of Exp option ref * Dec Ctx * Exp * (Cnstr ref) list ref
-                                        (*     | X<I> : G|-V, Cnstr   *)
-  | EClo  of Exp * Sub			(*     | U[s]                 *)
-  | AVar  of Exp option ref             (*     | A<I>                 *)
-
-  | FgnExp of csid * FgnExp             (*     | (foreign expression) *)
-
-  | NVar  of int			(*     | n (linear, 
-                                               fully applied variable
-                                               used in indexing       *)
-
-  and Head =				(* Head:                      *)
-    BVar  of int			(* H ::= k                    *)
-  | Const of cid			(*     | c                    *)
-  | Proj  of Block * int		(*     | #k(b)                *)
-  | Skonst of cid			(*     | c#                   *)
-  | Def   of cid			(*     | d (strict)           *)
-  | NSDef of cid			(*     | d (non strict)       *)
-  | FVar  of string * Exp * Sub		(*     | F[s]                 *)
-  | FgnConst of csid * ConDec           (*     | (foreign constant)   *)
-
-  and Spine =				(* Spines:                    *)
-    Nil					(* S ::= Nil                  *)
-  | App   of Exp * Spine		(*     | U ; S                *)
-  | SClo  of Spine * Sub		(*     | S[s]                 *)
-
-  and Sub =				(* Explicit substitutions:    *)
-    Shift of int			(* s ::= ^n                   *)
-  | Dot   of Front * Sub		(*     | Ft.s                 *)
-
-  and Front =				(* Fronts:                    *)
-    Idx of int				(* Ft ::= k                   *)
-  | Exp of Exp				(*     | U                    *)
-  | Axp of Exp				(*     | U                    *)
-  | Block of Block			(*     | _x                   *)
-  | Undef				(*     | _                    *)
-
-  and Dec =				(* Declarations:              *)
-    Dec of string option * Exp		(* D ::= x:V                  *)
-  | BDec of string option * (cid * Sub)	(*     | v:l[s]               *)
-  | ADec of string option * int	        (*     | v[^-d]               *)
-  | NDec of string option 
-
-  and Block =				(* Blocks:                    *)
-    Bidx of int				(* b ::= v                    *)
-  | LVar of Block option ref * Sub * (cid * Sub)
-                                        (*     | L(l[^k],t)           *)
-  | Inst of Exp list                    (*     | U1, ..., Un          *)
-  (* It would be better to consider having projections count
-     like substitutions, then we could have Inst of Sub here, 
-     which would simplify a lot of things.  
-
-     I suggest however to wait until the next big overhaul 
-     of the system -- cs *)
-
-
-(*  | BClo of Block * Sub                 (*     | b[s]                 *) *)
-
-  (* constraints *)
-
-  and Cnstr =				(* Constraint:                *)
-    Solved                      	(* Cnstr ::= solved           *)
-  | Eqn      of Dec Ctx * Exp * Exp     (*         | G|-(U1 == U2)    *)
-  | FgnCnstr of csid * FgnCnstr         (*         | (foreign)        *)
-
-  and Status =                          (* Status of a constant:      *)
-    Normal                              (*   inert                    *)
-  | Constraint of csid * (Dec Ctx * Spine * int -> Exp option)
-                                        (*   acts as constraint       *)
-  | Foreign of csid * (Spine -> Exp)    (*   is converted to foreign  *)
-
-  and FgnUnify =                        (* Result of foreign unify    *)
-    Succeed of FgnUnifyResidual list
-    (* succeed with a list of residual operations *)
-  | Fail
-
-  and FgnUnifyResidual =
-    Assign of Dec Ctx * Exp * Exp * Sub
-    (* perform the assignment G |- X = U [ss] *)
-  | Delay of Exp * Cnstr ref
-    (* delay cnstr, associating it with all the rigid EVars in U  *)
-
-  (* Global signature *)
-
-  and ConDec =			        (* Constant declaration       *)
-    ConDec of string * mid option * int * Status
-                                        (* a : K : kind  or           *)
-              * Exp * Uni	        (* c : A : type               *)
-  | ConDef of string * mid option * int	(* a = A : K : kind  or       *)
-              * Exp * Exp * Uni		(* d = M : A : type           *)
-              * Ancestor                (* Ancestor info for d or a   *)
-  | AbbrevDef of string * mid option * int
-                                        (* a = A : K : kind  or       *)
-              * Exp * Exp * Uni		(* d = M : A : type           *)
-  | BlockDec of string * mid option     (* %block l : SOME G1 PI G2   *)
-              * Dec Ctx * Dec list
-  | BlockDef of string * mid option * cid list
-                                        (* %block l = (l1 | ... | ln) *)
-  | SkoDec of string * mid option * int	(* sa: K : kind  or           *)
-              * Exp * Uni	        (* sc: A : type               *)
-
-  and Ancestor =			(* Ancestor of d or a         *)
-    Anc of cid option * int * cid option (* head(expand(d)), height, head(expand[height](d)) *)
-                                        (* NONE means expands to {x:A}B *)
-
-  datatype StrDec =                     (* Structure declaration      *)
-      StrDec of string * mid option
-
-  (* Form of constant declaration *)
-  datatype ConDecForm =
-    FromCS				(* from constraint domain *)
-  | Ordinary				(* ordinary declaration *)
-  | Clause				(* %clause declaration *)
-
-  (* Type abbreviations *)
-  type dctx = Dec Ctx			(* G = . | G,D                *)
-  type eclo = Exp * Sub   		(* Us = U[s]                  *)
-  type bclo = Block * Sub   		(* Bs = B[s]                  *)
-  type cnstr = Cnstr ref
-
-  exception Error of string		(* raised if out of space     *)
-
-  (* standard operations on foreign expressions *)
-  structure FgnExpStd : sig
-    (* convert to internal syntax *)
-    structure ToInternal : FGN_OPN where type arg = unit
-                                   where type result = Exp
-
-    (* apply function to subterms *)
-    structure Map : FGN_OPN where type arg = Exp -> Exp
-			    where type result = Exp
-
-    (* apply function to subterms, for effect *)
-    structure App : FGN_OPN where type arg = Exp -> unit
-			    where type result = unit
-
-    (* test for equality *)
-    structure EqualTo : FGN_OPN where type arg = Exp
-                                where type result = bool
-
-    (* unify with another term *)
-    structure UnifyWith : FGN_OPN where type arg = Dec Ctx * Exp
-                                  where type result = FgnUnify
-
-    (* fold a function over the subterms *)
-    val fold : (csid * FgnExp) -> (Exp * 'a -> 'a) -> 'a -> 'a
-  end
-
-  (* standard operations on foreign constraints *)
-  structure FgnCnstrStd : sig
-    (* convert to internal syntax *)
-    structure ToInternal : FGN_OPN where type arg = unit
-                                   where type result = (Dec Ctx * Exp) list
-
-    (* awake *)
-    structure Awake : FGN_OPN where type arg = unit
-                              where type result = bool
-
-    (* simplify *)
-    structure Simplify : FGN_OPN where type arg = unit
-                                 where type result = bool
-  end
-  
-  val conDecName   : ConDec -> string
-  val conDecParent : ConDec -> mid option
-  val conDecImp    : ConDec -> int
-  val conDecStatus : ConDec -> Status
-  val conDecType   : ConDec -> Exp
-  val conDecBlock  : ConDec -> dctx * Dec list
-  val conDecUni    : ConDec -> Uni
-
-  val strDecName   : StrDec -> string
-  val strDecParent : StrDec -> mid option
-
-  val sgnReset     : unit -> unit
-  val sgnSize      : unit -> cid * mid
-
-  val sgnAdd   : ConDec -> cid
-  val sgnLookup: cid -> ConDec
-  val sgnApp   : (cid -> unit) -> unit
-
-  val sgnStructAdd    : StrDec -> mid
-  val sgnStructLookup : mid -> StrDec
-
-  val constType   : cid -> Exp		(* type of c or d             *)
-  val constDef    : cid -> Exp		(* definition of d            *)
-  val constImp    : cid -> int
-  val constStatus : cid -> Status
-  val constUni    : cid -> Uni
-  val constBlock  : cid -> dctx * Dec list
-
-  (* Declaration Contexts *)
-
-  val ctxDec    : dctx * int -> Dec	(* get variable declaration   *)
-  val blockDec  : dctx * Block * int -> Dec 
-
-  (* Explicit substitutions *)
-
-  val id        : Sub			(* id                         *)
-  val shift     : Sub			(* ^                          *)
-  val invShift  : Sub                   (* ^-1                        *)
-
-  val bvarSub   : int * Sub -> Front    (* k[s]                       *)
-  val frontSub  : Front * Sub -> Front	(* H[s]                       *)
-  val decSub    : Dec * Sub -> Dec	(* x:V[s]                     *)
-  val blockSub  : Block * Sub -> Block  (* B[s]                       *)
-
-  val comp      : Sub * Sub -> Sub	(* s o s'                     *)
-  val dot1      : Sub -> Sub		(* 1 . (s o ^)                *)
-  val invDot1   : Sub -> Sub		(* (^ o s) o ^-1)             *)
-
-  (* EVar related functions *)
-
-  val newEVar    : dctx * Exp -> Exp	(* creates X:G|-V, []         *) 
-  val newAVar    : unit ->  Exp	        (* creates A (bare)           *) 
-  val newTypeVar : dctx -> Exp		(* creates X:G|-type, []      *)
-  val newLVar    : Sub * (cid * Sub) -> Block	
-					(* creates B:(l[^k],t)        *) 
-
-  (* Definition related functions *)
-  val headOpt : Exp -> Head option
-  val ancestor : Exp -> Ancestor
-  val defAncestor : cid -> Ancestor
-
-  (* Type related functions *)
-
-  (* Not expanding type definitions *)
-  val targetHeadOpt : Exp -> Head option (* target type family or NONE *)
-  val targetHead : Exp -> Head           (* target type family         *)
-
-  (* Expanding type definitions *)
-  val targetFamOpt : Exp -> cid option  (* target type family or NONE *)
-  val targetFam : Exp -> cid            (* target type family         *)
-
-  (* Used in Flit *)
-  val rename : cid * string -> unit
-
-end;  (* signature INTSYN *)

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

@@ -1,8 +0,0 @@
-irb(main):001:0> puts <<XYZ
-irb(main):002:0" a
-irb(main):003:0" b
-irb(main):004:0" XYZ
-a
-b
-=> nil
-irb(main):005:0> 

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

@@ -1,214 +0,0 @@
-#!/usr/bin/env newlisp
-
-;; @module IRC
-;; @description a basic irc library
-;; @version early alpha! 0.1 2011-10-31 14:21:26
-;; @author cormullion
-;; Usage:
-;; (IRC:init "newlithper") ; a username/nick (not that one obviously :-)
-;; (IRC:connect "irc.freenode.net" 6667) ; irc/server
-;; (IRC:join-channel {#newlisp}) ; join a room
-;; either (IRC:read-irc-loop) ; loop - monitor only, no input
-;; or     (IRC:session)       ; a command-line session, end with /QUIT
-
-(context 'IRC)
-    (define Inickname)
-    (define Ichannels)
-    (define Iserver)
-    (define Iconnected)
-    (define Icallbacks '())
-    (define Idle-time 400) ; seconds
-    (define Itime-stamp)   ; time since last message was processed
-
-(define (register-callback callback-name callback-function)
-    (println {registering callback for } callback-name { : } (sym (term callback-function) (prefix callback-function)))
-    (push (list callback-name (sym (term callback-function) (prefix callback-function))) Icallbacks)) 
-
-(define (do-callback callback-name data)
-   (when (set 'func (lookup callback-name Icallbacks)) ; find first callback
-         (if-not (catch (apply func (list data)) 'error)
-                 (println {error in callback } callback-name {: } error))))
-
-(define (do-callbacks callback-name data)
-   (dolist (rf (ref-all callback-name Icallbacks))
-        (set 'callback-entry (Icallbacks (first rf)))
-        (when   (set 'func (last callback-entry))
-                (if-not (catch (apply func (list data)) 'error)
-                (println {error in callback } callback-name {: } error)))))
-
-(define (init str)
-   (set 'Inickname str)
-   (set 'Iconnected nil)
-   (set 'Ichannels '())
-   (set 'Itime-stamp (time-of-day)))
-
-(define (connect server port)
-    (set 'Iserver     (net-connect server port))
-    (net-send Iserver (format "USER %s %s %s :%s\r\n" Inickname Inickname Inickname Inickname))
-    (net-send Iserver (format "NICK %s \r\n" Inickname))
-    (set 'Iconnected true)
-    (do-callbacks "connect" (list (list "server" server) (list "port" port))))
-
-(define (identify password)
-    (net-send Iserver (format "PRIVMSG nickserv :identify %s\r\n" password)))
-
-(define (join-channel channel)
-    (when (net-send Iserver (format "JOIN %s \r\n" channel))
-          (push channel Ichannels)
-          (do-callbacks "join-channel" (list (list "channel" channel) (list "nickname" Inickname)))))
-
-(define (part chan)
-    (if-not (empty? chan)
-        ; leave specified
-        (begin
-            (net-send Iserver (format "PART %s\r\n" chan))
-            (replace channel Ichannels)
-            (do-callbacks "part" (list (list "channel" channel))))
-        ; leave all
-        (begin
-            (dolist (channel Ichannels)
-                (net-send Iserver (format "PART %s\r\n" channel))
-                (replace channel Ichannels)
-                (do-callbacks "part" (list (list "channel" channel)))))))
-
-(define (do-quit message)
-    (do-callbacks "quit" '()) ; chance to do stuff before quit...
-    (net-send Iserver (format "QUIT :%s\r\n" message))
-    (sleep 1000)
-    (set 'Ichannels '())
-    (close Iserver)
-    (set 'Iconnected nil))
-
-(define (privmsg user message)
-    (net-send Iserver (format "PRIVMSG %s :%s\r\n" user message)))
-
-(define (notice user message)
-    (net-send Iserver (format "NOTICE %s :%s\r\n" user message)))
-
-(define (send-to-server message (channel nil))
-    (cond
-        ((starts-with message {/}) ; default command character
-            (set 'the-message (replace "^/" (copy message) {} 0)) ; keep original
-            (net-send Iserver (format "%s \r\n" the-message)) ; send it
-            ; do a quit
-            (if (starts-with (lower-case the-message) "quit")
-                (do-quit { enough})))
-        (true 
-            (if (nil? channel)
-                ; say to all channels
-                (dolist (c Ichannels)
-                        (net-send Iserver (format "PRIVMSG %s :%s\r\n" c message)))
-                ; say to specified channel
-                (if (find channel Ichannels)
-                    (net-send Iserver (format "PRIVMSG %s :%s\r\n" channel message))))))
-    (do-callbacks "send-to-server" (list (list "channel" channel) (list "message" message))))
-
-(define (process-command sender command text)
-    (cond
-        ((= sender "PING")
-            (net-send Iserver (format "PONG %s\r\n" command)))
-        ((or (= command "NOTICE") (= command "PRIVMSG"))
-            (process-message sender command text))
-        ((= command "JOIN")
-            (set 'username (first (clean empty? (parse sender {!|:} 0))))
-            (set 'channel  (last  (clean empty? (parse sender {!|:} 0))))
-            (println {username } username { joined } channel)
-            (do-callbacks "join" (list (list "channel" channel) (list "username" username))))
-        (true
-            nil)))
-
-(define (process-message sender command text)
-    (let ((username {} target {} message {}))
-        (set 'username (first (clean empty? (parse sender {!|:} 0))))
-        (set 'target   (trim  (first (clean empty? (parse text {!|:} 0)))))
-        (set 'message  (slice text (+ (find {:} text) 1)))
-        (cond 
-            ((starts-with message "\001")
-                (process-ctcp username target message))
-            ((find target Ichannels)
-                (cond 
-                    ((= command {PRIVMSG})
-                        (do-callbacks "channel-message" (list (list "channel" target) (list "username" username) (list "message" message))))
-                    ((= command {NOTICE})
-                        (do-callbacks "channel-notice"  (list (list "channel" target) (list "username" username) (list "message" message))))))
-            ((= target Inickname)
-                (cond 
-                    ((= command {PRIVMSG})
-                        (do-callbacks "private-message" (list (list "username" username) (list "message" message))))
-                    ((= command {NOTICE})
-                        (do-callbacks "private-notice"  (list (list "username" username) (list "message" message))))))
-            (true                
-                nil))))
-  
-(define (process-ctcp username target message)
-    (cond
-        ((starts-with message "\001VERSION\001")
-            (net-send Iserver (format "NOTICE %s :\001VERSION %s\001\r\n" username version)))
-        ((starts-with message "\001PING")
-            (set 'data (first (rest (clean empty? (parse message { } 0)))))
-            (set 'data (trim data "\001" "\001"))
-            (net-send Iserver  (format "NOTICE %s :\001PING %s\001\r\n" username data)))
-        ((starts-with message "\001ACTION")
-            (set 'data (first (rest (clean empty? (parse message { } 0)))))
-            (set 'data (join data { }))
-            (set 'data (trim data "\001" "\001"))
-            (if (find target Ichannels)
-                (do-callbacks "channel-action" (list (list "username" username) (list "message" message))))
-            (if (= target Inickname)
-                (do-callbacks "private-action" (list (list "username" username) (list "message" message)))))
-        ((starts-with message "\001TIME\001")
-            (net-send Iserver (format "NOTICE %s:\001TIME :%s\001\r\n" username (date))))))
-
-(define (parse-buffer raw-buffer)
-    (let ((messages (clean empty? (parse raw-buffer "\r\n" 0)))
-          (sender {} command {} text {}))
-        ; check for elapsed time since last activity    
-        (when (> (sub (time-of-day) Itime-stamp) (mul Idle-time 1000))
-              (do-callbacks "idle-event")
-              (set 'Itime-stamp (time-of-day)))
-        (dolist (message messages)
-            (set 'message-parts (parse message { }))           
-            (unless (empty? message-parts)
-                (set 'sender (first message-parts))
-                (catch (set 'command (first (rest message-parts))) 'error)
-                (catch (set 'text (join (rest (rest message-parts)) { })) 'error))
-            (process-command sender command text))))
-
-(define (read-irc)
-    (let ((buffer {}))
-        (when (!= (net-peek Iserver) 0) 
-              (net-receive Iserver buffer 8192 "\n")
-              (unless (empty? buffer)
-                (parse-buffer buffer)))))
-
-(define (read-irc-loop) ; monitoring
-    (let ((buffer {}))       
-        (while Iconnected    
-            (read-irc)
-            (sleep 1000))))
-
-(define (print-raw-message data) ; example of using a callback
-    (set 'raw-data (lookup "message" data))
-    (set 'channel  (lookup "channel" data))
-    (set 'message-text raw-data)
-    (println (date (date-value) 0 {%H:%M:%S }) username {> } message-text))
-
-(define (print-outgoing-message data)
-    (set 'raw-data (lookup "message" data))
-    (set 'channel  (lookup "channel" data))
-    (set 'message-text raw-data)
-    (println (date (date-value) 0 {%H:%M:%S }) Inickname {> } message-text))
-
-(define (session); interactive terminal
-    ; must add callbacks to display messages
-    (register-callback "channel-message" 'print-raw-message)
-    (register-callback "send-to-server"  'print-outgoing-message)
-    (while Iconnected
-        (while (zero? (peek 0))
-            (read-irc))
-        (send-to-server (string (read-line 0))))
-    (println {finished session } (date))
-    (exit))
-
-; end of IRC code
-