gitlab-pygments.rb 0.3.2

data/vendor/pygments-main/tests/examplefiles/string_delimiters.d

@@ -0,0 +1,21 @@
+import std.stdio;
+
+void main() {
+    // Nesting delimited strings
+    auto a = q"{foo " {bar} baz}";
+    auto b = q"[foo [bar] " baz]";
+    auto c = q"(foo " (bar) baz)";
+    auto d = q"<foo <bar> " baz>";
+    // Non-nesting delimited strings
+    auto e = q"/foo " bar/";
+    auto f = q"-Another " string-";
+    // "heredoc" strings
+    auto g = q"FOO
+        This is a string!
+FOO";
+    // Token strings (only the q{} should be highlighted as a string)
+    auto h = q{
+        int i;
+        void foo() { writefln("Hello, world!"); }
+    };
+}

data/vendor/pygments-main/tests/examplefiles/stripheredoc.sh

@@ -0,0 +1,3 @@
+cat <<-EOF
+  Hello world $PATH
+  EOF

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

@@ -0,0 +1,119 @@
+###################################
+#######  emplikH1.test() ##########
+###################################
+
+emplikH1.test <- function(x, d, theta, fun,
+	              tola = .Machine$double.eps^.25)
+{
+n <- length(x)
+if( n <= 2 ) stop("Need more observations")
+if( length(d) != n ) stop("length of x and d must agree")
+if(any((d!=0)&(d!=1))) stop("d must be 0/1's for censor/not-censor")
+if(!is.numeric(x)) stop("x must be numeric values --- observed times")
+
+#temp<-summary(survfit(Surv(x,d),se.fit=F,type="fleming",conf.type="none"))
+#
+newdata <- Wdataclean2(x,d)
+temp <- DnR(newdata$value, newdata$dd, newdata$weight)
+
+time <- temp$time         # only uncensored time?  Yes.
+risk <- temp$n.risk
+jump <- (temp$n.event)/risk
+
+funtime <- fun(time)
+funh <- (n/risk) * funtime    # that is Zi
+funtimeTjump <- funtime * jump
+
+if(jump[length(jump)] >= 1) funh[length(jump)] <- 0  #for inthaz and weights
+
+inthaz <- function(x, ftj, fh, thet){ sum(ftj/(1 + x * fh)) - thet }
+
+diff <- inthaz(0, funtimeTjump, funh, theta)
+
+if( diff == 0 ) { lam <- 0 } else {
+    step <- 0.2/sqrt(n)
+    if(abs(diff) > 6*log(n)*step )
+    stop("given theta value is too far away from theta0")
+
+    mini<-0
+    maxi<-0
+    if(diff > 0) {
+    maxi <- step
+    while(inthaz(maxi, funtimeTjump, funh, theta) > 0 && maxi < 50*log(n)*step)
+    maxi <- maxi+step
+    }
+    else {
+    mini <- -step
+    while(inthaz(mini, funtimeTjump, funh, theta) < 0 && mini > - 50*log(n)*step)
+    mini <- mini - step
+    }
+
+    if(inthaz(mini, funtimeTjump, funh, theta)*inthaz(maxi, funtimeTjump, funh, theta) > 0 )
+    stop("given theta is too far away from theta0")
+
+    temp2 <- uniroot(inthaz,c(mini,maxi), tol = tola,
+                  ftj=funtimeTjump, fh=funh, thet=theta)
+    lam <- temp2$root
+}
+
+onepluslamh<- 1 + lam * funh   ### this is 1 + lam Zi in Ref.
+
+weights <- jump/onepluslamh  #need to change last jump to 1? NO. see above
+
+loglik <- 2*(sum(log(onepluslamh)) - sum((onepluslamh-1)/onepluslamh) )
+#?is that right? YES  see (3.2) in Ref. above. This ALR, or Poisson LR.
+
+#last <- length(jump)    ## to compute loglik2, we need to drop last jump
+#if (jump[last] == 1) {
+#                     risk1 <- risk[-last]
+#                     jump1 <- jump[-last]
+#                     weights1 <- weights[-last]
+#                     } else {
+#                            risk1 <- risk
+#                            jump1 <- jump
+#                            weights1 <- weights
+#                            }
+#loglik2 <- 2*( sum(log(onepluslamh)) +
+#          sum( (risk1 -1)*log((1-jump1)/(1- weights1) ) )  )
+##? this likelihood seems have negative values sometimes???
+
+list( logemlik=loglik,  ### logemlikv2=loglik2,
+      lambda=lam, times=time, wts=weights,
+      nits=temp2$nf, message=temp2$message )
+}
+
+library("graphics")
+
+par(mfrow = c(1, 2))
+# plot histogram
+x <- rnorm(100)
+if (max(x) > 100)
+  stop("Quite unexpected.")
+else
+  hist(x, plot=TRUE, col="ivory")
+
+# from doc: lowess
+plot(cars, main = "lowess(cars)")
+     lines(lowess(cars), col = 2)
+     lines(lowess(cars, f=.2), col = 3)
+     legend(5, 120, c(paste("f = ", c("2/3", ".2"))), lty = 1, col = 2:3)
+
+# from doc: is.na
+is.na(c(1, NA))
+
+# from doc: Extract
+y <- list(1,2,a=4,5)
+y[c(3,4)]             # a list containing elements 3 and 4 of y
+y$a                   # the element of y named a
+
+# from doc: for
+for(n in c(2,5,10,20,50)) {
+  x <- stats::rnorm(n)
+  cat(n,":", sum(x2),"\n")
+}
+
+class(fo <- y ~ x1*x2) # "formula"
+
+
+
+

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;

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

