pygments.rb 0.5.4 → 0.6.0

data/vendor/pygments-main/tests/examplefiles/test.pwn

@@ -0,0 +1,253 @@
+#include <core>
+
+// Single line comment
+/* Multi line
+   comment */
+
+/// documentation
+/**
+
+	documentation multi line
+	
+**/
+
+public OnGameModeInit() {
+    printf("Hello, World!");
+}
+
+enum info {
+	Float:ex;
+	exa,
+	exam[5],
+}
+new arr[5][info];
+
+stock Float:test_func()
+{
+	new a = 5, Float:b = 10.3;
+	if (a == b) {
+		
+	} else {
+		
+	}
+	
+	for (new i = 0; i < 10; i++) {
+		continue;
+	}
+	
+	do {
+		a--;
+	} while (a > 0);
+	
+	while (a < 5) {
+		a++;
+		break;
+	}
+	
+	switch (a) {
+		case 0: {
+		}
+		case 0..4: {
+		}
+		case 5, 6: {
+		}
+	}
+	
+	static x;
+	new xx = a > 5 ? 5 : 0;
+	new array[sizeof arr] = {0};
+	tagof a;
+	state a;
+	goto label;
+	new byte[2 char];
+	byte{0} = 'a';
+	
+	return (float(a) + b);
+}
+
+
+// float.inc
+/* Float arithmetic
+ *
+ * (c) Copyright 1999, Artran, Inc.
+ * Written by Greg Garner (gmg@artran.com)
+ * Modified in March 2001 to include user defined
+ * operators for the floating point functions.
+ *
+ * This file is provided as is (no warranties).
+ */
+#if defined _Float_included
+  #endinput
+#endif
+#define _Float_included
+#pragma library Float
+
+/* Different methods of rounding */
+enum floatround_method {
+  floatround_round,
+  floatround_floor,
+  floatround_ceil,
+  floatround_tozero,
+  floatround_unbiased
+}
+enum anglemode {
+  radian,
+  degrees,
+  grades
+}
+
+/**************************************************/
+/* Convert an integer into a floating point value */
+native Float:float(value);
+
+/**************************************************/
+/* Convert a string into a floating point value */
+native Float:floatstr(const string[]);
+
+/**************************************************/
+/* Multiple two floats together */
+native Float:floatmul(Float:oper1, Float:oper2);
+
+/**************************************************/
+/* Divide the dividend float by the divisor float */
+native Float:floatdiv(Float:dividend, Float:divisor);
+
+/**************************************************/
+/* Add two floats together */
+native Float:floatadd(Float:oper1, Float:oper2);
+
+/**************************************************/
+/* Subtract oper2 float from oper1 float */
+native Float:floatsub(Float:oper1, Float:oper2);
+
+/**************************************************/
+/* Return the fractional part of a float */
+native Float:floatfract(Float:value);
+
+/**************************************************/
+/* Round a float into a integer value */
+native floatround(Float:value, floatround_method:method=floatround_round);
+
+/**************************************************/
+/* Compare two integers. If the two elements are equal, return 0.
+   If the first argument is greater than the second argument, return 1,
+   If the first argument is less than the second argument, return -1. */
+native floatcmp(Float:oper1, Float:oper2);
+
+/**************************************************/
+/* Return the square root of the input value, same as floatpower(value, 0.5) */
+native Float:floatsqroot(Float:value);
+
+/**************************************************/
+/* Return the value raised to the power of the exponent */
+native Float:floatpower(Float:value, Float:exponent);
+
+/**************************************************/
+/* Return the logarithm */
+native Float:floatlog(Float:value, Float:base=10.0);
+
+/**************************************************/
+/* Return the sine, cosine or tangent. The input angle may be in radian,
+   degrees or grades. */
+native Float:floatsin(Float:value, anglemode:mode=radian);
+native Float:floatcos(Float:value, anglemode:mode=radian);
+native Float:floattan(Float:value, anglemode:mode=radian);
+
+/**************************************************/
+/* Return the absolute value */
+native Float:floatabs(Float:value);
+
+
+/**************************************************/
+#pragma rational Float
+
+/* user defined operators */
+native Float:operator*(Float:oper1, Float:oper2) = floatmul;
+native Float:operator/(Float:oper1, Float:oper2) = floatdiv;
+native Float:operator+(Float:oper1, Float:oper2) = floatadd;
+native Float:operator-(Float:oper1, Float:oper2) = floatsub;
+native Float:operator=(oper) = float;
+
+stock Float:operator++(Float:oper)
+    return oper+1.0;
+
+stock Float:operator--(Float:oper)
+    return oper-1.0;
+
+stock Float:operator-(Float:oper)
+    return oper^Float:cellmin;                  /* IEEE values are sign/magnitude */
+
+stock Float:operator*(Float:oper1, oper2)
+    return floatmul(oper1, float(oper2));       /* "*" is commutative */
+
+stock Float:operator/(Float:oper1, oper2)
+    return floatdiv(oper1, float(oper2));
+
+stock Float:operator/(oper1, Float:oper2)
+    return floatdiv(float(oper1), oper2);
+
+stock Float:operator+(Float:oper1, oper2)
+    return floatadd(oper1, float(oper2));       /* "+" is commutative */
+
+stock Float:operator-(Float:oper1, oper2)
+    return floatsub(oper1, float(oper2));
+
+stock Float:operator-(oper1, Float:oper2)
+    return floatsub(float(oper1), oper2);
+
+stock bool:operator==(Float:oper1, Float:oper2)
+    return floatcmp(oper1, oper2) == 0;
+
+stock bool:operator==(Float:oper1, oper2)
+    return floatcmp(oper1, float(oper2)) == 0;  /* "==" is commutative */
+
+stock bool:operator!=(Float:oper1, Float:oper2)
+    return floatcmp(oper1, oper2) != 0;
+
+stock bool:operator!=(Float:oper1, oper2)
+    return floatcmp(oper1, float(oper2)) != 0;  /* "!=" is commutative */
+
+stock bool:operator>(Float:oper1, Float:oper2)
+    return floatcmp(oper1, oper2) > 0;
+
+stock bool:operator>(Float:oper1, oper2)
+    return floatcmp(oper1, float(oper2)) > 0;
+
+stock bool:operator>(oper1, Float:oper2)
+    return floatcmp(float(oper1), oper2) > 0;
+
+stock bool:operator>=(Float:oper1, Float:oper2)
+    return floatcmp(oper1, oper2) >= 0;
+
+stock bool:operator>=(Float:oper1, oper2)
+    return floatcmp(oper1, float(oper2)) >= 0;
+
+stock bool:operator>=(oper1, Float:oper2)
+    return floatcmp(float(oper1), oper2) >= 0;
+
+stock bool:operator<(Float:oper1, Float:oper2)
+    return floatcmp(oper1, oper2) < 0;
+
+stock bool:operator<(Float:oper1, oper2)
+    return floatcmp(oper1, float(oper2)) < 0;
+
+stock bool:operator<(oper1, Float:oper2)
+    return floatcmp(float(oper1), oper2) < 0;
+
+stock bool:operator<=(Float:oper1, Float:oper2)
+    return floatcmp(oper1, oper2) <= 0;
+
+stock bool:operator<=(Float:oper1, oper2)
+    return floatcmp(oper1, float(oper2)) <= 0;
+
+stock bool:operator<=(oper1, Float:oper2)
+    return floatcmp(float(oper1), oper2) <= 0;
+
+stock bool:operator!(Float:oper)
+    return (_:oper & cellmax) == 0;
+
+/* forbidden operations */
+forward operator%(Float:oper1, Float:oper2);
+forward operator%(Float:oper1, oper2);
+forward operator%(oper1, Float:oper2);
+

