| podobné slovo | definícia | 
compile (mass) | compile
  - zostaviť, kompilovať, prekladať | 
compiler (mass) | compiler
  - prekladač, zostavovateľ | 
compile (encz) | compile,kompilovat	v:		Zdeněk Brožcompile,přeložit	v: [it.]	program (do binární, spustitelné
 podoby)	Pajoshcompile,sestavit	v:		Zdeněk Brož | 
compiled (encz) | compiled,kompilovaný	adj:		Zdeněk Brožcompiled,zkompilovaný	adj:		Zdeněk Brož | 
compiler (encz) | compiler,překladač	n: [it.]		 | 
compilers (encz) | compilers,kompilátory	n: pl.		Zdeněk Brož | 
compiles (encz) | compiles,kompiluje	v:		Zdeněk Brož | 
decompile (encz) | decompile,dekompilovat	v:		Zdeněk Brož | 
international compilers working group on external debt statistics (encz) | International Compilers Working Group on External Debt Statistics,			 | 
precompiled (encz) | precompiled,přeložený	[it.]		web | 
recompile (encz) | recompile,překompilovat	v:		Zdeněk Brožrecompile,rekompilovat	v:		Zdeněk Brož | 
recompiled (encz) | recompiled,rekompilovaný	adj:		Zdeněk Brož | 
Compiled (gcide) | Compile \Com*pile"\, v. t. [imp. & p. p. Compiled; p. pr. &
    vb. n. Compiling.] [F. compiler, fr.L. compilare to
    plunder, pillage; com- + pilare to plunder. See Pill, v.
    t., Pillage.]
    1. To put together; to construct; to build. [Obs.]
       [1913 Webster]
 
             Before that Merlin died, he did intend
             A brazen wall in compass to compile.  --Spenser.
       [1913 Webster]
 
    2. To contain or comprise. [Obs.]
       [1913 Webster]
 
             Which these six books compile.        --Spenser.
       [1913 Webster]
 
    3. To put together in a new form out of materials already
       existing; esp., to put together or compose out of
       materials from other books or documents.
       [1913 Webster]
 
             He [Goldsmith] compiled for the use of schools a
             History of Rome.                      --Macaulay.
       [1913 Webster]
 
    4. To write; to compose. [Obs.] --Sir W. Temple.
       [1913 Webster]
 
    5. (Computers) to process (computer program source code) with
       a compiler[2] to produce an assembly-language program or
       an executable program in machine language.
       [PJC] | 
Compilement (gcide) | Compilement \Com*pile"ment\, n.
    Compilation. [R.]
    [1913 Webster] | 
Compiler (gcide) | Compiler \Com*pil"er\ (k[o^]m*p[imac]l"[~e]r), n. [OE.
    compiluor; cf. OF. compileor, fr. L. compilator.]
    1. One who compiles; esp., one who makes books by
       compilation.
       [1913 Webster]
 
    2. (Computers) a computer program that decodes instructions
       written in a higher-level computer language to produce an
       assembly-language program or an executable program in
       machine language.
       [WordNet 1.5 +PJC] | 
Recompile (gcide) | Recompile \Re`com*pile"\ (r[=e]`k[o^]m*p[imac]l"), v. t.
    To compile anew.
    [1913 Webster] | 
