pldb/PLDB huggingface dataset:
Coco/R (grammarLanguage, appeared 1990)
Origin: Johannes Kepler University
Country: Austria
Website: http://ssw.jku.at/coco/

Coco/R is a compiler generator, which takes an attributed grammar of a source language and generates a scanner and a parser for this language. The scanner works as a deterministic finite automaton. The parser uses recursive descent. LL(1) conflicts can be resolved by a multi-symbol lookahead or by semantic checks. Thus the class of accepted grammars is LL(k) for an arbitrary k.

Coco/R is a compiler generator that takes an L-attributed Extended Backus–Naur Form (EBNF) grammar of a source language and generates a scanner and a parser for that language. The scanner works as a deterministic finite automaton.  It supports Unicode characters in UTF-8 encoding and can be made case-sensitive or case-insensitive. It can also recognize tokens based on their right-hand-side context. In addition to terminal symbols the scanner can also recognize pragmas, which are tokens that are not part of the syntax but can occur anywhere in the input stream (e.g. compiler directives or end-of-line characters). The parser uses recursive descent; LL(1) conflicts can be resolved by either a multi-symbol lookahead or by semantic checks. Thus the class of accepted grammars is LL(k) for an arbitrary k. Fuzzy parsing is supported by so-called ANY symbols that match complementary sets of tokens. Semantic actions are written in the same language as the generated scanner and parser. The parser's error handling can be tuned by specifying synchronization points and "weak symbols" in the grammar. Coco/R checks the grammar for completeness, consistency, non-redundancy as well as for LL(1) conflicts. There are versions of Coco/R for most modern languages (Java, C#, C++, Pascal, Modula-2, Modula-3, Delphi, VB.NET, Python, Ruby and others). The latest versions from the University of Linz are those for C#, Java and C++. For the Java version, there is an Eclipse plug-in and for C#, a Visual Studio plug-in. There are also sample grammars for Java and C#. Coco/R was originally developed at the ETHZ and moved with Hanspeter Mössenböck to University of Linz when he got his appointment there. Coco/R is distributed under the terms of a slightly relaxed GNU General Public License.
Coda web development software (editor, appeared 2007)
Origin: Panic Inc
Country: United States
Website: https://www.panic.com/coda/


Coda is a commercial and proprietary web development application for macOS, developed by Panic. It was first released on April 23, 2007 and won the 2007 Apple Design Award for Best User Experience. Coda version 2.0 was released on 24 May 2012, along with an iPad version called Diet Coda. Although formerly available on the Mac App Store, it was announced on May 14, 2014 that the update to Coda 2.5 would not be available in the Mac App Store due to sandboxing restrictions.
CodeGear Delphi (pl, appeared 1995)
Origin: Borland Software Corporation
Embarcadero Technologies
Country: United States


Delphi is an integrated development environment (IDE) for rapid application development of desktop, mobile, web, and console software, developed by Embarcadero Technologies. It is also an event-driven language.  Delphi's compilers use their own Object Pascal dialect of Pascal and generate native code for Microsoft Windows, macOS (IA-32 only), iOS, Android and Linux (x64 only). Since 2016, there have been new releases of Delphi every six months, with new platforms being added approximately every second release.Delphi includes a code editor, a visual designer, an integrated debugger, a source code control component, and support for third-party plugins. The code editor features Code Insight (code completion), Error Insight (real-time error-checking), and refactoring. The visual forms designer has traditionally used Visual Component Library (VCL) for native Windows development, but the FireMonkey (FMX) platform was later added for cross-platform development. Database support in Delphi is very strong. A Delphi project of a million lines to compile in a few seconds – one benchmark gave 170,000 lines per second. Delphi was originally developed by Borland as a rapid application development tool for Windows as the successor of Turbo Pascal. Delphi added full object-oriented programming to the existing language, and since then the language has grown to support generics and anonymous methods, and native Component Object Model (COM) support. In 2006, Borland’s developer tools section was transferred from Borland to a wholly owned subsidiary known as CodeGear, which was sold to Embarcadero Technologies in 2008. In 2015, Embarcadero was purchased by Idera Software, but the Embarcadero mark was retained for the developer tools division. Delphi and its C++ counterpart, C++Builder, are interoperable. They share many core components, notably the IDE, VCL, and much of the runtime library. In addition, they can be used jointly in a project. For example, C++Builder 6 and later can consume Delphi source code and C++ in one project, while packages compiled with C++Builder can be used from within Delphi. In 2007, the products were released jointly as RAD Studio, a shared host for Delphi and C++Builder, which can be purchased with either or both.
CodeQL (queryLanguage, appeared 2018)
Creators: Pavel Avgustinov
Origin: GitHub
Website: https://codeql.github.com/
File extensions: ql

