pldb/PLDB huggingface dataset:
PCRE (queryLanguage, appeared 1997)
Stands for: Perl Compatible Regular Expressions
Creators: Philip Hazel
Origin: https://github.com/PCRE2Project
Country: Unknown
Website: http://pcre.org/


Perl Compatible Regular Expressions (PCRE) is a regular expression C library inspired by the regular expression capabilities in the Perl programming language. Philip Hazel started writing PCRE in summer 1997. PCRE's syntax is much more powerful and flexible than either of the POSIX regular expression flavors and than that of many other regular-expression libraries. While PCRE originally aimed at feature-equivalence with Perl, the two implementations are not fully equivalent. During the PCRE 7.x and Perl 5.9.x phase, the two projects have coordinated development, with features being ported between them in both directions. A number of prominent open-source programs, such as the Apache HTTP Server and the PHP and R scripting languages, incorporate the PCRE library; proprietary software can do likewise (BSD license). As of Perl 5.10, PCRE is also available as a replacement for Perl's default regular expression engine through the re::engine::PCRE module. The library can be built using configure and make (typical of Unix-like environments), as well as in Unix, Windows and other environments using CMake. Numerous default settings are chosen at build time. In addition to the PCRE library, the distribution includes a POSIX C wrapper, a native C++ wrapper, several test programs, and the utility program pcregrep built in tandem with the library. The PCRE library provides matching only; the C++ wrapper, if used, adds multiple match and replacement functionality. Unless users choose the "NoRecurse" PCRE build option (aka "--disable-stack-for-recursion"), the calling application or operating system must allocate adequate stack space to PCRE. The amount of stack needed varies for each pattern. For example, completing the tests provided with pcretest needs 8 MB of stack space. While PCRE's documentation cautions that the "NoRecurse" build option makes PCRE slower than the alternative, using it avoids entirely the issue of stack overflows.

GitHub description: PCRE2 development is now based here.
PDP-11 (computingMachine, appeared 1970)
Origin: Digital Equipment Corporation
Country: United States


The PDP-11 is a series of 16-bit minicomputers sold by Digital Equipment Corporation (DEC) from 1970 into the 1990s, one of a succession of products in the PDP series. In total, around 600,000 PDP-11s of all models were sold, making it one of DEC's most successful product lines. The PDP-11 is considered by some experts to be the most popular minicomputer ever. The PDP-11 included a number of innovative features in its instruction set and additional general-purpose registers that made it much easier to program than earlier models in the series. Additionally, the innovative Unibus system allowed external devices to be easily interfaced to the system using direct memory access, opening the system to a wide variety of peripherals.  The PDP-11 replaced the PDP-8 in many real-time applications, although both product lines lived in parallel for more than 10 years.  The ease of programming of the PDP-11 made it very popular for general purpose computing uses as well. The design of the PDP-11 inspired the design of late-1970s microprocessors including the Intel x86 and the Motorola 68000. Design features of PDP-11 operating systems, as well as other operating systems from Digital Equipment, influenced the design of other operating systems such as CP/M and hence also MS-DOS. The first officially named version of Unix ran on the PDP-11/20 in 1970. It is commonly stated that the C programming language took advantage of several low-level PDP-11–dependent programming features, albeit not originally by design.An effort to expand the PDP-11 from 16 to 32-bit addressing led to the VAX-11 design, which took part of its name from the PDP-11.
PEARL (pl, appeared 1977)
Stands for: Process and Experiment Automation Real-Time Language
Origin: Deutsches Institut für Normung
Country: Germany


PEARL, or Process and experiment automation realtime language, is a computer programming language designed for multitasking and real-time programming. Being a high-level language, it is fairly cross-platform. Since 1977, the language has been going under several standardization steps by the Deutsches Institut für Normung. The current version is PEARL-90, which was standardized in 1998 as DIN 66253-2. PEARL is not to be confused with the similarly named Perl, an entirely unrelated programming language created by Larry Wall in 1987.
PEG (grammarLanguage, appeared 2002)
Stands for: parsing expression grammar