Recompilement (gcide) | Recompilement \Re`com*pile"ment\ (-ment), n.
    The act of recompiling; new compilation or digest; as, a
    recompilement of the laws. --Bacon.
    [1913 Webster] | 
c compiler (wn) | C compiler
     n 1: a compiler for programs written in C | 
compile (wn) | compile
     v 1: get or gather together; "I am accumulating evidence for the
          man's unfaithfulness to his wife"; "She is amassing a lot
          of data for her thesis"; "She rolled up a small fortune"
          [syn: roll up, collect, accumulate, pile up,
          amass, compile, hoard]
     2: put together out of existing material; "compile a list" [syn:
        compose, compile]
     3: use a computer program to translate source code written in a
        particular programming language into computer-readable
        machine code that can be executed | 
compiler (wn) | compiler
     n 1: a person who compiles information (as for reference
          purposes)
     2: (computer science) a program that decodes instructions
        written in a higher order language and produces an assembly
        language program [syn: compiler, compiling program] | 
fortran compiler (wn) | Fortran compiler
     n 1: a compiler for programs written in FORTRAN | 
lisp compiler (wn) | LISP compiler
     n 1: a compiler for programs written in LISP | 
pascal compiler (wn) | Pascal compiler
     n 1: a compiler for programs written in Pascal | 
a language with an extensible compiler (foldoc) | A Language with an Extensible Compiler
 ALEC
 
     (ALEC) A language Implemented using RCC on an
    ICL 1906A.
 
    ["ALEC - A User Extensible Scientific Programming Language",
    R.B.E. Napper et al, Computer J 19(1):25-31].
 
    (1995-04-19)
  | 
air material command compiler (foldoc) | AIr MAterial COmmand compiler
 AIMACO
 
     (AIMACO) A modification of FLOW-MATIC.  AIMACO
    was supplanted by COBOL.
 
    [Sammet 1969, p. 378].
 
    (1995-02-20)
  | 
algebraic compiler and translator (foldoc) | Algebraic Compiler and Translator
 ACT 1
 
     (ACT 1) A language and compiler for the {Royal
    McBee} LGP-30, designed around 1959, apparently by Clay
    S. Boswell, Jr, and programmed by Mel Kaye.
 
    (http://ed-thelen.org/comp-hist/lgp-30-man.html)
 
    (2008-08-04)
  | 
assembly language compiler (foldoc) | Assembly Language Compiler
 
     (ALC) An alternative name for IBM 360 {assembly
    language}.
 
    Compare BAL.
 
    (1995-01-04)
  | 
block diagram compiler (foldoc) | Block Diagram Compiler
 BDL
 
     (BDL) A block diagram simulation tool,
    with associated language.
 
    ["A Software Environment for Digital Signal-Processing
    Simulations," D.H. Johnson & R.E. Vaughan, Circuits Systems
    and Signal Processing 6(1):31-43, 1987].
 
    (2000-07-17)
  | 
byte compiler (foldoc) | byte-code compiler
 byte compiler
 
     A compiler which outputs a program in
    some kind of byte-code.
 
    Compare: byte-code interpreter.
 
    (1995-11-04)
  | 
byte-code compiler (foldoc) | byte-code compiler
 byte compiler
 
     A compiler which outputs a program in
    some kind of byte-code.
 
    Compare: byte-code interpreter.
 
    (1995-11-04)
  | 
compile time (foldoc) | compile time
 
     The period of time during which a program's
    source code is being translated into machine code, as
    opposed to run time when the program is being executed.  As
    well as the work done by the compiler, this may include
    macro preprocessing as done by cpp for example.  The final
    stage of program construction, performed by the linker,
    would generally also be classed as compile time but might be
    distinguished as link time.
 
    For example, static data in a C program is allocated at
    compile time whereas non-static data is allocated at {run
    time}, typically on the stack.
 
    (2004-09-28)
  | 
compiled html (foldoc) | Compiled HTML
 chm
 
     A Microsoft file format for
    distributing a collection of HTML files, along with their
    associated images, sounds, etc., as a single compressed
    archive file.
 
    Microsoft use this format for Windows HTML Help files.
    Most chms include a project (.hhp) file listing the included
    files and basic settings, a contents (.hhc) file, an index
    (.hhk) file, html files, and, optionally, image files.
 
    Users view chms with hh.exe, the HTML Help viewer installed
    with Internet Explorer.
 
    Filename extension: .chm.
 
    
 (http://msdn.microsoft.com/library/en-us/htmlhelp/html/vsconHH1Start.asp).
 
    (2003-05-17)
  | 
compiler (foldoc) | compiler
 
     A program that converts another program
    from some source language (or programming language) to
    machine language (object code).  Some compilers output
    assembly language which is then converted to {machine
    language} by a separate assembler.
 
    A compiler is distinguished from an assembler by the fact that
    each input statement does not, in general, correspond to a
    single machine instruction or fixed sequence of instructions.
    A compiler may support such features as automatic allocation
    of variables, arbitrary arithmetic expressions, control
    structures such as FOR and WHILE loops, variable scope,
    input/ouput operations, higher-order functions and
    portability of source code.
 
    AUTOCODER, written in 1952, was possibly the first primitive
    compiler.  Laning and Zierler's compiler, written in
    1953-1954, was possibly the first true working algebraic
    compiler.
 
    See also byte-code compiler, native compiler, {optimising
    compiler}.
 
    (1994-11-07)
  | 
compiler and generalized translator (foldoc) | COmpiler and GENeralized Translator
 COGENT
 
     (COGENT) A compiler writing language with
    pattern-directed string and list processing features, for {CDC
    3600} and CDC 3800.  A COGENT program consists of
    productions defining a context-free language, plus
    analysis and synthesis function generators.
 
    ["COGENT Programming Manual", J.C. Reynolds, ANL-7022, Argonne,
    Mar 1965].
 
    [Sammet 1969, p.638].
 
    ["An Introduction to the COGENT System", J.C. Reynolds, Proc
    ACM 20th Natl Conf, 1965].
 
    (1994-12-23)
  | 
compiler compiler (foldoc) | compiler-compiler
 compiler compiler
 
    A utility to generate the source code of a parser,
    interpreter or compiler from an annotated language
    description (usually in BNF).  Most so called
    compiler-compilers are really just parser generators.
 
    Examples are Bison, Eli, FSL, META 5, MUG2,
    Parsley, Pre-cc, Yacc.
 
    (1995-01-23)
  | 
compiler jock (foldoc) | compiler jock
 
    A programmer who specialises in writing compilers.
 
    [Jargon File]
 
    (1995-01-19)
  | 
compiler language for information processing (foldoc) | Compiler Language for Information Processing
 
    (CLIP) A language written in 1958-1959, based on IAL, which
    led to JOVIAL.  CLIP was one of the first languages used to
    write its own compiler.
 
    [Sammet 1969, p. 635].
 
    (1994-12-12)
  | 
compiler target language (foldoc) | Compiler Target Language
 
    (CTL) The intermediate language used by the ALICE parallel
    machine.
 
    ["The Design and Implementation of ALICE: A Parallel Graph
    Reduction Machine", M.D. Cripps et al, Proc Workshop on Graph
    Reduction, Springer 1987].
 
    (1994-11-14)
  | 
compiler-compiler (foldoc) | Compiler-Compiler
 
    An early compiler generator for the Atlas, with its own
    distinctive input language.
 
    ["The Compiler-Compiler", R.A. Brooker et al, Ann Rev
    Automatic Programming 3:229-275, Pergamon 1963].
 
    (1994-10-24)
 compiler-compiler
 compiler compiler
 
    A utility to generate the source code of a parser,
    interpreter or compiler from an annotated language
    description (usually in BNF).  Most so called
    compiler-compilers are really just parser generators.
 
    Examples are Bison, Eli, FSL, META 5, MUG2,
    Parsley, Pre-cc, Yacc.
 
    (1995-01-23)
  | 
computer compiler (foldoc) | Computer Compiler
 
    1.  A proposed language for compiler design.
 
    [Sammet 1969, p. 695].
 
    2. A discussion of various applications of computers to the
    design and production of computers.
 
    {ACM
    
 (http://dl.acm.org/citation.cfm?id=1464213&CFID=83216609&CFTOKEN=42516197)}.
 
    ["A proposal for a computer compiler", Gernot Metze
    (University of Illinois), Sundaram Seshu (University of
    Illinois), AFIPS '66 (Spring) Proceedings of the 1966-04-26 -
    28, Spring joint computer conference].
 
    (2007-02-13)
  | 
cornell compiler (foldoc) | CORnell Compiler
 CORC
 
     (CORC) A simple programming language for student maths
 problems.
 
    ["The Cornell Computing Language", R.W. Conway et al, CACM
 6(6):317-320, Jun 1963, Sammet 1969, p.294-296].
 
    (2023-03-05)
  | 
cross-compiler (foldoc) | cross-compiler
 
     A compiler which runs on one platform and
    produces code for another, as opposed to a native code
    compiler which produces code for the platform on which it
    runs.
 
    (1998-02-24)
  | 
dow compiler (foldoc) | DOW COMPILER
 
    An early system on the Datatron 200 series.
 
    [Listed in CACM 2(5):16 (May 1959)].
 
    (1994-12-07)
  | 
eli compiler construction system (foldoc) | Eli Compiler Construction System
 
     A compiler generation package which integrates
    off-the-shelf tools and libraries with specialised language
    processors to generate complete compilers quickly and
    reliably.  It simplifies the development of new
    special-purpose languages, implementation of existing
    languages on new hardware and extension of the constructs and
    features of existing languages.
 
    It runs on Sun-4 SunOS 4, 5, Ultrix/MIPS, RS/6000,
    HP-UX, SGI, Linux.
 
    Colorado U (ftp://ftp.cs.colorado.edu/pub/cs/distribs/eli/).
    Europe (ftp://ftp.upb.de/unix/eli).
 
    Mailing list: .
 
    E-mail: , Developers
    , Users .
 
    (2000-08-12)
  | 
extendible compiler (foldoc) | ExTendible Compiler
 ETC
 
     (ETC) A Fortran-like compiler that can be
    extended with macros.
 
    ["ETC - An Extendible Macro-Based Compiler", B.N. Dickman,
    Proc SJCC 38 1971].
 
    (2010-01-28)
  | 
glasgow haskell compiler (foldoc) | Glasgow Haskell Compiler
 
     (GHC) A Haskell 1.2 compiler written in Haskell
    by the AQUA project at Glasgow University, headed by Simon
    Peyton Jones  throughout the 1990's
    [started?].  GHC can generate either C or native code for
    SPARC, DEC Alpha and other platforms.  It can take
    advantage of features of gcc such as global register
    variables and has an extensive set of optimisations.
 
    GHC features an extensible I/O system based on a "monad",
    in-line C code, fully fledged unboxed data types,
    incrementally-updatable arrays, mutable reference types,
    generational garbage collector, concurrent threads.
    Time and space profiling is also supported.
 
    It requires GNU gcc 2.1+ and Perl.
 
    GHC runs on Sun-4, DEC Alpha, Sun-3, NeXT, DECstation,
    HP-PA and SGI.
 
    {Glasgow FTP
    (ftp://ftp.dcs.glasgow.ac.uk/pub/haskell/glasgow/)}.  {Yale
    (ftp://nebula.cs.yale.edu/pub/haskell/glasgow/)}.  {Sweden
    (ftp://ftp.cs.chalmers.se/pub/haskell/glasgow/)}.
 
    Papers (ftp://ftp.dcs.glasgow.ac.uk/pub/glasgow-fp).
 
    ["Imperative functional programming", Peyton Jones & Wadler,
    POPL '93].
 
    ["Unboxed data types as first-class citizens", Peyton Jones &
    Launchbury, FPCA '91].
 
    ["Profiling lazy functional languages", Sansom & Peyton Jones,
    Glasgow workshop '92].
 
    ["Implementing lazy functional languages on stock hardware",
    Peyton Jones, Journal of Functional Programming, Apr 1992].
 
    E-mail: .
 
    (1999-01-05)
  | 
gmd toolbox for compiler construction (foldoc) | GMD Toolbox for Compiler Construction
 Cocktail
 
    (Or Cocktail) A huge set of compiler building tools for
    MS-DOS, Unix and OS/2.
 
    parser generator (LALR -> C, Modula-2), documentation, parser
    generator (LL(1) -> C, Modula-2), tests, scanner generator (->
    C, Modula-2), tests translator (Extended BNF -> BNF),
    translator (Modula-2 -> C), translator (BNF (yacc) -> Extended
    BNF), examples abstract syntax tree generator,
    attribute-evaluator generator, code generator
 
    The MS-DOS version requires DJ Delorie's DOS extender
    (go32) and the OS/2 version requires the emx programming
    environment.
 
    (ftp://ftp.karlsruhe.gmd.de/pub/cocktail/dos).  {OS/2 FTP
    (ftp://ftp.eb.ele.tue.nl/pub/src/cocktail/dos-os2.zoo)}.
 
    Mailing list: listserv@eb.ele.tue.nl (subscribe to Cocktail).
    E-mail: Josef Grosch , Willem Jan
    Withagen  (OS/2).
 
    (1992-01-01)
  | 
honeywell-800 business compiler (foldoc) | Fully Automated Compiling Technique
 FACT
 Honeywell-800 Business Compiler
 
     (FACT, "Honeywell-800 Business
    Compiler") A pre-COBOL English-like business {data
    processing} language for the Honeywell 800, developed
    ca. 1959.
 
    [Sammet 1969, p. 327].
 
    (1994-12-01)
  | 
mathematics in recognizable form automatically compiled (foldoc) | Mathematics in Recognizable Form Automatically Compiled
 MIRFAC
 
     (MIRFAC) An early interactive system resembling
    BASIC using typewriter output with special mathematical
    symbols.
 
    [Sammet 1969, pp. 281-284].
 
    (1997-08-01)
  | 
matrix compiler (foldoc) | Matrix Compiler
 
    Early matrix computations on UNIVAC.  Sammet 1969, p.642.
  | 
native compiler (foldoc) | native compiler
 
     A compiler which runs on the computer
    for which it is producing machine code, in contrast to a
    cross-compiler, which produces code for a different
    computer.
 
    (1995-11-04)
  | 
norc compiler (foldoc) | NORC COMPILER
 
    Early system on NORC machine.  Listed in CACM 2(5):16 (May
    1959).
  | 
optimising compiler (foldoc) | optimising compiler
 
     compiler which attempts to analyse the
    code it produces and to produce more efficient code by
    performing program transformation such as {branch
    elimination}, partial evaluation, or {peep-hole
    optimisation}.
 
    Contrast pessimising compiler.
 
    (1995-02-01)
  | 
pessimising compiler (foldoc) | pessimising compiler
 
    /pes'*-mi:z"ing k*m-pi:l"r/ (Antonym of "{optimising
    compiler}") A compiler that produces object code that is
    worse than the straightforward or obvious hand translation.
    The implication is that the compiler is actually trying to
    optimise the program, but through excessive cleverness is
    doing the opposite.  A few pessimizing compilers have been
    written on purpose, however, as pranks or burlesques.
 
    (1995-02-01)
  | 
purdue compiler-construction tool set (foldoc) | Purdue Compiler-Construction Tool Set
 PCCTS
 
     (PCCTS) A highly integrated lexical analser generator
    and parser generator by Terence J. Parr ,
    Will E. Cohen and Henry G. Dietz , both
    of Purdue University.
 
    ANTLR (ANother Tool for Language Recognition) corresponds to
    YACC and DLG (DFA-based Lexical analyser Generator) functions
    like LEX.  PCCTS has many additional features which make it
    easier to use for a wide range of translation problems.  PCCTS
    grammars contain specifications for lexical and syntactic
    analysis with selective backtracking ("infinite lookahead"),
    semantic predicates, intermediate-form construction and
    error reporting.  Rules may employ Extended BNF (EBNF)
    grammar constructs and may define parameters, return values,
    and have local variables.
 
    Languages described in PCCTS are recognised via LLk parsers
    constructed in pure, human-readable, C code.  Selective
    backtracking is available to handle non-LL(k) constructs.
    PCCTS parsers may be compiled with a C++ compiler.  PCCTS
    also includes the SORCERER tree parser generator.
 
    (ftp://marvin.ecn.purdue.edu/pub/pccts/1.10).
 
    {UK FTP (ftp://src.doc.ic.ac.uk/
    computing/programming/languages/tools/pccts/)}.  {Macintosh
    FTP (ftp://maya.dei.unipd.it/pub/mac/)}.
 
    Mailing list: pccts-users-request@ahpcrc.umn.edu ("subscribe
    pccts-users your_name" in the message body).
 
    E-mail: Terence J. Parr , Roberto Avanzi
     (Mac port).
 
    (2000-10-30)
  | 
string oriented interactive compiler (foldoc) | STring Oriented Interactive Compiler
 STOIC
 
     (STOIC) A language from the Smithsonian
    Astrophysical Observatory.  STOIC is similar to FORTH for
    strings and includes many VAX-specific items.
 
    (1998-09-27)
  | 
twente compiler generator system (foldoc) | Twente Compiler Generator System
 TCGS
 
     (TCGS) A compiler generator developed at
    the University of Twente, The Netherlands.
 
    (1998-04-27)
  | 
yet another compiler compiler (foldoc) | Yet Another Compiler Compiler
 yacc
 
     (yacc) The LALR parser generator found on
    most Unix systems.  Also, the language used to describe the
    syntax of another language to yacc (the program).
 
    Implementations: ayacc, YAY, perln-byacc,
 
    SASL-Yacc - "Yacc in SASL - An Exercise in Functional
    Programming", Simon Peyton-Jones, Software Prac & Exp
    15:807-820 (1985).  Mentions also a BCPL implementation.
 
    Yacc++ - 1990.  An object-oriented rewrite of yacc, supports
    regular expressions, produces an LR1 grammar parser.
 
    ["YACC Meets C++", S.C. Johnson, USENIX Spring '88 Conf].
 
    Chris Clark, Compiler Resources Inc, +1 (508) 435-5016.
 
    MLYACC - Implementation and output in SML/NJ.
    (ftp:research.att.com/dist/ml/75.tools.tar.Z).
 
    A version, by David Poole at Montana University has been
    retargeted to Turbo Pascal.
 
    (ftp://iecc.com/pub/file/lyprg.zip).
 
    See also Bison, yet another, Yet Another Yacc.
 
    Unix manual page: yacc(1).
 
    ["YACC - Yet Another Compiler Compiler", S.C. Johnson, CS TR
    32, Bell Labs (Jul 1975)].
 
    [Was there ever an "ACC" - "Another Compiler Compiler"?  If
    so, what was the first compiler compiler called?]
 
    (2000-11-15)
  | 
compiler jock (jargon) | compiler jock
  n.
 
     See jock (sense 2).
  | 
pessimizing compiler (jargon) | pessimizing compiler
  /pes'@·mi:z`ing k@m·pi:l'r/, n.
 
     [antonym of techspeak ‘optimizing compiler’] A compiler that produces
     object code that is worse than the straightforward or obvious hand
     translation. The implication is that the compiler is actually trying to
     optimize the program, but through excessive cleverness is doing the
     opposite. A few pessimizing compilers have been written on purpose,
     however, as pranks or burlesques.
  | 
recompile the world (jargon) | recompile the world
 
 
     The surprisingly large amount of work that needs to be done as the result
     of any small but globally visible program change. “The world” may mean the
     entirety of some huge program, or may in theory refer to every program of a
     certain class in the entire known universe. For instance, “Add one #define
     to stdio.h, and you have to recompile the world.” This means that any minor
     change to the standard-I/O header file theoretically mandates recompiling
     every C program in existence, even if only to verify that the change didn't
     screw something else up. In practice, you may not actually have to
     recompile the world, but the implication is that some human cleverness is
     required to figure out what parts can be safely left out.
  |