
	Where results make sense

Topic: Byte compiled

	GNU Emacs Lisp Reference Manual - Byte Compilation
		See section Debugging Problems in Compilation, for how to investigate errors occurring in byte compilation.
		Eval During Compile: Code to be evaluated when you compile.
		One way to ensure that necessary macro definitions are available during compilation is to require the file that defines them.
	www.math.utah.edu /docs/info/elisp_15.html (1873 words)

	XEmacs Lisp Reference Manual: Byte Compilation
		The byte compiler is a relatively recent development, and has evolved significantly over the period covering Emacs versions 19 and 20.
		While almost all of the byte codes are the same, and code compiled by one version often runs perfectly well on the other, this is very dangerous, and can result in crashes or data loss.
		The intent is that compiled byte-code and the corresponding code executed by the Lisp interpreter produce identical results.
	www.xemacs.org /Documentation/21.5/html/lispref_22.html (3655 words)

	XEmacs User's Manual - Compiling Libraries
		Emacs Lisp code can be compiled into byte-code which loads faster, takes up less space when loaded, and executes faster.
		To compile and evaluate Lisp code in a given buffer, use
		When you use this function, the files to be compiled are specified with command-line arguments.
	www.tau.ac.il /cc/pages/docs/xemacs/xemacs_200.html (266 words)

	GNU Emacs Lisp Reference Manual - Byte Compilation
		Files compiled in versions before 19.29 may not work in 19.29 if they contain character constants with modifier bits, because the bits were renumbered in Emacs 19.29.
		One way to ensure that necessary macro definitions are available during compilation is to require the file that defines them (see section Features).
		If you compile a new version of the file, the best thing to do is immediately load the new compiled file.
	www.csupomona.edu /reference/gnu/elisp-manual-19-2.4/elisp_15.html (2504 words)

	GNU Emacs Lisp Reference Manual: Byte Compilation
		Compiling a Lisp file with the Emacs byte compiler always reads the file as multibyte text, even if Emacs was started with
		If a program does not work the same way when compiled as it does when interpreted, erroneous macro definitions are one likely cause (see section 13.6 Common Problems Using Macros).
		One way to ensure that necessary macro definitions are available during compilation is to require the file that defines them (see section 15.6 Features).
	jamesthornton.com /gnu/elisp-manual/elisp_16.html (2641 words)

	GNU Emacs Lisp Reference Manual - Compilation Functions
		Macro calls are expanded when they are compiled, so the macros must already be defined for proper compilation.
		One way to ensure that necessary macro definitions are available during compilation is to require the file that defines them.
		Other forms are batched together, then each batch is compiled, and written so that its compiled code will be executed when the file is read.
	www.tac.nyc.ny.us /manuals/elisp/elisp_168.html (550 words)

	Native compilation of Emacs byte-code
		Byte code functions are compiled at run-time, either before or after dumping of the Emacs binary.
		The native compilation additions presented here may be useful for investigating the rest (compilation of byte-code functions all the way to subrs), although the TODO entry has since been removed.
		A speedup over byte code is available, but in most cases it will be over-shadowed by the time spent in the primitive functions (the pre-compiled functions, which are written in C).
	www.mundell.ukfsn.org /native (313 words)

	Compilation Functions
		One way to ensure that necessary macro definitions are available during compilation is to require the file that defines them (see Named Features).
		If you use this on a defun that is actually a function definition, the effect is to install a compiled version of that function.
		Only the byte compiler knows how to generate valid calls to this function.
	www.cse.unsw.edu.au /help/doc/info/elisp/Compilation_Functions.html (545 words)

	Dr. Dobb's \| Endian-Neutral Software, Part 1 \| July 22, 2001
		Byte values or single-byte character data do not have Endianness because the smallest addressable unit of memory is one byte; consequently, byte order is not an issue.
		For BE, the byte address of each byte value is the same in (a), (b), and (c) of Figure 5; for LE, the byte addresses are all different for the same byte value.
		For code that is compiled to execute on the PowerPC in LE mode, the compiler should generate as much aligned data and instructions as possible to minimize the alignment interrupts.
	www.ddj.com /184409326?pgno=23 (3374 words)

	interpreter from FOLDOC (Site not responding. Last check: 2007-10-21)
		This is in contrast to a compiler which does not execute its input program (the "source code") but translates it into executable "machine code" (also called "object code") which is output to a file for later execution.
		For example Emacs Lisp is compiled to "byte-code" which is a highly compressed and optimised representation of the Lisp source but is not machine code (and therefore not tied to any particular hardware).
		The compiled code in this case is machine code for a virtual machine which is implemented not in hardware but in the byte-code interpreter.
	foldoc.org /?interpreter (436 words)

	[No title]
		That is, Python source code is compiled by the 'python' command to byte-code in exactly the same manner as before (except for a couple 'import' statements and function calls added to invoke Psyco).
		In the first place, Psyco compiles operations to somewhat opitimized machine code; in itself this produces only slight improvements, since what the machine code needs to accomplish is the same as what Python's dispatched functions do.
		One upshot that was hoped for in the project was compilation to the same machine code OCaml generates, which is generally comparable with the speed of C. Unfortunately, Vyper is a dead project, and a compiling version was never completed.
	gnosis.cx /publish/programming/charming_python_b9.txt (2797 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		When `require' is used at top level in a file, it takes effect when you byte-compile that file (note Byte* Compilation::.) as well as when you load it.
		Although top-level calls to `require' are evaluated during byte compilation, `provide' calls are not.
		Compiling a Lisp file with the Emacs byte compiler always reads the file as multibyte text, even if Emacs was started with `--unibyte', unless the file specifies otherwise.
	osiris.sunderland.ac.uk /~cs0pdu/pub/info/elisp-12 (6430 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		When this option is true, if you load the compiled file and then move it, the functions you loaded will not be able to run.") (defvar byte-compile-dynamic-docstrings t "If non-nil, compile* doc strings for lazy access.
		When this option is true, if you load the compiled file and then move it, you won't be able to find the documentation of anything in that file.
		If it is 'byte, then only byte-level optimizations will be logged.") (defvar byte-compile-error-on-warn nil "If true, the byte-compiler reports warnings with `error'.") (defconst byte-compile-warning-types '(redefine callargs free-vars unresolved obsolete)) (defvar byte-compile-warnings t "List of warnings that the byte-compiler should issue (t for all).
	www.ibiblio.org /pub/historic-linux/distributions/redhat/4.1/i386/live/usr/share/emacs/19.34/lisp/bytecomp.el (5800 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		One way to ensure that necessary macro definitions are available during compilation is to require the file that defines them (*note Named Features::.).
		The function definition of SYMBOL must be the actual code for the function; i.e., the compiler does not follow indirection to another symbol.
		The byte compiler uses the dynamic function loading feature if the variable `byte-compile-dynamic' is non-`nil' at compilation time.
	www.math.psu.edu /local_doc/info/elisp-11 (6602 words)

	Data processing system and method for managing memory of an interpretive system - Patent 6862650
		In interpreted languages, a compiler typically generates byte-codes to be used by a programming virtual machine, rather than native machine code, to provide control and data necessary to execute an application.
		Therefore, heaps for storing the compiled code tend to grow larger until the memory space allocated for the heap is exceeded in current Java applications that implement JIT compilation.
		When the code is compiled into actual native code, the native code may execute directly within operating system 302 and is not required to run through an interpreted programming device, such as JVM 310.
	www.freepatentsonline.com /6862650.html (6302 words)

	Parrot - Perl's new Virtual Machine
		Compiled languages are fast to run, and interprettive languages are simpler to develop.
		The virtual machine is runs after the compiler; it takes the machine code output from the compiler, and interprets and runs that machine code.
		In the Perl model (up to and including release 5 of Perl), the compiler and interpretter are built into the same program ("perl"), and when you run perl on a text file the file in interpretted into "byte code" (Larry's name for the intermediate compiler output) which is the passed straight on into the interpretter.
	www.wellho.net /solutions/perl-parrot-perl-s-new-virtual-machine.html (1696 words)

	Package-XSLTVM (Site not responding. Last check: 2007-10-21)
		A concept of virtual machine assumes a compiler compiling XSLT stylesheets to a sequence of byte codes or machine instructions for the "XSLT CPU".
		The generated bytecode resides in a compiler buffer which is freed when next stylesheet is compiled or when compiler object is deleted.
		The XSLT compiler is used to compile XSLT stylesheets into bytecode.
	www.oracle.com /technology/docs/tech/xml/xdk/doc_library/beta/doc/c/parser/package-xsltvm.html (1339 words)

	[No title]
		When `byte-compile-emacs19-compatibility' is non-nil, this variable is ignored and considered to be nil.") (defvar byte-optimize t "Enables optimization in the byte* compiler.
		When this option is true, if you load the compiled file and then move it, the functions you loaded will not be able to run.") (defvar byte-compile-dynamic-docstrings (emacs-version>= 20) "If non-nil, compile* doc strings for lazy access.
		Changing the byte ;; interpreter to deal with these args would be wrong and cause ;; incompatibility, so we generate non-inlined calls for those cases.
	www.umanitoba.ca /campus/acn/unix/software/vendor_html/workshop/contrib/xemacs-21.4.12/lib/xemacs-21.4.12/lisp/bytecomp.el (7357 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		My solution is a representational model for describing performance data from interpreted, just-in-time compiled, and dynamically compiled executions that solves problems associated with these two characteristics.
		The model allows for a concrete description of behaviors in interpreted, JIT compiled and dynamically compiled exectutions, and it is a reference point for what is needed to implement a performance tool for measuring these types of executions.
		To demonstrate the model, I built a prototype implementation of a performance tool for measuring interpreted and dynamically compiled Java executions called Paradyn-J. Paradyn-J dynamically inserts instrumentation into the Java VM and into Java application byte-code and native code as the Java application is run by the VM.
	www.cs.swarthmore.edu /~newhall/perf.html (360 words)

	[No title]
		;;; The native compiler will convert this throw into whatever is necessary ;;; to throw, so we don't have to duplicate all that cruft.
		If the byte interpreter exits, ;;; it must have been because of a BREAKUP (see below), so we branch (by ;;; tail-calling the byte interpreter) to the pc returned by BREAKUP.
		There are no values to ;;; pass, so we don't have to mess with them, and multiple exits can all be ;;; using the same tag so we have to pass the pc we want to go to.
	www.cs.cmu.edu /afs/cs.cmu.edu/project/clisp/OldFiles/src/exp/struct/code/byte-interp.lisp (1645 words)

	Programming in Emacs Lisp
		One other aspect of interpreting: the Lisp interpreter is able to interpret two kinds of entity: humanly readable code, on which we will focus exclusively, and specially processed code, called byte compiled code, which is not humanly readable.
		Byte compiled code runs faster than humanly readable code.
		Byte compiled code is usually stored in a file that ends with a
	www.delorie.com /gnu/docs/emacs-lisp-intro/emacs-lisp-intro_19.html (165 words)

	Re: Is guile byte-code compiled?
		Granted, byte compilation isn't really that of a big goal if you can compile to native code, though there might be advantages when you can define your own VM instruction set.
		Traditionally in CL systems, compile took a symbol as an argument and compiled the function in that symbols function space.
		All in all i consider the multiple-dispatch-evaluator and on-demand compilation to be the best solution for both a good Scheme implementation and a scripting language.
	www.cygwin.com /ml/guile/1999-05/msg00189.html (465 words)

	Chapter 4 The Java Virtual Machine
		Bytes four and five of a.class file (the two bytes immediately following CAFEBABE) are the minor version of the compiler that produced this file.
		The first two bytes of this part of the file are an unsigned short specifying the number of entries in the constant pool.
		Although it is illegal to copy the byte code verbatim and paste it into your own files, it is perfectly legal to rewrite and recompile the algorithm.
	www.geocities.com /lowaa2000/java1.htm (10465 words)

	Python Servlet Engine (Site not responding. Last check: 2007-10-21)
		Since it only executes byte compiled Python, there is no need for parsing the files on each request, as with PHP or other web application servers.
		It is also compiled and stored in the same way that Python itself compiles and stores modules.
		This way users of the application will never have to experience a delay due to parsing and compiling of any files, and you can distribute only optimized byte compiled files to protect your intellectual property in the source code.
	nick.borko.org /pse/works.html (245 words)

	The GCJ FAQ - GNU Project - Free Software Foundation (FSF)
		I have just compiled and benchmarked my Java application and it seems to be running slower than than XXX JIT JVM.
		It works pretty transparently: if a compiled version of a class is not found in the application binary or linked shared libraries, the class loader will search for a bytecode version in your classpath, much like a VM would.
		The reason is that when you compile to bytecode you lose a lot of information about program structure etc. That information helps in generating better code.
	www.gnu.org /software/gcc/java/faq.html (2468 words)

	Development Tools
		While the actual process of building the intermediate layer is the work of a compiler, and the execution itself is done by the Java Virtual Machine through.class files, there is often a need to inspect and even modify the compiled byte code for purposes of optimization or run-time analysis.
		One of the main benefits of using a tool like BCEL for modifying or inspecting Java byte code is that cryptic knowledge like that of.class file structures or binary format is not a necessity, given that it is these low-level concepts that BCEL tries to abstract away from a developer through its high-level API.
		Our main method is used to read the input provided at run time, and searches for a byte code file in every directory defined in the CLASSPATH environment variable.
	tools.devchannel.org /print.pl?sid=04/07/08/1935232 (694 words)

	Byte-compilation of Scheme using Java byte-codes (Site not responding. Last check: 2007-10-21)
		Mutual tail-calls among multiple functions compiled together can be handled by compiling all the functions in one big procedure, and and starting it with a switch operation to jump to the code for the desired function.
		Jeffrey Mark Siskind is working on a highly optimizing compiler to translate Scheme to C. It could possibly be re-targeted to emit Java byte-codes.
		Also, William Clinger has expressed plans to re-target his Twobit optimizing compiler to emit Java byte-codes, and he believes it should be easy to do.
	www.delorie.com /gnu/docs/kawa/scm2java.html (1911 words)

	ByteLoader - load byte compiled perl code (Site not responding. Last check: 2007-10-21)
		This module is used to load byte compiled perl code as produced by
		It uses the source filter mechanism to read the byte code and insert it into the compiled code at the appropriate point.
		Tom Hughes based on the ideas of Tim Bunce and others.
	theory.uwinnipeg.ca /CPAN/perl/lib/ByteLoader.html (55 words)

	BYTE.com
		Heading the team is John Backus, who goes on to contribute to the development of ALGOL and the well-known syntax-specification system known as BNF.
		In 1983, the Department of Defense directs that all new "mission-critical" applications be written in Ada.
		BYTE Digest editors every month analyze and evaluate the best articles from Information Week, EE Times, Dr.
	www.byte.com /art/9509/sec7/art19.htm (1292 words)

	User-Code File Converter / Compiler / De-compiler / Bar-Code Generator
		The file converter is used to "package" compiled user-code putting a suitable "wrapper" around it.
		This is done preceding the code with a "header", appending a valid "checksum", and adding "filler" (don't care) bytes to satisfy file size requirements.
		The de-compiler takes compiled user-code, packaged in any of the supported formats, and creates a text file that can be edited or printed out.
	www.hpmuseum.org /software/41uc.htm (2471 words)

Try your search on: Qwika (all wikis)