This Java class represents a constructor node in an abstract syntax tree (AST). It extends TigerNode and provides methods to access and manipulate its parameters, type parameters, and throws clause. The toString() method returns a string representation of the constructor node, including its formal parameters and type parameters.

This Java code defines a custom exception class ParseException that is used to handle parsing errors in a parser generated by JavaCC. It provides constructors for creating exceptions with different information, such as the current token and expected tokens, and a method to generate an error message based on this information. The exception can be thrown when a parsing error occurs during the execution of the parser.

This Java code creates a CommandLineReader class that extends FilterReader. It reads input from the standard input stream, replacing empty lines with ;\n, allowing for more pleasant interaction on the command line. The reader is tested in a simple main method that continuously prints the read characters.

This Java class represents a tag in a source file, used by an integrated development environment (IDE). It stores information about the tag, such as its name, line number, and icon, and provides methods to access this information. The class extends another class called SourceAsset and uses a Hashtable to store icons for different types of tags.

This C code implements a demuxer for the 8088flex TMV file format, which is used to store audio and video data in a compressed form. The code provides functions for probing, reading headers, packets, and seeking within the files, as well as registering the demuxer with FFmpeg. It also defines the structure of the TMVContext, which holds metadata about the audio and video streams.

This Java class provides a utility for calculating the MD5 sum of input streams, files, and strings. It uses the MessageDigest API to compute the MD5 hash and converts the result to a hexadecimal string using a custom toHex method. The class offers three methods to calculate the MD5 sum: one for an InputStream, one for a File, and one for a String.

This Java class, CharIndexedSegment, provides a way to search within Segment objects using regular expressions from the gnu.regexp package. It allows for searching in both forward and reverse directions, with methods to get the character at a specific index, check if an index is valid, reset the index, and move the index by a certain amount.

This Ada code defines a package for calendar-related functionality, specifically time zones and dates. It introduces several types: Absolute_Time and Relative_Time to represent time in seconds since a base date (October 1582), Julian_Day_Number to represent days since the Julian Day Number 1, and Internal_Time_Zone to store information about time zones. The package also provides an alias for the UTC time zone.

This Java code is a SVN blame tool, which displays the revision history of a file by showing the author and revision number for each line of code. It takes a LogData object as input, which contains information about the SVN repository, username, password, and paths to analyze. The output is displayed on the console.

This Java class, CurrentPositionPainter, extends another class called DebuggerPainter. It is used to paint a specific line in an edit pane, likely for debugging purposes. The painting includes drawing a magenta rectangle at the current position on the screen, with additional lines and points to represent the physical line’s location.

This Java code defines a custom option pane for a text editor, allowing users to configure various settings such as push away mode, layout, and animations. It uses a combination of JComboBox and JCheckBox components to provide a user-friendly interface for setting these options. The changes are saved when the “Save” button is clicked, updating the text editor’s properties accordingly.

This Java code defines a class CartesianSeries that extends JsObject. It represents a vertical or horizontal axis of a Cartesian chart in the YUI Charts widget library. The class provides methods to set and get values for the xField and yField, which are used to access data from a source.

This is an Ada implementation of a UML State Machine class. It defines a set of abstract operations and attributes for managing states, including entry and exit actions, state invariants, and relationships with other states and state machines. The class provides a framework for modeling complex state-based systems and allows for redefinition and extension of existing states.

This Java class, CTagsFileProvider, is a provider of identifier names from a tags file generated by ctags. It loads and processes the identifiers from the file, storing them in an internal list. The class provides methods to process the file, forget the loaded identifiers, and iterate over the identifiers, allowing for use in other parts of the application.

This Java code defines an enumeration called KeyboardCommand with five possible values: NONE, TAB_OUT_FORWARD, TAB_OUT_BACK, EDIT_PLUGIN, and CLOSE_PLUGIN_MANAGER. It appears to be part of a plugin manager for the jEdit text editor, allowing different keyboard commands to be executed.

This Java class, ActionContext, manages a collection of action sets for an editor and browser application. It provides methods to retrieve actions by name and get the action set that contains a specified action. The class is part of the jEdit project and has been maintained since version 4.2pre1.

This Java code defines a custom exception class InvalidHeaderException that extends the built-in IOException. It provides two constructors: one with no message and another with a specified error message, both of which call the superclass constructor to set the error message. This exception is intended to be used when there’s an issue with a TAR archive header.