In computer science, a parsing expression grammar, or PEG, is a type of analytic formal grammar, i.e. it describes a formal language in terms of a set of rules for recognizing strings in the language. The formalism was introduced by Bryan Ford in 2004 and is closely related to the family of top-down parsing languages introduced in the early 1970s. Syntactically, PEGs also look similar to context-free grammars (CFGs), but they have a different interpretation: the choice operator selects the first match in PEG, while it is ambiguous in CFG. This is closer to how string recognition tends to be done in practice, e.g. by a recursive descent parser. Unlike CFGs, PEGs cannot be ambiguous; if a string parses, it has exactly one valid parse tree. It is conjectured that there exist context-free languages that cannot be recognized by a PEG, but this is not yet proven. PEGs are well-suited to parsing computer languages (and artificial human languages such as Lojban), but not natural languages where the performance of PEG algorithms is comparable to general CFG algorithms such as the Earley algorithm.


Expr    ← Sum
Sum     ← Product (('+' / '-') Product)*
Product ← Value (('*' / '/') Value)*
Value   ← [0-9]+ / '(' Expr ')'
PEG.js (grammarLanguage, appeared 2010)
Creators: David Majda
Origin: https://github.com/pegjs
Country: Germany and United Kingdom
Website: https://pegjs.org/

PEG.js is a simple parser generator for JavaScript that produces fast parsers with excellent error reporting. You can use it to process complex data or computer languages and build transformers, interpreters, compilers and other tools easily.


GitHub description: PEG.js: Parser generator for JavaScript

start
 = additive

additive
  = left:multiplicative "+" right:additive { return left + right; }
  / multiplicative

multiplicative
  = left:primary "*" right:multiplicative { return left * right; }
  / primary

primary
  = integer
  / "(" additive:additive ")" { return additive; }

integer "integer"
  = digits:[0-9]+ { return parseInt(digits.join(""), 10); }
PeopleCode (pl, appeared 2008)
Origin: Oracle


PeopleCode is a proprietary object-oriented programming language used to express business logic for PeopleSoft applications. Syntactically, PeopleCode is similar to other programming languages, and can be found in both loosely-typed and strongly-typed forms. PeopleCode and its run-time environment is part of the larger PeopleTools framework. PeopleCode has evolved over time and its implementation through the PeopleSoft applications lack consistency. PeopleCode offers some interoperability with the Java programming language. Definition name references, for example, enable you to refer to PeopleTools definitions, such as record definitions or pages, without using hard-coded string literals. Other language features, such as PeopleCode data types and metastrings, reflect the close interaction of PeopleTools and Structured Query Language (SQL). Dot notation, classes and methods in PeopleCode are similar to other object oriented languages, like Java. Object syntax was an important feature of PeopleTools 8.
Pep8 (assembly, appeared 2009)
Origin: Pepperdine University
Country: United States



GitHub description: Pep/8 assembler and simulator for the textbook Computer Systems, J. Stanley Warford, Fourth edition

 BR main
 num: .EQUATE 0 
 main: SUBSP 2,i 
 DECI num,s 
 if: LDA num,s 
 ANDA 0x0001,i
 BRNE else
 STRO even_msg,d 
 BR endIf
 else: STRO odd_msg,d 
 endIf: ADDSP 2,i 
 STOP
 odd_msg: .ASCII "The number is: Odd\x00"
 even_msg: .ASCII "The number is: Even\x00"
 .END
Perl 6 (pl, appeared 2015)
Also known as: Raku perl6
Creators: Larry Wall
Origin: https://raku.org/community
Country: Various
Website: https://perl6.org/


Perl 6 (also known as Raku) is a member of the Perl family of programming languages.While historically several interpreter and compiler implementations were being written, today only the Rakudo Perl 6 implementation is in active development. It is introducing elements of many modern and historical languages. Compatibility with Perl 5 is not a goal, though a compatibility mode is part of the specification. The design process for Perl 6 began in 2000. In February 2015 a post on The Perl Foundation blog stated that "The Perl6 team will attempt to get a development release of version 1.0 available for Larry's birthday in September and a Version 1.0 release by Christmas", and on 25 December 2015, the first stable version of the specification was announced.Development on Pugs, the first high-traction implementation, began in 2005, and there have been multiple Perl 6 implementation projects. Rakudo Perl 6 is based on NQP (Not Quite Perl) and can use MoarVM or the Java Virtual Machine as a runtime environment, and releases a new version every month (including precompiled GNU/Linux packages); in July 2010, the project released the first Rakudo Star distribution, a collection of a Perl 6 implementation and related materials. Larry Wall maintains a reference grammar known as STD.pm6, written in Perl 6 and bootstrapped with Perl 5.
Perl Data Language (pl, appeared 1996)
Origin: https://github.com/PDLPorters
Country: Various