CodeQL let's you query code as if it were data.


GitHub description: CodeQL: the libraries and queries that power security researchers around the world, as well as code scanning in GitHub Advanced Security (code scanning), LGTM.com, and LGTM Enterprise

from DataFlow::PathNode source, DataFlow::PathNode sink, UnsafeDeserializationConfig conf
  
          where conf.hasFlowPath(source, sink)
  
          select sink.getNode().(UnsafeDeserializationSink).getMethodAccess(), source, sink,
      "Unsafe deserialization of $@.", source.getNode(), "user input"
Common Object File Format (binaryExecutable, appeared 1983)
Stands for: Common Object File Format
Origin: AT&T Corporation
Country: United States


The Common Object File Format (COFF) is a format for executable, object code, and shared library computer files used on Unix systems. It was introduced in Unix System V, replaced the previously used a.out format, and formed the basis for extended specifications such as XCOFF and ECOFF, before being largely replaced by ELF, introduced with SVR4. COFF and its variants continue to be used on some Unix-like systems, on Microsoft Windows, in EFI environments and in some embedded development systems.
COFFEE Cinema 4D (pl, appeared 1992)
Origin: Maxon
Country: Germany


COFFEE (often written as "C.O.F.F.E.E") is a computer scripting language that forms part of CINEMA 4D, a proprietary 3D graphics application. Although presented as an acronym the letters of the word COFFEE do not appear to stand for anything, but are rather a comic reference to Java, a considerably more famous computer language.
CoffeeScript (pl, appeared 2009)
Also known as: coffee
Creators: Jeremy Ashkenas
Origin: https://github.com/jashkenas
Country: United States
Website: http://coffeescript.org
File extensions: coffee
litcoffee
Keywords: and
or
is
isnt
not
on
yes
@
no
off
true
false
null
this
new
delete
typeof
in
instanceof
return
throw
break
continue
debugger
if
else
switch
for
while
do
try
catch
finally
class
extends
super
undefined
then
unless
until
loop
of
by
when


CoffeeScript is a programming language that transcompiles to JavaScript. It adds syntactic sugar inspired by Ruby, Python and Haskell in an effort to enhance JavaScript's brevity and readability. Specific additional features include list comprehension and pattern matching. CoffeeScript support is included in Ruby on Rails version 3.1 and Play Framework. In 2011, Brendan Eich referenced CoffeeScript as an influence on his thoughts about the future of JavaScript.
ColaScript (pl, appeared 2012)
Creators: Dan Onoshko
Origin: TrigenSoftware
Country: Georgia
Website: https://github.com/TrigenSoftware/ColaScript/wiki/A-Tour-of-the-ColaScript



GitHub description: ColaScript is the language that compiles into JavaScript. This language is similar to Dart, CoffeeScript, Python, Go and PHP, with some original ideas. Compiler based on UglifyJS2. You can try ColaScript here (stable) or here (dev). Learn more about ColaScript.
ColdFusion Components (xmlFormat, appeared 1995)
Origin: Adobe
Country: United States