This Java class, BufferSwitcher, is a part of an integrated development environment (IDE) for editing files. It creates a dropdown menu that displays a list of available buffers (files being edited). The user can select a buffer from this list and switch to it in the IDE. The class also updates the list of buffers when they change, ensuring the correct buffer is displayed.

This Java code defines a set of listener interfaces and event handlers for various GUI events, such as button clicks, key presses, and window changes. It also provides a method to update an image in a graphical application. The code uses a custom interpreter and call stack system to handle the event handling and method invocation.

This Java class, CurrentBufferSet, implements a file set for searching the current buffer in an editor. It provides methods to get the first, next, and all files in the set, as well as the total number of files and code associated with it. The class is designed to work within an editor’s search functionality, allowing users to search the contents of the currently open file.

This Java code defines an abstract class Selection that represents a portion of text in a buffer. It provides methods to get the start and end offsets, as well as line numbers, of the selection. The class also extends two concrete classes: Range for ordinary range selections and Rect for rectangular selections.

This Java code defines a TabItemWidget class, which represents a single tab item on a desktop panel. It displays a label and a close button, allowing users to rename or remove the associated desktop. When the close button is clicked, it prompts the user to confirm removal. If renamed, it updates the desktop’s name and saves changes.

This HTML code is a documentation page for a Java class, ITaskRegistrarAsync. It displays information about the class, including its methods, fields, and constructors. The page includes navigation links to related classes and a summary of the class’s contents. The output appears to be generated from public sources, such as Javadoc comments in the Java codebase.

This Java code defines a custom options panel for a text editor, specifically for mouse-related settings. It allows users to configure various mouse actions, such as dragging and dropping text, joining non-word characters, pasting from middle mouse button clicks, and modifying gutter click behavior. The settings are saved when the user closes the options panel.

This Java code defines a class PrismaticJoint that extends Joint. It provides functionality for a prismatic joint, which allows translation along an axis while preventing relative rotation. The class includes methods to get and set joint limits, motor speed, and force, as well as enable/disable the limit and motor features.

This Java interface defines a listener for events related to file selection and activation in a Virtual File System (VFS) browser. It provides two methods: filesSelected and filesActivated, which are called when files are selected and double-clicked, respectively, allowing the listener to respond to these events.

This Java class, CompletionRequest, is part of a CSS editor’s auto-completion feature. It analyzes user input and suggests possible completions based on CSS properties, units, and values. The class uses regular expressions to parse the input text and determine whether it matches certain patterns, allowing it to provide relevant suggestions for completion.

This Java code is part of a text editor’s plugin that provides features like syntax highlighting, auto-completion, and parsing. It creates a background thread to parse buffers in real-time, updates the UI with parsed data, and manages toolbars and caret handlers for editing. The code also handles buffer parsing, parsing cancellation, and cleanup of resources when the view is stopped or removed.

This Java class, Mode, represents an edit mode for a text editor. It defines settings and properties for editing specific types of files, such as syntax highlighting and folding. The class provides methods to initialize, load, and set properties, as well as check if the current buffer matches the specified file name and first line.

This Java class provides a set of properties and methods for configuring a log viewer application. It allows users to customize settings such as font, buffer size, latency, and tab placement, as well as store and retrieve these values from a configuration file. The class also handles default values and invalid input, ensuring that the application remains stable and functional.

This is a Java interface definition for a ProjectListener that extends the EventListener interface. It provides methods to be notified when files are added, removed, and project properties change in a project. The listener can react to these events by implementing the corresponding methods.

This is a Java interface definition for a command pattern implementation. It specifies a standard interface for various command classes, requiring them to implement an execute method that takes a string array of parameters and throws two custom exceptions: CommandInitializationException and CommandExecutionException. This allows commands to be executed with standardized input and output handling.

This Java code creates a graphical user interface (GUI) for adding new actions to an editor. It allows users to select an action set, choose an action from that set, and add it to the editor’s context menu. The GUI includes options for customizing the action’s label and separator. When the “OK” button is clicked, the selected action is added to the editor’s context menu.

This Java code is a utility class for creating and manipulating images with custom dialog boxes. It provides methods to create images with different layouts, resize them, and apply alpha blending effects. The getRMXPDialog method creates an image with a dialog box layout, while the getRMXPDialog(LImage rmxpImage, int width, int height, int size, int offset) method is a variant that takes an existing image as input.