Perl Data Language (abbreviated PDL) is a set of free software array programming extensions to the Perl programming language. PDL extends the data structures built into Perl, to include large multidimensional arrays, and adds functionality to manipulate those arrays as vector objects. It also provides tools for image processing, computer modeling of physical systems, and graphical plotting and presentation. Simple operations are automatically vectorized across complete arrays, and higher-dimensional operations (such as matrix multiplication) are supported.
Perl (pl, appeared 1987)
Creators: Larry Wall
Origin: Unisys
Country: United States
Website: https://www.perl.org
File extensions: pl
pm
t
pod
Keywords: __DATA__
else
lock
qw
__END__
elsif
lt
qx
__FILE__
eq
m
s
__LINE__
exp
ne
sub
__PACKAGE__
for
no
tr
and
foreach
or
unless
cmp
ge
package
until
continue
gt
q
while
CORE
if
qq
xor
do
le
qr
y


Perl is a family of high-level, general-purpose, interpreted, dynamic programming languages. The languages in this family include Perl 5 and Perl 6. Though Perl is not officially an acronym, there are various backronyms in use, including "Practical Extraction and Reporting Language". Perl was originally developed by Larry Wall in 1987 as a general-purpose Unix scripting language to make report processing easier. Since then, it has undergone many changes and revisions. Perl 6, which began as a redesign of Perl 5 in 2000, eventually evolved into a separate language. Both languages continue to be developed independently by different development teams and liberally borrow ideas from one another. The Perl languages borrow features from other programming languages including C, shell script (sh), AWK, and sed. They provide powerful text processing facilities without the arbitrary data-length limits of many contemporary Unix commandline tools, facilitating easy manipulation of text files. Perl 5 gained widespread popularity in the late 1990s as a CGI scripting language, in part due to its then unsurpassed regular expression and string parsing abilities. In addition to CGI, Perl 5 is used for system administration, network programming, finance, bioinformatics, and other applications, such as for GUIs. It has been nicknamed "the Swiss Army chainsaw of scripting languages" because of its flexibility and power, and also its ugliness. In 1998, it was also referred to as the "duct tape that holds the Internet together", in reference to both its ubiquitous use as a glue language and its perceived inelegance.
PgBouncer (application, appeared 2007)
Creators: Frank McGeough
Origin: https://github.com/pgbouncer/pgbouncer
Country: unknown
Website: https://www.pgbouncer.org/

PgBouncer is an open-source, lightweight, single-binary connection pooler for PostgreSQL. It can pool connections to one or more databases (on possibly different servers) and serve clients over TCP and Unix domain socket.


GitHub description: Lightweight connection pooler for PostgreSQL
Netpbm grayscale image format (textDataFormat, appeared 1988)
Origin: https://netpbm.sourceforge.net/history.html
Country: Unknown

The PGM format is a lowest common denominator grayscale file format. It is designed to be extremely easy to learn and write programs for. (It's so simple that most people will simply reverse engineer it because it's easier than reading this specification).



P2
# feep.pgm
24 7
15
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
0  3  3  3  3  0  0  7  7  7  7  0  0 11 11 11 11  0  0 15 15 15 15  0
0  3  0  0  0  0  0  7  0  0  0  0  0 11  0  0  0  0  0 15  0  0 15  0
0  3  3  3  0  0  0  7  7  7  0  0  0 11 11 11  0  0  0 15 15 15 15  0
0  3  0  0  0  0  0  7  0  0  0  0  0 11  0  0  0  0  0 15  0  0  0  0
0  3  0  0  0  0  0  7  7  7  7  0  0 11 11 11 11  0  0 15  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
Pharo (pl, appeared 2008)
Origin: https://consortium.pharo.org
Country: France
Website: https://pharo.org/