<cfcomponent> 
<cffunction name="allemployees" access="public" output="false" 
returntype="query"> 
<cfset var getNames=""> 
<cfquery name="getNames" datasource="cfdocexamples"> 
SELECT * FROM Employee 
</cfquery> 
</cffunction> 
<cffunction name="namesalarycontract" access="public" output="false" 
returntype="query"> 
<cfset var EmpList=""> 
<cfquery name="EmpList" datasource="cfdocexamples"> 
SELECT Firstname, Lastname, Salary, Contract 
FROM Employee 
</cfquery> 
</cffunction> 
<cffunction name="fullname" access="public" output="false" 
returntype="query"> 
<cfset var engquery=""> 
<cfquery name="engquery" datasource="cfdocexamples"> 
SELECT FirstName || ' ' || LastName AS FullName 
FROM Employee 
</cfquery> 
</cffunction> 
<cffunction name="bydept" access="public" output="false" returntype="query"> 
<cfset var deptquery=""> 
<cfquery name="deptquery" datasource="cfdocexamples"> 
SELECT Dept_ID, FirstName || ' ' || LastName 
AS FullName 
FROM Employee 
ORDER BY Dept_ID 
</cfquery> 
</cffunction> 
<cffunction name="employeebyURLID" access="public" output="false" 
returntype="query"> 
<cfset var GetRecordtoUpdate=""> 
<cfquery name="GetRecordtoUpdate" datasource="cfdocexamples"> 
SELECT * FROM Employee 
WHERE Emp_ID = #URL.Emp_ID# 
</cfquery> 
</cffunction> 
<cffunction name="deleteemployee" access="public" output="false" 
returntype="void"> 
<cfset var DeleteEmployee=""> 
<cfquery name="DeleteEmployee" datasource="cfdocexamples"> 
DELETE FROM Employee 
WHERE Emp_ID = #Form.Emp_ID# 
</cfquery> 
</cffunction> 
<cffunction name="distinctlocs"access="public" output="false" 
returntype="query"> 
<cfset var GetDepartments=""> 
<cfquery name="GetDepartments" datasource="cfdocexamples"> 
SELECT DISTINCT Location 
FROM Departmt 
</cfquery> 
</cffunction> 
</cfcomponent>
ColdFusion (pl, appeared 1995)
Creators: Joseph J. Allaire
Origin: Adobe
Website: https://www.adobe.com/products/coldfusion


Adobe ColdFusion is a commercial rapid web application development platform created by J. J. Allaire in 1995. (The programming language used with that platform is also commonly called ColdFusion, though is more accurately known as CFML.) ColdFusion was originally designed to make it easier to connect simple HTML pages to a database. By version 2 (1996), it became a full platform that included an IDE in addition to a full scripting language.
COLLADA (application, appeared 2004)
Origin: Sony Computer Entertainment
Khronos Group
Country: United States and Japan


COLLADA (COLLAborative Design Activity) is an interchange file format for interactive 3D applications. It is managed by the nonprofit technology consortium, the Khronos Group, and has been adopted by ISO as a publicly available specification, ISO/PAS 17506.COLLADA defines an open standard XML schema for exchanging digital assets among various graphics software applications that might otherwise store their assets in incompatible file formats. COLLADA documents that describe digital assets are XML files, usually identified with a .dae (digital asset exchange) filename extension.
Color BASIC (pl, appeared 1980)
Creators: Bill Gates
Origin: Microsoft
Country: United States


Color BASIC is the implementation of Microsoft BASIC that is included in the ROM of the Tandy/Radio Shack TRS-80 Color Computers manufactured between 1980 and 1991. BASIC (Beginners All-purpose Symbolic Instruction Code) is a high level language with simple syntax that makes it easy for novices to write simple programs. Color BASIC is interpreted, that is, decoded as it is run. Because of this, it is simple to edit and debug but performance is significantly lower than a compiled language such as C or assembly language.
ColorForth (pl, appeared 1992)
Creators: Charles H. Moore
Origin: https://github.com/colorforth
Country: United States
Website: https://colorforth.github.io/cf.htm

In Forth, a new word is defined by a preceding colon, words inside a definition are compiled, outside are executed. In colorForth a new word is red, green words are compiled, yellow executed. This use of color further reduces the syntax, or punctuation, needed. It also makes explicit how the computer will interpret each word.

colorForth is a programming language from the Forth language's original designer, Charles H. Moore, developed in the 1990s. There was an earlier predecessor called 386 OK which appeared for sale at Silicon Valley Forth Interest Group (SVFIG) meetings in 1992.An idiosyncratic programming environment, the colors simplify Forth's semantics, speed compiling, and are said to aid Moore's own poor eyesight: colorForth uses different colors in its source code (replacing some of the punctuation in standard Forth) to determine how different words are treated. colorForth was originally developed as the scripting language for Moore's own homebrew VLSI CAD program OKAD, with which he develops custom Forth processors. As the language gained utility, he rewrote his CAD program in it, spruced up the environment, and released it to the public. It has since gained a small following, spurred much debate in the Forth community, and sprung offshoots for other processors and operating environments. The language's roots are closer to the Forth machine languages Moore develops for his processors than to the mainstream standardized Forths in more widespread use. The language comes with its own tiny (63K) operating system. Practically everything is stored as source code and compiled as and when needed. The current colorForth environment is limited to running on Pentium grade PCs with limited support for lowest-common-denominator motherboards, AGP video, disk, and network hardware. Coloring in colorForth has semantic meaning. Red words start a definition and green words are compiled into the current definition. Thus, colorForth would be rendered in standard Forth as:   : color forth ;  Moore developed Forth in the early 1970s and created a series of implementations of the language. In the 1980s he diverged from (or rather ignored) the standardization of the language, instead continuing to evolve it. He developed a series of Forth-like languages, each fairly extreme in its simplicity: Machine Forth, OK, colorForth. There is some controversy about colorForth marginalizing color blind programmers, but Moore has stated that color is only one option for displaying the language. One of Moore's papers on colorForth was printed in black and white, but used italics and other typographical conventions to present source code.
COMAL (pl, appeared 1973)
Creators: Børge R. Christensen
Benedict Løfstedt
Origin: A school in Denmark
Country: Denmark