This Java code retrieves and manipulates font properties for a graphical user interface (GUI). It checks if fonts can display localized text, such as languages and characters, and returns boolean values indicating success or failure. The code uses desktop properties to retrieve font information from the operating system’s toolkit.

This Java code defines a ConsoleBeanShell class that executes commands in jEdit’s BeanShell interpreter. It provides methods for printing information messages, executing commands, stopping the console, and waiting for user input. The class is designed to work with jEdit’s console interface, allowing users to interact with the BeanShell interpreter from within the editor.

This Java code performs a text-only installation of an application. It prompts the user to select components to install, sets configuration options for operating system tasks, and starts the installation process in a separate thread. The output displays the selected installation directory, component choices, and progress updates during the installation.

This Java class implements a custom shell for the GDB debugger, specifically designed to work with the MI (Machine Interface) protocol. It extends the BaseShell class and overrides several methods to customize its behavior, including printing information messages and executing commands. The class is part of a larger plugin architecture for the jEdit text editor.

This Java code implements a “Copy” action for an integrated development environment (IDE). It allows users to copy files from one location to another, either within the same repository or between different repositories. The action creates a new process that performs the copy operation and displays the results in the IDE’s UI.

This Java class represents a message that triggers the recreation of a dynamic menu in the jEdit text editor. It takes a menu name as an argument and stores it internally, allowing all menus with this name to be recreated upon display. The class extends EBMessage and provides methods for accessing the menu name and generating a string representation of the message.

This Java class, CssSideKickPlugin, defines a plugin for CSS sidekick functionality. It contains constants for the plugin’s name and option prefix, which can be used to identify and configure the plugin in a larger application. The class provides no additional functionality beyond defining these constants.

This Java code defines a custom action for a text editor, specifically Log Viewer. When triggered, it toggles word wrapping (line wrapping) on or off in the currently selected log file. It uses a separate class to handle the action and interacts with the main application’s GUI components. The action is part of a larger plugin for the jEdit text editor.

This Java code is part of a plugin manager for an IDE (Integrated Development Environment). It provides functionality to manage plugins, including sorting and filtering plugin information, displaying plugin details in a table, and handling keyboard and mouse events. The code also includes rendering and focus management for the plugin table.

This Java code creates a custom Reader class called CommandLineReader that modifies the behavior of the standard input stream when reading from the command line. It treats empty lines as ‘;\n’ to make the interpreter more user-friendly, but ignores this behavior when reading from files non-interactively.

This Java class, HistoryModel, is a list model for storing and managing a history of text input. It allows multiple instances to be created with unique names, and provides methods for adding, retrieving, and saving entries in the history. The data is stored in a vector and can be loaded from a file when the application starts.

This Java class, OptionsManager, is a singleton that manages settings for a Lucene plugin. It loads and saves settings from an XML file, storing options such as automatically indexing projects, directories, file name regex, and index interval. The class provides methods to get and set these options, as well as clear the settings.

The EditBus class is a global event notification mechanism for jEdit, a text editor. It allows plugins and other components to receive messages reflecting changes in the application’s state, such as buffer changes or property updates. The bus maintains a list of registered components, which receive messages sent using the send() method.

This Java code is for a graphical user interface (GUI) dialog box that allows users to manage and download macros from a database. It provides features such as sorting, searching, and selecting macros to download. The GUI includes buttons, text fields, and lists to display the available macros and their properties.

This Java code defines a class BSHArrayInitializer that extends SimpleNode. It is used to initialize arrays in a scripting language, allowing for dynamic array creation with variable dimensions and initializers. The class evaluates an array initializer syntax and creates an array of the specified base type with the given dimensions and initializers.

This Java class, BufferChanging, is a message sent by the EditPane when its buffer changes. It notifies plugins that the buffer has changed and provides the new buffer object. The class extends PositionChanging and includes error checking to ensure the new buffer is not null. It also logs an error if it is.

This C++ header defines a struct sharpsl_param_info that contains hardware parameters specific to Sharp SL series devices, such as display settings and touch input configurations. The struct is packed tightly in memory to save space. It also declares an external variable sharpsl_param of type sharpsl_param_info, and a function sharpsl_save_param that presumably saves the device’s parameters to storage.

This Java class, CodeObjectType, represents a type of object in a database schema. It provides methods to retrieve text and statement purpose information about code objects, such as their creation prefix and purpose for loading object code. The class is part of a larger SQL plugin system.