Pharo is a pure object-oriented programming language and a powerful environment, focused on simplicity and immediate feedback (think IDE and OS rolled into one).

Pharo is an open source dynamic and reflective language inspired from the programming language and integrated development environment (IDE) Smalltalk. Pharo offers strong live programming features such as immediate object manipulation, live update and hot recompiling. The live programming environment is at the heart of the system.


Object subclass: #Counter
 instanceVariableNames: ’count initialValue’
 classVariableNames: ’’
 package: ’MyCounter’
Phel (pl, appeared 2020)
Creators: Jens Haase
Origin: https://github.com/phel-lang
Country: United States
Website: https://phel-lang.org/



GitHub description: Phel is a functional programming language that compiles to PHP. It is a dialect of Lisp inspired by Clojure and Janet.

 (ns hello-world\boot)

 (println "Hello, World!")
Phoenix Object Basic (pl, appeared 2001)
Origin: CIMLINC, Inc
Janus Software
Country: United States and The Netherlands


Phoenix Object Basic is an object-oriented rapid application development tool for Linux. It has object-oriented features such as inheritance and polymorphism as found in languages such as Python and Perl. It also features a similar design environment and compatible syntax to Visual Basic reducing the learning curve for those making a transition from that language to Linux programming. Phoenix includes a full implementation of the BASIC programming language. It was released for download in 2001 and the Linux package is at version 1.5 beta 6 (released October 2004), it also requires the distribution of a small number of runtime library files with complied applications. Phoenix Object Basic is a proprietary tool for cross-platform Linux and Windows application development.   Key attributes:  No longer being actively developed Rapid Application Development for Windows and Linux Short learning curve for VB developers Object-oriented Small executables, Fast execution Cross platform Released as an RPMThe Phoenix source code is not available because it contains proprietary third party components. Phoenix is free of charge and freely distributable.
PHP (pl, appeared 1995)
Stands for: Personal Home Page
Creators: Rasmus Lerdorf
Origin: Zend
Country: Canada
Website: https://php.net
File extensions: php
phtml
php3
php4
php5
php7
phps
Keywords: __CLASS__
__DIR__
__FILE__
__FUNCTION__
__halt_compiler()
__LINE__
__METHOD__
__NAMESPACE__
__TRAIT__
abstract
and
array()
as
break
callable
case
catch
class
clone
const
continue
declare
default
die()
do
echo
else
elseif
empty()
enddeclare
endfor
endforeach
endif
endswitch
endwhile
eval()
exit()
extends
final
finally
for
foreach
function
global
goto
if
implements
include
include_once
instanceof
insteadof
interface
isset()
list()
namespace
new
or
print
private
protected
public
require
require_once
return
static
switch
throw
trait
try
unset()
use
var
while
xor
yield


PHP is a server-side scripting language designed primarily for web development but also used as a general-purpose programming language. Originally created by Rasmus Lerdorf in 1994, the PHP reference implementation is now produced by The PHP Development Team. PHP originally stood for Personal Home Page, but it now stands for the recursive acronym PHP: Hypertext Preprocessor. PHP code may be embedded into HTML or HTML5 markup, or it can be used in combination with various web template systems, web content management systems and web frameworks. PHP code is usually processed by a PHP interpreter implemented as a module in the web server or as a Common Gateway Interface (CGI) executable. The web server software combines the results of the interpreted and executed PHP code, which may be any type of data, including images, with the generated web page. PHP code may also be executed with a command-line interface (CLI) and can be used to implement standalone graphical applications. The standard PHP interpreter, powered by the Zend Engine, is free software released under the PHP License. PHP has been widely ported and can be deployed on most web servers on almost every operating system and platform, free of charge. The PHP language evolved without a written formal specification or standard until 2014, leaving the canonical PHP interpreter as a de facto standard. Since 2014 work has gone on to create a formal PHP specification.

GitHub description: The PHP Interpreter
phylip (textDataFormat, appeared 1991)
Origin: University of Washington
Country: United States
File extensions: phy
ph