COMAL (Common Algorithmic Language) is a computer programming language developed in Denmark by Benedict Løfstedt and Børge R. Christensen in 1973. COMAL was one of the few structured programming languages that was available for and comfortably usable on 8-bit home computers. The "COMAL Kernel Syntax & Semantics" contains the formal definition of the language. Further extensions common to many implementations are described in .
Combined Log Format (textDataFormat, appeared 2002)
Origin: University of Illinois at Urbana–Champaign
Country: United States

Common Log Format plus referrer and user agent columns.



0:0:0:0:0:0:0:1 - Administrator [17/Sep/2021:13:51:27 -0400] "GET /invoke/pub.flow/getTransportInfo" 200 2502 https://mycompany.com/test/webapp "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36"
COMIT (pl, appeared 1957)
Creators: Victor Yngve
Origin: University of Chicago
Massachusetts Institute of Technology
Country: United States


COMIT was the first string processing language (compare SNOBOL, TRAC, and Perl), developed on the IBM 700/7000 series computers by Dr. Victor Yngve and collaborators at MIT from 1957 to 1965.  Yngve created the language for supporting computerized research in the field of linguistics, and more specifically, the area of machine translation for natural language processing. The creation of COMIT led to the creation of SNOBOL.
Commodore BASIC (pl, appeared 1977)
Origin: Microsoft


Commodore BASIC, also known as PET BASIC, is the dialect of the BASIC programming language used in Commodore International's 8-bit home computer line, stretching from the PET of 1977 to the C128 of 1985. The core was based on 6502 Microsoft BASIC, and as such it shares many characteristics with other 6502 BASICs of the time, such as Applesoft BASIC. Commodore licensed BASIC from Microsoft on a "pay once, no royalties" basis after Jack Tramiel turned down Bill Gates' offer of a $3 per unit fee, stating, "I'm already married," and would pay no more than $25,000 for a perpetual license.
Common Lisp (pl, appeared 1984)
Also known as: commonlisp
Creators: Scott Fahlman
Richard P. Gabriel
David A. Moon
Kent Pitman
Guy Steele
Dan Weinreb
Origin: American National Standards Institute
Country: United States
Website: http://common-lisp.net/
File extensions: lisp
lsp
l
cl
fasl


Common Lisp (CL) is a dialect of the Lisp programming language, published in ANSI standard document ANSI INCITS 226-1994 (R2004) (formerly X3.226-1994 (R1999)). The Common Lisp HyperSpec, a hyperlinked HTML version, has been derived from the ANSI Common Lisp standard. The Common Lisp language was developed as a standardized and improved successor of Maclisp. By the early 1980s several groups were already at work on diverse successors to MacLisp: Lisp Machine Lisp (aka ZetaLisp), Spice Lisp, NIL and S-1 Lisp. Common Lisp sought to unify, standardise, and extend the features of these MacLisp dialects. Common Lisp is not an implementation, but rather a language specification. Several implementations of the Common Lisp standard are available, including free and open-source software and proprietary products. Common Lisp is a general-purpose, multi-paradigm programming language. It supports a combination of procedural, functional, and object-oriented programming paradigms. As a dynamic programming language, it facilitates evolutionary and incremental software development, with iterative compilation into efficient run-time programs. This incremental development is often done interactively without interrupting the running application. It also supports optional type annotation and casting, which can be added as necessary at the later profiling and optimization stages, to permit the compiler to generate more efficient code. For instance, fixnum can hold an unboxed integer in a range supported by the hardware and implementation, permitting more efficient arithmetic than on big integers or arbitrary precision types. Similarly, the compiler can be told on a per-module or per-function basis which type safety level is wanted, using optimize declarations. Common Lisp includes CLOS, an object system that supports multimethods and method combinations. It is often implemented with a Metaobject Protocol. Common Lisp is extensible through standard features such as Lisp macros (code transformations) and reader macros (input parsers for characters). Common Lisp provides some backwards compatibility to Maclisp and to John McCarthy's original Lisp. This allows older Lisp software to be ported to Common Lisp.
CWL (pl, appeared 2014)
Creators: Luka Stojanovic
Origin: https://w3id.org/cwl/meeting_minutes
Country: Various
Website: https://www.commonwl.org/