This Java class, BeanShellEvaluator, extends a Preprocessor and provides a method to process SQL text using BeanShell, a scripting language. The doProcess method takes a string input, evaluates it in the context of a BeanShell namespace, and returns the result as a string.

This Java code defines a plugin configuration pane for a Perforce version control system. It displays and allows editing of global settings, including the Perforce path, editor command, and file monitoring options. The changes are saved to a configuration object when the user clicks “save”. The code is part of a larger plugin for the JEdit text editor.

This Java code is a compiler for Java programs. It takes a set of .java files, compiles them into bytecode, and then runs the resulting classes using Sun’s javac tool. The compiled output is displayed in a GUI window, allowing users to view the compilation process and any errors that occur.

This Java class implements binary expressions for a scripting language, specifically handling instanceof and boolean operations. It evaluates the left-hand side of an expression, determines its type, and then performs the specified operation on the left-hand side and right-hand side based on their types. The result is returned as a Primitive object.

This Java code is a part of an editor plugin that highlights matching XML tags in a text editor. It uses a combination of buffer changes and caret updates to detect when a tag is being edited, and then updates the highlighting accordingly. The plugin also handles cases where a tag is inserted or removed from the buffer.

This C code initializes a Windows-based network interface for receiving notifications about network events, such as packet arrival and error conditions. It creates an instance of a WMI (Windows Management Instrumentation) object sink, connects to a WMI server, and registers asynchronous notifications with the sink. The sink provides methods for querying, adding references, releasing, indicating, and setting the status of the notification.

This Java code defines an interface named ClearCaseConstants that provides a set of constants for ClearCase commands and options. It includes strings representing various commands, such as COMMAND_CLEARTOOL, COMMAND_CLEARFINDCO, and option flags like OPTION_KEEP_FILE. The constants are likely used to interact with the ClearCase version control system in a Java application.

This Java class, SubduedFillPainter, extends a parent class to create a fill painter that returns images with a subdued 3D gradient appearance. It overrides two methods to adjust the colors used in the gradient, resulting in a milder and less intense visual effect compared to its parent class.

This Java code manages XML catalogs and resources for a text editor, specifically JEdit. It loads and parses catalog files, handles resource downloads, and updates the catalog when the user changes a file on disk. The code uses a custom Entry class to represent XML entries and a VFSUpdateHandler component to reload catalogs when files are modified.

This Java class, RETokenRange, represents a token range in regular expressions. It extends the REToken class and provides methods to match input characters within a specified range (inclusive) with sensitivity options. The class also includes a dump method to print the token range as a string.

This Java class, ExplicitFoldHandler, is a fold handler for the jEdit text editor. It folds lines based on markers (“{{{” and “}}}”) embedded in the text, increasing the fold level when an opening bracket appears three times and decreasing it when a closing bracket appears three times.

This PHP class, RoleVoter, implements a voter for Symfony’s security system. It checks if any attribute of an object starts with a given prefix (‘ROLE_’) and grants access if the role is present in the token’s roles. If the attribute is ‘ROLE_PREVIOUS_ADMIN’, it triggers deprecation warnings. The voter returns ACCESS_ABSTAIN by default, unless the attribute matches one of the token’s roles, in which case it returns ACCESS_GRANTED.

This Java code defines an interface DerivationRule that extends a base class Rule. It represents a derivation rule in a UML model and has one feature: a reference list of conclusions, which is bidirectional and opposite to another concept called “conclusion rule”. The interface provides a method to access this reference list.

This Ada code defines a configuration package for handling strings on an x86_64 platform. It specifies a string handler to be used, which is platform-dependent, and provides an initialization procedure that sets up this handler. The package is designed to work with the Matreshka project, which focuses on localization, internationalization, and globalization.

This Lisp code defines a web application framework using Weblocks, a continuations-based web framework. It creates a main page with a flash widget displaying an initial message and navigation widgets for employees and companies pages. The employees and companies pages are defined as composites of gridedit widgets, which display data in tables and allow editing.

This C header file defines a class Pickle that represents a serialized data structure. It provides methods for reading and writing data, including allocation and resizing of the buffer, alignment, and padding with null bytes. The class also includes functions for finding the end of the pickled data within a given range and updating iterators by a specified number of bytes.

This Java class, PeriodicUpdater, extends another class called Updater. It creates a timer that schedules an AJAX request to a specified URL at regular intervals (in milliseconds) and updates a container element with the response. The update can be cancelled or restarted as needed.