data/vendor/pygments-main/tests/examplefiles/test.r3

@@ -1,3 +1,9 @@
+preface.... everything what is before header is not evaluated
+so this should not be colorized:
+1 + 2
+
+REBOL [] ;<- this is minimal header, everything behind it must be colorized
+
 ;## String tests ##
 print "Hello ^"World" ;<- with escaped char
 multiline-string: {
@@ -52,15 +58,29 @@ type? #ff0000 ;== issue!
 to integer! (1 + (x / 4.5) * 1E-4)
 
 ;## some spec comments
-comment now
-comment 10
+1 + 1
+comment "aa"								
+2 + 2
+comment {aa}
+3 + 3
+comment {a^{}
+4 + 4
+comment {{}}
+5 + 5
 comment {
-    bla
-    bla
+	foo: 6
 }
-comment [
-    quit
-]
+6 + 6
+comment [foo: 6]
+7 + 7
+comment [foo: "[" ]
+8 + 8
+comment [foo: {^{} ]
+9 + 9
+comment [foo: {boo} ]
+10 + 10
+comment 5-May-2014/11:17:34+2:00
+5-May-2014/11:17:34+2:00 11 + 11	
 
 ;## other tests ##
 ---: 1

data/vendor/pygments-main/tests/examplefiles/test.rsl

@@ -0,0 +1,111 @@
+scheme COMPILER = 
+class
+  type
+    Prog == mk_Prog(stmt : Stmt),  
+
+    Stmt ==  
+      mk_Asgn(ide : Identifier,  expr : Expr) |   
+      mk_If(cond : Expr,  s1 : Stmt, s2 : Stmt) |   
+      mk_Seq(head : Stmt,  last : Stmt),  
+
+    Expr == 
+      mk_Const(const : Int) |  
+      mk_Plus(fst : Expr,  snd : Expr) |
+      mk_Id(ide : Identifier),
+    Identifier = Text
+
+type /* storage for program variables */
+  `Sigma = Identifier -m-> Int 
+
+value     
+  m : Prog -> `Sigma -> `Sigma
+  m(p)(`sigma)  is  m(stmt(p))(`sigma),  
+
+  m : Stmt -> `Sigma -> `Sigma
+  m(s)(`sigma)  is  
+    case s of 
+      mk_Asgn(i, e) -> `sigma !! [i +> m(e)(`sigma)], 
+      mk_Seq(s1, s2) -> m(s2)(m(s1)(`sigma)), 
+      mk_If(c, s1, s2) -> 
+        if m(c)(`sigma) ~= 0 then m(s1)(`sigma) else m(s2)(`sigma) end      
+    end,
+  
+  m : Expr -> `Sigma -> Int
+  m(e)(`sigma)  is  
+    case e of 
+      mk_Const(n) -> n, 
+      mk_Plus(e1, e2) -> m(e1)(`sigma) + m(e2)(`sigma), 
+      mk_Id(id) -> if id isin  dom `sigma then `sigma(id) else 0 end 
+    end 
+
+type
+  MProg = Inst-list,
+  Inst == 
+     mk_Push(ide1 : Identifier) | 
+     mk_Pop(Unit) | 
+     mk_Add(Unit) | 
+     mk_Cnst(val : Int) | 
+     mk_Store(ide2 : Identifier) | 
+     mk_Jumpfalse(off1 : Int) | 
+     mk_Jump(off2 : Int) 
+
+
+/* An interpreter for SMALL instructions */
+
+type  Stack = Int-list
+value 
+  I : MProg >< Int >< Stack -> (`Sigma ->`Sigma)
+  I(mp, pc, s)(`sigma) is 
+    if pc <= 0 \/ pc > len mp then `sigma else
+      case  mp(pc) of
+        mk_Push(x) -> if x isin dom `sigma 
+          then I(mp, pc + 1, <.`sigma(x).> ^ s)(`sigma)
+          else  I(mp, pc + 1, <.0.> ^ s)(`sigma) end,
+        mk_Pop(()) -> if len s = 0 then `sigma
+          else I(mp, pc + 1, tl s)(`sigma) end,
+        mk_Cnst(n)  -> I(mp, pc + 1, <.n.> ^  s)(`sigma),
+        mk_Add(()) -> if len s < 2 then `sigma 
+          else  I(mp, pc + 1,<.s(1) + s(2).> ^ tl tl s)(`sigma) end,
+        mk_Store(x) -> if len s = 0 then `sigma
+          else I(mp, pc + 1, s)(`sigma !! [x +> s(1)]) end,
+        mk_Jumpfalse(n) -> if len s = 0 then `sigma
+          elsif  hd s ~= 0  then I(mp, pc + 1, s)(`sigma) 
+          else I(mp, pc + n, s)(`sigma) end,
+        mk_Jump(n) -> I(mp, pc + n, s)(`sigma) 
+      end
+    end  
+
+value
+  comp_Prog : Prog -> MProg
+  comp_Prog(p) is comp_Stmt(stmt(p)),
+
+  comp_Stmt : Stmt -> MProg
+  comp_Stmt(s) is
+    case s of
+      mk_Asgn(id, e) -> comp_Expr(e) ^ <. mk_Store(id), mk_Pop() .>,
+      mk_Seq(s1, s2) -> comp_Stmt(s1) ^ comp_Stmt(s2),
+      mk_If(e, s1, s2) -> 
+       let 
+         ce = comp_Expr(e), 
+         cs1 = comp_Stmt(s1), cs2 = comp_Stmt(s2) 
+       in
+           ce ^ 
+           <. mk_Jumpfalse(len cs1 + 3) .> ^
+           <. mk_Pop() .> ^
+           cs1 ^
+           <. mk_Jump(len cs2 + 2) .> ^
+           <. mk_Pop() .> ^
+           cs2
+       end
+    end,
+
+  comp_Expr : Expr -> MProg
+  comp_Expr(e) is 
+    case e of
+      mk_Const(n) -> <. mk_Cnst(n) .>,
+      mk_Plus(e1, e2) -> 
+        comp_Expr(e1) ^ comp_Expr(e2) ^ <. mk_Add() .>,
+      mk_Id(id) -> <. mk_Push(id) .>
+    end
+
+end

data/vendor/pygments-main/tests/examplefiles/test.swift

@@ -0,0 +1,65 @@
+//
+//  test.swift
+//  from https://github.com/fullstackio/FlappySwift
+//
+//  Created by Nate Murray on 6/2/14.
+//  Copyright (c) 2014 Fullstack.io. All rights reserved.
+//
+
+import UIKit
+import SpriteKit
+
+extension SKNode {
+    class func unarchiveFromFile(file : NSString) -> SKNode? {
+        
+        let path = NSBundle.mainBundle().pathForResource(file, ofType: "sks")
+        
+        var sceneData = NSData.dataWithContentsOfFile(path, options: .DataReadingMappedIfSafe, error: nil)
+        var archiver = NSKeyedUnarchiver(forReadingWithData: sceneData)
+        
+        archiver.setClass(self.classForKeyedUnarchiver(), forClassName: "SKScene")
+        let scene = archiver.decodeObjectForKey(NSKeyedArchiveRootObjectKey) as GameScene
+        archiver.finishDecoding()
+        return scene
+    }
+}
+
+class GameViewController: UIViewController {
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+
+        if let scene = GameScene.unarchiveFromFile("GameScene") as? GameScene {
+            // Configure the view.
+            let skView = self.view as SKView
+            skView.showsFPS = true
+            skView.showsNodeCount = true
+            
+            /* Sprite Kit applies additional optimizations to improve rendering performance */
+            skView.ignoresSiblingOrder = true
+            
+            /* Set the scale mode to scale to fit the window */
+            scene.scaleMode = .AspectFill
+            
+            skView.presentScene(scene)
+        }
+    }
+
+    override func shouldAutorotate() -> Bool {
+        return true
+    }
+
+    override func supportedInterfaceOrientations() -> Int {
+        if UIDevice.currentDevice().userInterfaceIdiom == .Phone {
+            return Int(UIInterfaceOrientationMask.AllButUpsideDown.toRaw())
+        } else {
+            return Int(UIInterfaceOrientationMask.All.toRaw())
+        }
+    }
+
+    override func didReceiveMemoryWarning() {
+        super.didReceiveMemoryWarning()
+        // Release any cached data, images, etc that aren't in use.
+    }
+    
+}