pygments.rb-jruby 0.5.4

data/vendor/pygments-main/tests/examplefiles/swig_std_vector.i

@@ -0,0 +1,225 @@
+//
+// std::vector
+//
+
+%include <std_container.i>
+
+// Vector
+
+%define %std_vector_methods(vector...)
+  %std_sequence_methods(vector)
+  
+  void reserve(size_type n);
+  size_type capacity() const;
+%enddef
+
+
+%define %std_vector_methods_val(vector...)
+  %std_sequence_methods_val(vector)
+  
+  void reserve(size_type n);
+  size_type capacity() const;
+%enddef
+
+
+// ------------------------------------------------------------------------
+// std::vector
+// 
+// The aim of all that follows would be to integrate std::vector with 
+// as much as possible, namely, to allow the user to pass and 
+// be returned tuples or lists.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::vector<T>), f(const std::vector<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::vector<T> can be passed.
+//   -- f(std::vector<T>&), f(std::vector<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::vector
+//      can be passed.
+//   -- std::vector<T> f(), const std::vector<T>& f():
+//      the vector is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::vector<T>& f(), std::vector<T>* f():
+//      the vector is returned by reference; therefore, a wrapped std::vector
+//      is returned
+//   -- const std::vector<T>* f(), f(const std::vector<T>*):
+//      for consistency, they expect and return a plain vector pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <vector>
+%}    
+
+// exported classes
+
+
+namespace std {
+
+  template<class _Tp, class _Alloc = allocator< _Tp > >
+  class vector {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Tp value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef _Tp& reference;
+    typedef const _Tp& const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(_Tp);
+    %traits_enum(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::vector<_Tp, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdVectorTraits") {
+      namespace swig {
+	template <>  struct traits<std::vector<_Tp, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::vector<" #_Tp "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp, _Alloc >);
+
+#ifdef %swig_vector_methods
+    // Add swig/language extra methods
+    %swig_vector_methods(std::vector<_Tp, _Alloc >);
+#endif
+  
+    %std_vector_methods(vector);
+  };
+
+  // ***
+  // This specialization should disappear or get simplified when
+  // a 'const SWIGTYPE*&' can be defined
+  // ***
+  template<class _Tp, class _Alloc >
+  class vector<_Tp*, _Alloc > {
+  public:
+    typedef size_t size_type;    
+    typedef ptrdiff_t difference_type;
+    typedef _Tp* value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::vector<_Tp*, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdVectorTraits") {
+      namespace swig {
+	template <>  struct traits<std::vector<_Tp*, _Alloc > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" #_Tp " *," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp*, _Alloc >);
+
+#ifdef %swig_vector_methods_val
+    // Add swig/language extra methods
+    %swig_vector_methods_val(std::vector<_Tp*, _Alloc >);
+#endif
+
+    %std_vector_methods_val(vector);
+  };
+
+  // ***
+  // const pointer specialization
+  // ***
+  template<class _Tp, class _Alloc >
+  class vector<_Tp const *, _Alloc > {
+  public:
+    typedef size_t size_type;    
+    typedef ptrdiff_t difference_type;
+    typedef _Tp const * value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::vector<_Tp const*, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdVectorTraits") {
+      namespace swig {
+	template <>  struct traits<std::vector<_Tp const*, _Alloc > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" #_Tp " const*," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp const*, _Alloc >);
+
+#ifdef %swig_vector_methods_val
+    // Add swig/language extra methods
+    %swig_vector_methods_val(std::vector<_Tp const*, _Alloc >);
+#endif
+
+    %std_vector_methods_val(vector);
+  };
+
+  // ***
+  // bool specialization
+  // ***
+
+  template<class _Alloc > 
+  class vector<bool,_Alloc > {
+  public:
+    typedef size_t size_type;    
+    typedef ptrdiff_t difference_type;
+    typedef bool value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(bool);
+
+    %fragment(SWIG_Traits_frag(std::vector<bool, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(bool),
+	      fragment="StdVectorTraits") {
+      namespace swig {
+	template <>  struct traits<std::vector<bool, _Alloc > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<bool, _Alloc >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<bool, _Alloc >);
+
+
+#ifdef %swig_vector_methods_val
+    // Add swig/language extra methods
+    %swig_vector_methods_val(std::vector<bool, _Alloc >);
+#endif
+
+    %std_vector_methods_val(vector);
+
+#if defined(SWIG_STD_MODERN_STL) && !defined(SWIG_STD_NOMODERN_STL) 
+    void flip();
+#endif
+
+  };
+
+}

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

@@ -0,0 +1,153 @@
+#!/usr/bin/env Rscript
+### Example R script for syntax highlighting
+
+# This is also a comment
+
+## Valid names
+abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUV0123456789._a <- NULL
+.foo_ <- NULL
+._foo <- NULL
+
+## Invalid names
+0abc <- NULL
+.0abc <- NULL
+abc+cde <- NULL
+
+## Reserved Words
+NA
+NA_integer_
+NA_real_
+NA_character_
+NA_complex_
+NULL
+NaN
+Inf
+## Not reserved
+NULLa <- NULL
+NULL1 <- NULL
+NULL. <- NULL
+NA_foo_ <- NULL
+
+## Numbers
+12345678901
+123456.78901
+123e3
+123E3
+1.23e-3
+1.23e3
+1.23e-3
+## integer constants
+123L
+1.23L
+## imaginary numbers
+123i
+-123i
+123e4i
+123e-4i
+## Hex numbers
+0xabcdefABCDEF01234
+0xabcp123
+0xabcP123
+## Not hex
+0xg
+
+## Special operators %xyz%
+## %xyz%
+1 %% 2
+diag(2) %*% diag(2)
+1 %/% 2
+1 %in% 1:10
+diag(2) %o% diag(2)
+diag(2) %x% diag(2)
+`%foo bar%` <- function(x, y) x + y
+1 %foo bar% 2
+
+## Control Structures (3.2) and Function
+## if, else
+if (TRUE) print("foo") else print("bar")
+## For, in
+for(i in 1:5) {
+    print(i)
+}
+## While, break
+i <- 1
+while (TRUE) {
+    i <- i + 1
+    if (i > 3) break
+}
+## Repeat
+repeat {1+1}
+## Switch
+x <- 3
+switch(x, 2+2, mean(1:10), rnorm(5))
+## Function, dot-dot-dot, return
+foo <- function(...) {
+    return(sum(...))
+}
+# Not keywords
+functiona <- 2 + 2
+function. <- 2 + 2
+function1 <- 2 + 2
+
+
+## Grouping Tokens 10.3.7
+## Parentheses
+1 + (2 + 3)
+## brackets
+foo <- function(a) {
+    a + 1
+}
+
+## Indexing 10.3.8
+## []
+bar <- 1:10
+bar[3]
+## [[]]
+foo <- list(a=1, b=2, c=3)
+foo[["a"]]
+## $
+foo$a
+foo$"a"
+
+## Operators
+2 - 2
+2 + 2
+2 ~ 2
+! TRUE
+?"help"
+1:2
+2 * 2
+2 / 2
+2^2
+2 < 2
+2 > 2
+2 == 2
+2 >= 2
+2 <= 2
+2 != 2
+TRUE & FALSE
+TRUE && FALSE
+TRUE | FALSE
+TRUE || FALSE
+foo <- 2 + 2
+foo = 2 + 2
+2 + 2 -> foo
+foo <<- 2 + 2
+2 + 2 ->> foo
+base:::sum
+base::sum
+
+## Strings
+foo <- "hello, world!"
+foo <- 'hello, world!'
+foo <- "Hello, 'world!"
+foo <- 'Hello, "world!'
+foo <- 'Hello, \'world!\''
+foo <- "Hello, \"world!\""
+foo <- "Hello,
+world!"
+foo <- 'Hello,
+world!'
+
+## Backtick strings
+`foo123 +!"bar'baz` <- 2 + 2

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

@@ -0,0 +1,211 @@
+--  Model IED Simulator
+--  COL Gene Ressler, 1 December 2007
+with Ada.Text_IO;
+
+with Ada.Characters.Latin_1;
+use  Ada.Characters.Latin_1;
+
+with Ada.Strings.Fixed;
+use  Ada.Strings.Fixed;
+
+with Ada.Strings;
+with Ada.Strings.Bounded;
+
+with Binary_Search;
+
+with Ada.Containers.Generic_Array_Sort;
+
+package body Scanner is
+   
+   Constant_123   : constant Character := Character'Val (16#00#);
+   MAX_KEYWORD_LENGTH_C : constant Natural := 24;
+   
+   New_Constant : constant New_Type
+     := 2;
+   
+   KEYWORDS_C : constant Keyword_Array_T :=
+     (To_BS("description"),
+      To_BS("with"));
+   
+   procedure Blah;
+   
+   procedure blah is
+   begin
+      
+      Declaration:
+      declare
+         Joe : Type_Type := Random;
+      begin
+         Do_Something;
+      end Declaration;
+      Loop_ID:
+         loop
+            Loop_Do;
+            exit when 1=2;
+         end loop Loop_ID;
+      if True or else False then
+         Do_This();
+      elsif not False and then True then
+         Do_That;
+      else
+         Panic;
+      end if;
+   end blah;
+   
+   function "*" (Left, Right : in Integer) return Integer is
+   begin
+      <<Goto_Label>>
+      goto Goto_Label;
+      return Left + Right;
+   end "*";
+   
+   function Function_Specification
+     (Param_1        : in Blah; 
+      Param2, param3 : in access Blah_Type := 0)
+     return It_Type;
+   
+   package Rename_Check renames Ada.Text_IO;
+
+   type New_Float is delta 0.001 digits 12;
+   
+   package Package_Inst is new Ada.Strings.Bounded.Generic_Bounded_Length
+     (Max => MAX_KEYWORD_LENGTH_C);
+
+   type Array_Decl12 is array (Positive range <>) of SB.Bounded_String;
+   type Array_Decl3 is array (New_Type range Thing_1 .. Thing_2) of SB.Bounded_String;
+
+   type Boring_Type is
+     (Start,
+      End_Error);
+
+   subtype Sub_Type_check is Character range '0' .. '9';
+   
+   Initialized_Array : constant Transistion_Array_T :=
+     (Start =>
+        (Letter_Lower | Letter_Upper => Saw_Alpha,
+         ' ' | HT | CR | LF          => Start,
+         others => Begin_Error),
+
+      End_Error => (others => Start)
+
+     );
+
+   type Recorder is record
+      Advance      : Boolean;
+      Return_Token : Token_T;
+   end record;
+   
+   for Recorder use 8;
+   
+   type Null_Record is null record;
+   
+   type Discriminated_Record (Size : Natural) is 
+      record
+         A : String (1 .. Size);
+      end record;
+   
+   pragma Unchecked_Union (Union);
+   pragma Convention (C, Union);
+   
+   type Person is tagged 
+      record
+         Name   : String (1 .. 10);
+         Gender : Gender_Type;
+      end record;
+   
+   type Programmer is new Person with
+      record
+         Skilled_In : Language_List;
+         Favorite_Langauge : Python_Type;
+      end record;
+   
+   type Programmer is new Person 
+     and Printable 
+     with 
+      record
+         Skilled_In : Language_List;
+         Blah : aliased Integer;
+      end record;
+   
+   ---------------------
+   -- Scan_Next_Token --
+   ---------------------
+   
+   task Cyclic_Buffer_Task_Type is
+      entry Insert (An_Item : in  Item);
+      entry Remove (An_Item : out Item);
+   end Cyclic_Buffer_Task_Type;
+   
+   task body Cyclic_Buffer_Task_Type is
+      Q_Size : constant := 100;
+      subtype Q_Range is Positive range 1 .. Q_Size;
+      Length : Natural range 0 .. Q_Size := 0;
+      Head, Tail : Q_Range := 1;
+      Data : array (Q_Range) of Item;
+   begin
+      loop
+         select
+            when Length < Q_Size =>
+               accept Insert (An_Item : in  Item) do
+                  Data(Tail) := An_Item;
+               end Insert;
+               Tail := Tail mod Q_Size + 1;
+               Length := Length + 1;
+         or
+            when Length > 0 =>
+               accept Remove (An_Item : out Item) do
+                  An_Item := Data(Head);
+               end Remove;
+               Head := Head mod Q_Size + 1;
+               Length := Length - 1;
+         end select;
+      end loop;
+   end Cyclic_Buffer_Task_Type;
+     
+     
+   
+   procedure Scan_Next_Token
+     (S           : in     String;
+      Start_Index :    out Positive;
+      End_Index   : in out Natural;     --  Tricky comment
+      Line_Number : in out Positive;
+      Token       :    out Token_T);
+   
+   procedure Scan_Next_Token
+     (S           : in     String;
+      Start_Index :    out Positive;
+      End_Index   : in out Natural;     --  Another comment
+      Line_Number : in out Positive;
+      Token       :    out Token_T)
+   is
+   begin
+      Scanner_Loop:
+      loop
+         if New_State = End_Error then
+            exit Scanner_Loop;
+         end if;
+
+         if State = Start and New_State /= Start then
+            Start_Index := Peek_Index;
+         end if;
+      end loop Scanner_Loop;
+   end Scan_Next_Token;
+   
+   procedure Advance is
+   begin
+      Peek_Index := Peek_Index + 1;
+   end Advance;
+      
+
+   -- Eliminate the leading space that Ada puts in front of positive
+   -- integer images.
+   function Image(N : in Integer) return String is
+      S : String := Integer'Image(N);
+   begin
+      if S(1) = ' ' then
+         return S(2 .. S'Last);
+      end if;
+      return S;
+   end Image;
+
+end Scanner;