The PHYLIP file format stores a multiple sequence alignment. The format was originally defined and used in Joe Felsenstein’s PHYLIP package [R165], and has since been supported by several other bioinformatics tools



3 30
Taxon1     ACCGTTTCCACAGCATTATGG
GCTCGATGA
Taxon2     CACTTCACAAATCAATATTGA
GCTAGTGCA
Taxon3     TAAGGTATTGGGCTTGGTTCG
CAGGGGACT
PhyloXML (xmlFormat, appeared 2009)
Origin: World Wide Web Consortium
Country: United States
Website: http://www.phyloxml.org/


PhyloXML is an XML language for the analysis, exchange, and storage of phylogenetic trees (or networks) and associated data. The structure of phyloXML is described by XML Schema Definition (XSD) language. A shortcoming of current formats for describing phylogenetic trees (such as Nexus and Newick/New Hampshire) is a lack of a standardized means to annotate tree nodes and branches with distinct data fields (which in the case of a basic species tree might be: species names, branch lengths, and possibly multiple support values). Data storage and exchange is even more cumbersome in studies in which trees are the result of a reconciliation of some kind:  gene-function studies (requires annotation of nodes with taxonomic information as well as gene names, and possibly gene-duplication data) evolution of host-parasite interactions (requires annotation of tree nodes with taxonomic information for both host and parasite) phylogeographic studies (requires annotation of tree nodes with taxonomic and geographic information)To alleviate this, a variety of ad-hoc, special purpose formats have come into use (such as the NHX format, which focuses on the needs of gene-function and phylogenomic studies). A well defined XML format addresses these problems in a general and extensible manner and allows for interoperability between specialized and general purpose software. An example of a program for visualizing phyloXML is Archaeopteryx.


 <phyloxml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.phyloxml.org http://www.phyloxml.org/1.10/phyloxml.xsd"
  xmlns="http://www.phyloxml.org">
  <phylogeny rooted="true">
     <name>example from Prof. Joe Felsenstein's book "Inferring Phylogenies"</name>
     <description>MrBayes based on MAFFT alignment</description>
     <clade>
        <clade branch_length="0.06">
           <confidence type="probability">0.88</confidence>
           <clade branch_length="0.102">
              <name>A</name>
           </clade>
           <clade branch_length="0.23">
              <name>B</name>
           </clade>
        </clade>
        <clade branch_length="0.4">
           <name>C</name>
        </clade>
     </clade>
  </phylogeny>
</phyloxml>
PIC microcontroller (pl, appeared 1975)
Origin: Microchip Technology, Inc
Country: United States


PIC (usually pronounced as "pick") is a family of microcontrollers made by Microchip Technology, derived from the PIC1650  originally developed by General Instrument's Microelectronics Division. The name PIC initially referred to Peripheral Interface Controller, then it was corrected as Programmable Intelligent Computer. The first parts of the family were available in 1976; by 2013 the company had shipped more than twelve billion individual parts, used in a wide variety of embedded systems. Early models of PIC had read-only memory (ROM) or field-programmable EPROM for program storage, some with provision for erasing memory. All current models use flash memory for program storage, and newer models allow the PIC to reprogram itself. Program memory and data memory are separated. Data memory is 8-bit, 16-bit, and, in latest models, 32-bit wide. Program instructions vary in bit-count by family of PIC, and may be 12, 14, 16, or 24 bits long. The instruction set also varies by model, with more powerful chips adding instructions for digital signal processing functions. The hardware capabilities of PIC devices range from 6-pin SMD, 8-pin DIP chips up to 144-pin SMD chips, with discrete I/O pins, ADC and DAC modules, and communications ports such as UART, I2C, CAN, and even USB. Low-power and high-speed variations exist for many types. The manufacturer supplies computer software for development known as MPLAB X, assemblers and C/C++ compilers, and programmer/debugger hardware under the MPLAB and PICKit series. Third party and some open-source tools are also available. Some parts have in-circuit programming capability; low-cost development programmers are available as well as high-production programmers. PIC devices are popular with both industrial developers and hobbyists due to their low cost, wide availability, large user base, extensive collection of application notes, availability of low cost or free development tools, serial programming, and re-programmable Flash-memory capability.