@@ -0,0 +1,131 @@
+// example file for roundedpath() in roundedpath.asy
+// written by stefan knorr
+
+
+// import needed packages
+import roundedpath;
+
+// function definition
+picture CreateKOOS(real Scale, string legend)               // draw labeled coordinate system as picture
+{
+  picture ReturnPic;
+  real S = 1.2*Scale;
+  draw(ReturnPic, ((-S,0)--(S,0)), bar = EndArrow);         // x axis
+  draw(ReturnPic, ((0,-S)--(0,S)), bar = EndArrow);         // y axis
+  label(ReturnPic, "$\varepsilon$", (S,0), SW);             // x axis label
+  label(ReturnPic, "$\sigma$", (0,S), SW);                  // y axis label
+  label(ReturnPic, legend, (0.7S, -S), NW);                 // add label 'legend' 
+  return ReturnPic;                                         // return picture
+}
+
+
+// some global definitions
+real S = 13mm;                          // universal scale factor for the whole file
+real grad = 0.25;                       // gradient for lines
+real radius = 0.04;                     // radius for the rounded path'
+real lw = 2;                            // linewidth
+pair A = (-1, -1);                      // start point for graphs
+pair E = ( 1,  1);                      // end point for graphs
+path graph;                             // local graph
+pen ActPen;                             // actual pen for each drawing
+picture T[];                            // vector of all four diagrams
+real inc = 2.8;                         // increment-offset for combining pictures
+
+//////////////////////////////////////// 1st diagram
+T[1] = CreateKOOS(S, "$T_1$");                                        // initialise T[1] as empty diagram with label $T_1$                  
+graph = A;                                                            //  # pointwise definition of current path 'graph'                    
+graph = graph -- (A.x + grad*1.6, A.y + 1.6);                         //  #                                                                 
+graph = graph -- (E.x - grad*0.4, E.y - 0.4);                         //  #                                                                 
+graph = graph -- E;                                                   //  #
+
+graph = roundedpath(graph, radius, S);                                // round edges of 'graph' using roundedpath() in roundedpath.asy      
+ActPen =  rgb(0,0,0.6) + linewidth(lw);                               // define pen for drawing in 1st diagram                              
+draw(T[1],                   graph, ActPen);                          // draw 'graph' with 'ActPen' into 'T[1]' (1st hysteresis branch)     
+draw(T[1], rotate(180,(0,0))*graph, ActPen);                          // draw rotated 'graph' (2nd hysteresis branch)                       
+
+graph = (0,0) -- (grad*0.6, 0.6) -- ( (grad*0.6, 0.6) + (0.1, 0) );   // define branch from origin to hysteresis
+graph = roundedpath(graph, radius, S);                                // round this path                        
+draw(T[1], graph, ActPen);                                            // draw this path into 'T[1]'             
+
+
+//////////////////////////////////////// 2nd diagram
+T[2] = CreateKOOS(S, "$T_2$");                                        // initialise T[2] as empty diagram with label $T_2$              
+graph = A;                                                            //  # pointwise definition of current path 'graph'                
+graph = graph -- (A.x + grad*1.3, A.y + 1.3);                         //  #                                                             
+graph = graph -- (E.x - grad*0.7 , E.y - 0.7);                        //  #                                                             
+graph = graph -- E;                                                   //  #
+                                                                                                
+graph = roundedpath(graph, radius, S);                                // round edges of 'graph' using roundedpath() in roundedpath.asy      
+ActPen =  rgb(0.2,0,0.4) + linewidth(lw);                             // define pen for drawing in 2nd diagram                              
+draw(T[2],                   graph, ActPen);                          // draw 'graph' with 'ActPen' into 'T[2]' (1st hysteresis branch)     
+draw(T[2], rotate(180,(0,0))*graph, ActPen);                          // draw rotated 'graph' (2nd hysteresis branch)                       
+
+graph = (0,0) -- (grad*0.3, 0.3) -- ( (grad*0.3, 0.3) + (0.1, 0) );   // define branch from origin to hysteresis
+graph = roundedpath(graph, radius, S);                                // round this path                        
+draw(T[2], graph, ActPen);                                            // draw this path into 'T[2]'             
+
+
+//////////////////////////////////////// 3rd diagram
+T[3] = CreateKOOS(S, "$T_3$");                                        // initialise T[3] as empty diagram with label $T_3$              
+graph = A;                                                            //  # pointwise definition of current path 'graph'                
+graph = graph -- (A.x + grad*0.7, A.y + 0.7);                         //  #                                                             
+graph = graph -- ( - grad*0.3 , - 0.3);                               //  #                                                             
+graph = graph -- (0,0);                                               //  #                                                             
+graph = graph -- (grad*0.6, 0.6);                                     //  #                                                             
+graph = graph -- (E.x - grad*0.4, E.y - 0.4);                         //  #                                                             
+graph = graph -- E;                                                   //  #                                                             
+                                                                                                                                        
+graph = roundedpath(graph, radius, S);                                // round edges of 'graph' using roundedpath() in roundedpath.asy  
+ActPen =  rgb(0.6,0,0.2) + linewidth(lw);                             // define pen for drawing in 3rd diagram                          
+draw(T[3],                   graph, ActPen);                          // draw 'graph' with 'ActPen' into 'T[3]' (1st hysteresis branch) 
+draw(T[3], rotate(180,(0,0))*graph, ActPen);                          // draw rotated 'graph' (2nd hysteresis branch)                   
+
+
+//////////////////////////////////////// 4th diagram
+T[4] = CreateKOOS(S, "$T_4$");                                        // initialise T[4] as empty diagram with label $T_4$              
+graph = A;                                                            //  # pointwise definition of current path 'graph'                
+graph = graph -- (A.x + grad*0.4, A.y + 0.4);                         //  #                                                             
+graph = graph -- ( - grad*0.6 , - 0.6);                               //  #                                                             
+graph = graph -- (0,0);                                               //  #                                                             
+graph = graph -- (grad*0.9, 0.9);                                     //  #                                                             
+graph = graph -- (E.x - grad*0.1, E.y - 0.1);                         //  #                                                             
+graph = graph -- E;                                                   //  #                                                             
+                                                                                                                                        
+graph = roundedpath(graph, radius, S);                                // round edges of 'graph' using roundedpath() in roundedpath.asy  
+ActPen =  rgb(0.6,0,0) + linewidth(lw);                               // define pen for drawing in 4th diagram                          
+draw(T[4],                   graph, ActPen);                          // draw 'graph' with 'ActPen' into 'T[4]' (1st hysteresis branch) 
+draw(T[4], rotate(180,(0,0))*graph, ActPen);                          // draw rotated 'graph' (3nd hysteresis branch)                   
+
+
+// add some labels and black dots to the first two pictures
+pair SWW = (-0.8, -0.6);
+label(T[1], "$\sigma_f$", (0, 0.6S), NE);                             // sigma_f
+draw(T[1], (0, 0.6S), linewidth(3) + black);
+label(T[2], "$\sigma_f$", (0, 0.3S), NE);                             // sigma_f
+draw(T[2], (0, 0.3S), linewidth(3) + black);
+label(T[1], "$\varepsilon_p$", (0.7S, 0), SWW);                       // epsilon_p
+draw(T[1], (0.75S, 0), linewidth(3) + black);
+label(T[2], "$\varepsilon_p$", (0.7S, 0), SWW);                       // epsilon_p
+draw(T[2], (0.75S, 0), linewidth(3) + black);
+
+
+// add all pictures T[1...4] to the current one
+add(T[1],(0,0));
+add(T[2],(1*inc*S,0));
+add(T[3],(2*inc*S,0));
+add(T[4],(3*inc*S,0));
+
+
+// draw line of constant \sigma and all intersection points with the graphs in T[1...4]
+ActPen = linewidth(1) + dashed + gray(0.5);                           // pen definition
+draw((-S, 0.45*S)--((3*inc+1)*S, 0.45*S), ActPen);                    // draw backgoundline
+label("$\sigma_s$", (-S, 0.45S), W);                            // label 'sigma_s'
+
+path mark = scale(2)*unitcircle;                                  // define mark-symbol to be used for intersections
+ActPen = linewidth(1) + gray(0.5);                                    // define pen for intersection mark
+draw(shift(( 1 - grad*0.55 + 0*inc)*S, 0.45*S)*mark, ActPen);         //  # draw all intersections
+draw(shift((-1 + grad*1.45 + 0*inc)*S, 0.45*S)*mark, ActPen);         //  #
+draw(shift(( 1 - grad*0.55 + 1*inc)*S, 0.45*S)*mark, ActPen);         //  #
+draw(shift(( 1 - grad*0.55 + 2*inc)*S, 0.45*S)*mark, ActPen);         //  # 
+draw(shift((     grad*0.45 + 2*inc)*S, 0.45*S)*mark, ActPen);         //  # 
+draw(shift((     grad*0.45 + 3*inc)*S, 0.45*S)*mark, ActPen);         //  #