pygments.rb-jruby 0.5.4

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

@@ -0,0 +1,24 @@
+<!-- This page was loaded on <%= (new java.util.Date()).toLocaleString() %> -->
+<%= var x = 1;
+%>
+<%! int i = 0; %>
+<%! int a, b, c; %>
+<%! Circle a = new Circle(2.0); %>
+
+<%
+      String name = null;
+      if (request.getParameter("name") == null) {
+%>
+<%@ include file="error.html" %>
+<%
+      } else {
+      foo.setName(request.getParameter("name"));
+      if (foo.getName().equalsIgnoreCase("integra"))
+      name = "acura";
+      if (name.equalsIgnoreCase( "acura" )) {
+%>
+
+<jsp:useBean id="calendar" scope="page" class="employee.Calendar" />
+<h2>
+Calendar of <jsp:getProperty name="calendar" property="username" />
+</h2>

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

@@ -0,0 +1,45 @@
+# MAQL script
+CREATE DATASET {dataset.quotes} VISUAL(TITLE "St\\tock Qu\totes Data");
+
+# A comment
+CREATE DATASET {dataset.quotes} VISUAL(TITLE "Stock Qu\"otes Data");
+
+CREATE DATASET {dataset.quotes} VISUAL(TITLE "Stock Quotes Data");
+
+ALTER DATASET {dataset.quotes} ADD {attribute.sector};
+
+ALTER DATASET {dataset.quotes} DROP {attribute.symbol};
+
+ALTER DATASET {dataset.quotes} VISUAL(TITLE "Internal Quotes Data");
+
+CREATE ATTRIBUTE {attr.quotes.symbol}
+    VISUAL(TITLE "Symbol", FOLDER {folder.quotes.attr})
+    AS {d_quotes_symbol.nm_symbol};
+
+ALTER ATTRIBUTE {attr.quotes.symbol}
+    ADD LABELS {attr.quotes.company} VISUAL(TITLE "Company")
+    AS {d_quotes_symbol.nm_company};
+
+CREATE FACT {fact.quotes.open_price}
+    VISUAL( TITLE "Open Price", FOLDER {folder.quotes.fact}) AS {f_quotes.f_open_price};
+
+ALTER FACT {fact.quotes.open_price} ADD {f_quotes2.f_open_price};
+
+CREATE FOLDER {folder.quotes.attr}
+    VISUAL ( TITLE "Stock Quotes Data",
+             DESCRIPTION "Stock quotes data obtained from John Doe etc." )
+    TYPE ATTRIBUTE;
+
+ALTER DATATYPE {d_quotes_symbol.nm_symbol} VARCHAR(4),
+    {d_quotes_symbol.nm_symbol} VARCHAR(80),
+    {f_quotes.f_open_price} DECIMAL(10,2);
+
+INCLUDE TEMPLATE "URN:GOODDATA:DATE" MODIFY (IDENTIFIER "my-date", TITLE "quote")
+
+ALTER ATTRIBUTE {attr.quotes.symbol} ADD KEYS {d_quotes_symbol.nm_symbol} PRIMARY;
+
+ALTER ATTRIBUTE {attr.quotes.symbol} DROP KEYS {d_quotes_symbol.nm_symbol};
+
+ALTER FACT {fact.quotes.open_price} ADD {f_quotes2.f_open_price};
+
+# Another comment

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

@@ -0,0 +1,374 @@
+(* LIFO Storage Library
+ *
+ *  @file LIFO.mod
+ *  LIFO implementation
+ *
+ *  Universal Dynamic Stack
+ *
+ *  Author: Benjamin Kowarsch
+ *
+ *  Copyright (C) 2009 Benjamin Kowarsch. All rights reserved.
+ *
+ *  License:
+ *
+ *  Redistribution  and  use  in source  and  binary forms,  with  or  without
+ *  modification, are permitted provided that the following conditions are met
+ *
+ *  1) NO FEES may be charged for the provision of the software.  The software
+ *     may  NOT  be published  on websites  that contain  advertising,  unless
+ *     specific  prior  written  permission has been obtained.
+ *
+ *  2) Redistributions  of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *  3) Redistributions  in binary form  must  reproduce  the  above  copyright
+ *     notice,  this list of conditions  and  the following disclaimer  in the
+ *     documentation and other materials provided with the distribution.
+ *
+ *  4) Neither the author's name nor the names of any contributors may be used
+ *     to endorse  or  promote  products  derived  from this software  without
+ *     specific prior written permission.
+ *
+ *  5) Where this list of conditions  or  the following disclaimer, in part or
+ *     as a whole is overruled  or  nullified by applicable law, no permission
+ *     is granted to use the software.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY  AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR
+ * CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT  LIMITED  TO,  PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR PROFITS; OR BUSINESS
+ * INTERRUPTION)  HOWEVER  CAUSED  AND ON ANY THEORY OF LIABILITY,  WHETHER IN
+ * CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *  
+ *)
+
+
+IMPLEMENTATION (* OF *) MODULE LIFO;
+
+FROM SYSTEM IMPORT ADDRESS, ADR, TSIZE;
+FROM Storage IMPORT ALLOCATE, DEALLOCATE;
+
+
+(* ---------------------------------------------------------------------------
+// Private type : ListEntry
+// ---------------------------------------------------------------------------
+*)
+TYPE ListPtr = POINTER TO ListEntry;
+
+TYPE ListEntry = RECORD
+    value : DataPtr;
+    next  : ListPtr
+END; (* ListEntry *)
+
+
+(* ---------------------------------------------------------------------------
+// Opaque type : LIFO.Stack
+// ---------------------------------------------------------------------------
+// CAUTION:  Modula-2 does not support the use of variable length array fields
+// in records.  VLAs can  only  be implemented  using pointer arithmetic which
+// means  there is  no type checking  and  no boundary checking  on the array.
+// It also means that  array notation cannot be used on the array  which makes
+// the code  difficult to read  and maintain.  As a result,  Modula-2  is less
+// safe and less readable than C when it comes to using VLAs.  Great care must
+// be taken to make sure that the code accessing VLA fields is safe.  Boundary
+// checks must be inserted manually.  Size checks must be inserted manually to
+// compensate for the absence of type checks. *)
+
+TYPE Stack = POINTER TO StackDescriptor;
+
+TYPE StackDescriptor = RECORD
+    overflow   : ListPtr;
+    entryCount : StackSize;
+    arraySize  : StackSize;
+    array      : ADDRESS (* ARRAY OF DataPtr *)
+END; (* StackDescriptor *)
+
+
+(* ---------------------------------------------------------------------------
+// function:  LIFO.new( initial_size, status )
+// ---------------------------------------------------------------------------
+//
+// Creates  and  returns  a new LIFO stack object  with an initial capacity of
+// <initialSize>.  If  zero  is passed in  for <initialSize>,  then  the stack
+// will be created  with an  initial capacity  of  LIFO.defaultStackSize.  The
+// function fails  if a value greater than   LIFO.maximumStackSize  is  passed
+// in  for <initialSize> or if memory could not be allocated.
+//
+// The initial capacity of a stack is the number of entries that can be stored
+// in the stack without enlargement.
+//
+// The status of the operation  is passed back in <status>. *)
+
+PROCEDURE new ( initialSize : StackSize; VAR status : Status ) : Stack;
+
+VAR
+    newStack : Stack;
+    
+BEGIN
+
+    (* zero size means default *)
+    IF initialSize = 0 THEN
+        initialSize := defaultStackSize;
+    END; (* IF *)
+    
+    (* bail out if initial size is too high *)
+    IF initialSize > maximumStackSize THEN
+        status := invalidSize;
+        RETURN NIL;
+    END; (* IF *)
+    
+    (* allocate new stack object *)
+    ALLOCATE(newStack, TSIZE(Stack) + TSIZE(DataPtr) * (initialSize - 1));
+    
+    (* bail out if allocation failed *)
+    IF newStack = NIL THEN
+        status := allocationFailed;
+        RETURN NIL;
+    END; (* IF *)
+        
+    (* initialise meta data *)
+    newStack^.arraySize := initialSize;
+    newStack^.entryCount := 0;
+    newStack^.overflow := NIL;
+    
+    (* pass status and new stack to caller *)
+    status := success;
+    RETURN newStack
+    
+END new;
+
+
+(* ---------------------------------------------------------------------------
+// function:  LIFO.push( stack, value, status )
+// ---------------------------------------------------------------------------
+//
+// Adds a  new entry <value>  to the top of stack <stack>.  The  new entry  is
+// added by reference,  no data is copied.  However,  no entry is added if the
+// the stack is full,  that is  when the number of entries stored in the stack
+// has reached LIFO.maximumStackSize.  The function fails  if NIL is passed in
+// for <stack> or <value>,  or if memory could not be allocated.
+//
+// New entries are allocated dynamically  if the number of entries exceeds the
+// initial capacity of the stack.
+//
+// The status of the operation is passed back in <status>. *)
+
+PROCEDURE push ( VAR stack : Stack; value : DataPtr; VAR status : Status );
+VAR
+    newEntry : ListPtr;
+    valuePtr : POINTER TO DataPtr;
+
+BEGIN
+
+    (* bail out if stack is NIL *)
+    IF stack = NIL THEN
+        status := invalidStack;
+        RETURN;
+    END; (* IF *)
+    
+    (* bail out if value is NIL *)
+    IF value = NIL THEN
+        status := invalidData;
+        RETURN;
+    END; (* IF *)
+
+    (* bail out if stack is full *)
+    IF stack^.entryCount >= maximumStackSize THEN
+        status := stackFull;
+        RETURN;
+    END; (* IF *)
+
+    (* check if index falls within array segment *)
+    IF stack^.entryCount < stack^.arraySize THEN
+    
+        (* store value in array segment *)
+        
+        (* stack^.array^[stack^.entryCount] := value; *)
+        valuePtr := ADR(stack^.array) + TSIZE(DataPtr) * stack^.entryCount;
+        valuePtr^ := value;
+        
+    ELSE (* index falls within overflow segment *)
+    
+        (* allocate new entry slot *)
+        NEW(newEntry);
+        
+        (* bail out if allocation failed *)
+        IF newEntry = NIL THEN
+            status := allocationFailed;
+            RETURN;
+        END; (* IF *)
+        
+        (* initialise new entry *)
+        newEntry^.value := value;
+        
+        (* link new entry into overflow list *)
+        newEntry^.next := stack^.overflow;
+        stack^.overflow := newEntry;
+    
+    END; (* IF *)
+    
+    (* update entry counter *)
+    INC(stack^.entryCount);
+    
+    (* pass status to caller *)
+    status := success;
+    RETURN
+
+END push;
+
+
+(* ---------------------------------------------------------------------------
+// function:  LIFO.pop( stack, status )
+// ---------------------------------------------------------------------------
+//
+// Removes the top most value from stack <stack> and returns it.  If the stack
+// is empty,  that  is  when the  number  of  entries  stored in the stack has
+// reached zero,  then NIL is returned.
+//
+// Entries which were allocated dynamically (above the initial capacity) are
+// deallocated when their values are popped.
+//
+// The status of the operation is passed back in <status>. *)
+
+PROCEDURE pop ( VAR stack : Stack; VAR status : Status ) : DataPtr;
+
+VAR
+    thisValue : DataPtr;
+    thisEntry : ListPtr;
+    valuePtr : POINTER TO DataPtr;
+
+BEGIN
+
+    (* bail out if stack is NIL *)
+    IF stack = NIL THEN
+        status := invalidStack;
+        RETURN NIL;
+    END; (* IF *)
+    
+    (* bail out if stack is empty *)
+    IF stack^.entryCount = 0 THEN
+        status := stackEmpty;
+        RETURN NIL;
+    END; (* IF *)
+
+    DEC(stack^.entryCount);
+    
+    (* check if index falls within array segment *)
+    IF stack^.entryCount < stack^.arraySize THEN
+        
+        (* obtain value at index entryCount in array segment *)
+        
+        (* thisValue := stack^.array^[stack^.entryCount]; *)
+        valuePtr := ADR(stack^.array) + TSIZE(DataPtr) * stack^.entryCount;
+        thisValue := valuePtr^;
+        
+    ELSE (* index falls within overflow segment *)
+        
+        (* obtain value of first entry in overflow list *)
+        thisValue := stack^.overflow^.value;
+        
+        (* isolate first entry in overflow list *)
+        thisEntry := stack^.overflow;
+        stack^.overflow := stack^.overflow^.next;
+        
+        (* remove the entry from overflow list *)
+        DISPOSE(thisEntry);
+                
+    END; (* IF *)
+
+    (* return value and status to caller *)
+    status := success;
+    RETURN thisValue
+
+END pop;
+
+
+(* ---------------------------------------------------------------------------
+// function:  LIFO.stackSize( stack )
+// ---------------------------------------------------------------------------
+//
+// Returns the current capacity of <stack>.  The current capacity is the total
+// number of allocated entries. Returns zero if NIL is passed in for <stack>.
+*)
+PROCEDURE stackSize( VAR stack : Stack ) : StackSize;
+
+BEGIN
+
+    (* bail out if stack is NIL *)
+    IF stack = NIL THEN
+        RETURN 0;
+    END; (* IF *)
+
+    IF stack^.entryCount < stack^.arraySize THEN
+        RETURN stack^.arraySize;
+    ELSE
+        RETURN stack^.entryCount;
+    END; (* IF *)
+    
+END stackSize;
+
+
+(* ---------------------------------------------------------------------------
+// function:  LIFO.stackEntries( stack )
+// ---------------------------------------------------------------------------
+//
+// Returns  the  number of entries  stored in stack <stack>,  returns  zero if
+// NIL is passed in for <stack>. *)
+
+PROCEDURE stackEntries( VAR stack : Stack ) : StackSize;
+
+BEGIN
+
+    (* bail out if stack is NIL *)
+    IF stack = NIL THEN
+        RETURN 0;
+    END; (* IF *)
+
+    RETURN stack^.entryCount
+    
+END stackEntries;
+
+
+(* ---------------------------------------------------------------------------
+// function:  LIFO.dispose( stack )
+// ---------------------------------------------------------------------------
+//
+// Disposes of LIFO stack object <stack>.  Returns NIL. *)
+
+PROCEDURE dispose ( VAR stack : Stack ) : Stack;
+
+VAR
+    thisEntry : ListPtr;
+
+BEGIN
+
+    (* bail out if stack is NIL *)
+    IF stack = NIL THEN
+        RETURN NIL;
+    END; (* IF *)
+    
+    (* deallocate any entries in stack's overflow list *)
+    WHILE stack^.overflow # NIL DO
+        
+        (* isolate first entry in overflow list *)
+        thisEntry := stack^.overflow;
+        stack^.overflow := stack^.overflow^.next;
+        
+        (* deallocate the entry *)
+        DISPOSE(thisEntry);
+        
+    END; (* WHILE *)
+    
+    (* deallocate stack object and pass NIL to caller *)
+    DEALLOCATE(stack, TSIZE(Stack) + TSIZE(DataPtr) * (stack^.arraySize - 1));
+    RETURN NIL
+
+END dispose;
+
+
+END LIFO.

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

@@ -0,0 +1,51 @@
+you_lose_msg = "Either that person does not exist, or has a different password.";
+if (!(caller in {#0, this}))
+  return E_PERM;
+  "...caller isn't :do_login_command...";
+elseif (args && (args[1] == "test"))
+  return this:test(@listdelete(args, 1));
+elseif (!(length(args) in {1, 2}))
+  notify(player, tostr("Usage:  ", verb, " <existing-player-name> <password>"));
+elseif (!valid(candidate = this:_match_player(name = strsub(args[1], " ", "_"))))
+  if (name == "guest")
+    "must be no guests";
+    this:notify_lines(this:registration_text("guest"));
+  else
+    notify(player, you_lose_msg);
+  endif
+  "...unknown player...";
+elseif (is_clear_property(candidate, "password") || ((typeof(candidate.password) == STR) && ((length(candidate.password) < 2) || (crypt({@args, ""}[2], candidate.password) != candidate.password))))
+  notify(player, you_lose_msg);
+  "...bad password...";
+  server_log(tostr("FAILED CONNECT: ", args[1], " (", candidate, ") on ", connection_name(player), ($string_utils:connection_hostname(connection_name(player)) in candidate.all_connect_places) ? "" | "******"));
+elseif (((candidate.name == "guest") && this.sitematch_guests) && valid(foreigner = $country_db:get_guest()))
+  notify(player, tostr("Okay,...  Logging you in as `", foreigner:name(), "'"));
+  this:record_connection(foreigner);
+  return foreigner;
+elseif ((parent(candidate) == $guest) && (!valid(candidate = candidate:defer())))
+  if (candidate == #-3)
+    notify(player, "Sorry, guest characters are not allowed from your site right now.");
+  elseif (candidate == #-2)
+    this:notify_lines(this:registration_text("blacklisted", "Sorry, guest characters are not allowed from your site."));
+  elseif (candidate == #-4)
+    this:notify_lines(this:registration_text("guest"));
+  else
+    notify(player, "Sorry, all of our guest characters are in use right now.");
+  endif
+else
+  if ((!(name in candidate.aliases)) && (name != tostr(candidate)))
+    notify(player, tostr("Okay,... ", name, " is in use.  Logging you in as `", candidate:name(), "'"));
+  endif
+  if (this:is_newted(candidate))
+    notify(player, "");
+    notify(player, this:newt_message_for(candidate));
+    notify(player, "");
+  else
+    this:record_connection(candidate);
+    if (verb[1] == "s")
+      candidate.use_do_command = 0;
+    endif
+    return candidate;
+  endif
+endif
+return 0;