The Common Workflow Language (CWL) is a specification for describing analysis workflows and tools in a way that makes them portable and scalable across a variety of software and hardware environments, from workstations to cluster, cloud, and high performance computing (HPC) environments. CWL is designed to meet the needs of data-intensive science, such as Bioinformatics, Medical Imaging, Astronomy, Physics, and Chemistry.


GitHub description: Common Workflow Language reference implementation
CommonLoops (pl, appeared 1986)
Origin: Hewlett-Packard
Country: United States


CommonLoops (the Common Lisp Object-Oriented Programming System; an acronym reminiscent of the earlier Lisp OO system "Loops" for the Interlisp-D system) is an early programming language which extended Common Lisp to include Object-oriented programming functionality and is a dynamic object system which differs from the OOP facilities found in static languages such as C++ or Java. Like New Flavors, CommonLoops supported multiple inheritance, generic functions and method combination. CommonLoops also supported multi-methods and made use of metaobjects. CommonLoops and New Flavors were the primary ancestors of  CLOS.  CommonLoops was supported by a portable implementation known as Portable CommonLoops (PCL) which ran on all Common Lisp implementations of the day.
Compact Application Solution Language (pl, appeared 1997)
Origin: WAGWARE Systems Inc
Brainyware LLC
Country: United States


Compact Application Solution Language (CASL) is a programming language used to create computer programs for Palm OS, and Microsoft Windows desktops, laptops, and Pocket PCs with Windows Mobile.  It is published by WAGWARE Systems, Inc., and Brainyware, LLC. As a language, CASL is similar to Pascal or Visual Basic with object-oriented programming features.  The CASL software development kit (SDK) includes a graphical user interface (GUI) forms editor, an integrated development environment (IDE), and a compiler.  CASL programs can either be run as interpreted applications on target devices (using a small helper binary), or compiled directly to native code (CASLpro).  One of CASL's key features is that the same source can be compiled to Palm OS, Windows, or Pocket PC with Windows Mobile, without changing the code, termed "write once, run all". In July 2005, CASLsoft announced they were discontinuing support for CASL and releasing it as freeware, with version 4.2 as the last official release.  A month later, WAGWARE Systems, Inc. and Brainyware, LLC announced the purchase of CASL, updated the product and continue to release it as commercial software. CASL Version 4.3 was released on 3 July 2006. In January 2007, more libraries were released to support the Janam XP20/XP30 series of barcode devices.  The CASL libraries are also backward compatible with the Symbol SPT series devices.
Compiler-Compiler (pl, appeared 1963)


In computer science, a compiler-compiler or compiler generator is a programming tool that creates a parser, interpreter, or compiler from some form of formal description of a programming language and machine. The input may be a text file containing the grammar written in BNF or EBNF that defines the syntax of a programming language, and whose generated output is some source code of the parser for the programming language, although other definitions exist. Usually, the resulting source code will have to be extended upon before a complete compiler emerges.A metacompiler is a software development tool used chiefly in the construction of compilers, translators, and interpreters for other programming languages. The input to a metacompiler is a computer program written in a specialized programming metalanguage designed chiefly for the purpose of constructing compilers. The language of the compiler produced is called the object language. The minimal input producing a compiler is a metaprogram specifying the object language grammar and semantic transformations into an object program.
COMTRAN (pl, appeared 1957)
Origin: IBM
Country: United States


COMTRAN (COMmercial TRANslator) is an early programming language developed at IBM.  It was intended as the business programming equivalent of the scientific programming language FORTRAN (FORmula TRANslator).  It served as one of the forerunners to the COBOL language. Developed by Bob Bemer, in 1957, the language was the first to feature the programming language element known as a picture clause.