Include a file: Difference between revisions

Demonstrate the language's ability to include source code from other files.

<br><br>

 

=={{header|360 Assembly}}==

The COPY instruction includes source statements from the SYSLIB library.

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

'file constant include : includeConstantesARM64.inc'

/*******************************************/

.include "../includeARM64.inc"

 

 

=={{header|ACL2}}==

 

For files containing only events (definitions and similar; no top-level function calls) which are admissible (note the lack of file extension):

For all other files:

 

=={{header|Ada}}==

Some remarks are necessary here.

Ada does not define how the source code is stored in files. The language rather talks about compilation units. A compilation unit "imports" another compilation unit by using context clauses - these have the syntax "with CU1, CU2, ...;". All compilers I know of require in their standard mode exactly one compilation unit per file; also file naming conventions vary. However GNAT e.g. has a mode that can deal with files holding several compilation units and any file name conventions.

-- the with-clause tells the compiler to include the Text_IO package from the Ada standard

-- and Another_Package. Subprograms from these packages may be called as follows:

-- Another_Package.Do_Something("some text");

-- The use-clause allows the program author to write a subprogram call shortly as

 

=={{header|ALGOL 68}}==

==={{header|ALGOL 68G}}===

In the simplest case a file can be included as follows:

 

But in the Algol68 formal reports - it appears - the intention was to have a more structure approach.

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.7 algol68g-2.7].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

BEGIN

# Exception setup code: #

on value error(stand out, (REF FILE f)BOOL: GOTO value error not mended);

# Block setup code: #

# Block teardown code: #

printf(($"Postlude test."l$))

# Exception code: #

value error not mended: SKIP

# -*- coding: utf-8 -*- #

 

PR read "prelude/test.a68" PR;

printf($4x"Hello, world!"l$);

{{out}}

<pre>

''' Example of <code>ENVIRON</code> clause '''<br>

A file called ''mylib.a68'':

INT dim = 3; # a constant #

INT a number := 120; # a variable #

a number := ENVIRON EXAMPLE2;

print((a number))

 

''' Example of <code>USING</code> clause '''<br>

A file called ''usemylib.a68'':

BEGIN

MATRIX m2; # example only #

ENVIRON EXAMPLE3; # ENVIRONs can be nested #

666

 

=={{header|AntLang}}==

AntLang is made for interactive programming, but a way to load files exists.

Even if it is really primitive, i. e. file get's current environment and manipulates it.

 

=={{header|Applesoft BASIC}}==

Chain PROGRAM TWO to PROGRAM ONE. First create and save PROGRAM TWO. Then, create PROGRAM ONE and run it. PROGRAM ONE runs and then "includes" PROGRAM TWO which is loaded and run using the Binary program CHAIN from the DOS 3.3 System Master. Variables from PROGRAM ONE are not cleared so they can be used in PROGRAM TWO. User defined functions should be redefined in PROGRAM TWO. See "Applesoft: CHAIN and user-defined functions Issues" http://support.apple.com/kb/TA41069

 

20 DEF FN A(X) = X * Y

30 PRINT FN A(2)

 

20 Y = 6

30 DEF FN A(X) = X * Y

 

SAVE PROGRAM ONE

 

{{out}}

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

'file constantes.inc'

/************************************/

.include "./affichage.inc"

 

 

=={{header|AutoHotkey}}==

#Include FileOrDirName

#IncludeAgain FileOrDirName

 

=={{header|AWK}}==

The awk extraction and reporting language does not support the use of include files. However, it is possible to provide the name of more than one source file at the command line:

 

 

The functions defined in different source files will be visible from other scripts called from the same command line:

 

BEGIN {

sayhello()

function sayhello() {

print "Hello world"

 

However, it is not permissible to pass the name of additional source files through a hashbang line, so the following will will not work:

GNU Awk has an <code>@include</code> which can include another awk source file at that point in the code.

 

 

This is a parser-level construct and so must be a literal filename, not a variable or expression. If the filename is not absolute then it's sought in an <code>$AWKPATH</code> list of directories. See [http://www.gnu.org/software/gawk/manual/html_node/Include-Files.html the gawk manual] for more.

=={{header|Axe}}==

This will cause the program called OTHER to be parsed as if it was contained in the source code instead of this line.

 

=={{header|BaCon}}==

''other.bac''

''including.bac''

INCLUDE "other.bac"

 

{{out}}

Note that this will ''not'' work under QBasic.

 

 

See also: [[#BBC BASIC|BBC BASIC]], [[#Gambas|Gambas]], [[#IWBASIC|IWBASIC]], [[#PowerBASIC|PowerBASIC]], [[#PureBasic|PureBasic]], [[#Run BASIC|Run BASIC]], [[#ZX Spectrum Basic|ZX Spectrum Basic]]

 

=={{header|Batch File}}==

call file2.bat

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

The file is loaded into memory at run-time, executed, and then discarded. It must be in 'tokenised' (internal) .BBC format.

 

=={{header|Bracmat}}==

 

=={{header|C}} / {{header|C++}}==

In C and C++, inclusion of other files is achieved via a preprocessor. The <code>#include</code> preprocessor directive tells the compiler to incorporate code from the included file. This is normally used near the top of a source file and is usually used to tell the compiler to include header files for the function libraries.

 

#include <stdlib.h>

 

/* User/in-project header names are usually enclosed between double-quotes */

 

Although it is often conventional and idiomatic for a project to use its own headers in the style described on the second line above, it's also possible to tell most compilers using various flags (e. g. GCC and Clang accept <tt>-I</tt>) to treat an arbitrary directory as a system/library include folder, thereby allowing any contained files to be included using the angle bracket syntax.

 

=={{header|C sharp}}==

* likely because there is no need - all code compiled within one 'assembly' (individual IDE projects

* are usually compiled to separate assemblies) can 'see' all other code within that assembly.

 

=={{header|ChucK}}==

 

=={{header|Clipper}}==

The inclusion of other files is achieved via a preprocessor. The <code>#include</code> preprocessor directive tells the compiler to incorporate code from the included file. This is normally used near the top of a source file and is usually used to tell the compiler to include header files for the function libraries.

 

=={{header|Clojure}}==

Just as in Common Lisp:

 

This would rarely be used for loading code though, since Clojure supports modularisation (like most modern languages) through [http://blog.8thlight.com/colin-jones/2010/12/05/clojure-libs-and-namespaces-require-use-import-and-ns.html namespaces] and code is typically located/loaded via related abstractions. It's probably more often used to load data or used for quick-and-dirty experiments in the [https://en.wikipedia.org/wiki/Read–eval–print_loop REPL].

=={{header|COBOL}}==

In COBOL, code is included from other files by the <code>COPY</code> statement. The files are called copybooks, normally end with the file extension '.cpy' and may contain ''any'' valid COBOL syntax. The <code>COPY</code> statement takes an optional <code>REPLACING</code> clause allows any text within the copybook to be replaced with something else.

COPY "another-copy.cpy" REPLACING foo BY bar

SPACE BY ZERO

 

=={{header|Common Lisp}}==

 

=={{header|Crystal}}==

 

=={{header|D}}==

D has a module system, so usually there is no need of a textual inclusion of a text file:

 

To perform a textual inclusion:

 

=={{header|Delphi}}==

 

{$Include Common} // Inserts the contents of Common.pas into the current unit

 

=={{header|Dragon}}==

 

Just this would be enough.

showln "hello"

//this is program.dgn

 

include "program.dgn"

my() // output : hello

 

=={{header|DWScript}}==

 

In addition to straight inclusion, there is a filtered inclusion, in which the include file goes through a pre-processing filter.

{$INCLUDE Common} // Inserts the contents of Common.pas into the current unit

{$I Common} // Same as the previous line, but in a shorter form

{$FILTER Common} // Inserts the contents of Common.pas into the current unit after filtering

{$F Common} // Same as the previous line, but in a shorter form

 

=={{header|Déjà Vu}}==

!import!foo

 

#passing a file name (only works with compiled bytecode files):

 

=={{header|Emacs Lisp}}==

Write this code in: file1.el

(defun sum (ls)

(apply '+ ls) )

In the directory of file1.el, we write this new code in: file2.el

(add-to-list 'load-path "./")

(load "./file1.el")

(insert (format "%d" (sum (number-sequence 1 100) )))

<b>Output:</b>

<pre>

 

=={{header|Erlang}}==

-include("my_header.hrl"). % Includes the file at my_header.erl

 

=={{header|Euphoria}}==

include my_header.e

 

=={{header|Factor}}==

USING: vocaba vocabb... ;

 

=={{header|Forth}}==

 

Other Forth systems have a smarter word, which protects against multiple inclusion. The name varies: '''USES''', '''REQUIRE''', '''NEEDS'''.

 

=={{header|Fortran}}==

 

"The interpretation of char-literal-constant is processor dependent. An example of a possible valid interpretation is that char-literal-constant is the name of a file that contains the source text to be included."

=={{header|FreeBASIC}}==

File to be included :

Type Person

name As String

Operator Person.Cast() As String

Return "[" + This.name + ", " + Str(This.age) + "]"

 

Main file :

 

' main.bas file

Print

Print "Press any key to quit"

 

{{out}}

[Methuselah, 969]

</pre>

 

=={{header|Furryscript}}==

=={{header|FutureBasic}}==

FB has powerful tools to include files in a project. Its "include resources" statement allows you to specify any number of files for copying into the built application package's Contents/Resources/ directory.

include resources "SomeImage.png"

include resources "SomeMovie.mpeg"

include resources "SomeIcon.icns"

include resources "Info.plist" //Custom preference file to replace FB's generic app preferences

Including C or Objective-C headers (i.e. files with the .h extension) or source files (files with the .c or .m extension) requires a different 'include' syntax:

<pre>

 

Here a file is loaded into a variable

Dim sFile As String

 

 

End

 

=={{header|GAP}}==

 

=={{header|Gnuplot}}==

 

This is the same as done for each file named on the command line. Special filename <code>"-"</code> reads from standard input.

 

 

If the system has <code>popen</code> then piped output from another program can be loaded,

 

 

<code>call</code> is the same as <code>load</code> but takes parameters which are then available to the sub-script as <code>$0</code> through <code>$9</code>

 

 

=={{header|Go}}==

 

Instead one can simply give the other source code file(s) the same package name as the 'main' file, copy them to the same directory and build them all together. For example:

package main

 

hello()

hello2()

 

package main

 

func hello2() {

fmt.Println("Hello from main2.go")

 

{{out}}

=={{header|Harbour}}==

The inclusion of other files is achieved via a preprocessor. The <code>#include</code> preprocessor directive tells the compiler to incorporate code from the included file. This is normally used near the top of a source file and is usually used to tell the compiler to include header files for the function libraries.

 

=={{header|Haskell}}==

 

-- general, one will import a module, like so:

import SomeModule

-- Haskell Compiler runs the C preprocessor on source code, so #include may be

-- used:

 

=={{header|HTML}}==

Current HTML specifications do not provide an include tag, Currently, in order to include content from another file, it is necessary to include content via an iframe. However, this is not supported in some browsers and looks very untidy in other browsers:

 

 

There is an unofficial tag, but this will be ignored by most browsers:

 

 

=={{header|Icon}} and {{header|Unicon}}==

 

 

=={{header|IWBASIC}}==

 

Further, external library or object files can be specified with the $USE statement, which is a compiler preprocessor command:

 

 

IWBASIC also allows resources, files and data that are compiled with an application and embedded in the executable. However, resources in IWBASIC may be used only for projects, i.e., programs that have more than one source file.

Various resources are loaded as follows:

 

 

<code>ID</code> is either a numeric or string identifier to the resource, <code>TYPE</code> is a numeric or string type and it stores the info in variable. The standard Windows resource types can be specified and loaded in raw form using the following constants:

 

@RESBITMAP

@RESICON

@RESGROUPCURSOR

@RESGROUPICON

 

=={{header|J}}==

The usual approach for a file named 'myheader.ijs' would be:

 

 

However, this has "include once" semantics, and if the requirement is to include the file even if it has been included earlier you would instead use:

 

 

=={{header|Java}}==

 

Just this would be enough.

{

//code here

 

You could also consider creating an instance of Class2 within Class1, and then using the instance methods.

{

Class2 c2=new Class2();

c2.func2();

}

 

=={{header|JavaScript}}==

===Pure JavaScript in browsers with the DOM===

Following example, if loaded in an HTML file, loads the [http://jquery.com/ jQuery] library from a remote site

s.type = 'application/javascript';

 

// path to the desired file

s.src = 'http://code.jquery.com/jquery-1.6.2.js';

Most be noted that it can also request [[HTTP]] source and eval() the source

 

===With jQuery===

{{libheader|jQuery}}

 

===With AMD (require.js)===

 

===CommonJS style with node.js (or browserify)===

{{libheader|node.js}}

 

===ES6 Modules===

 

=={{header|jq}}==

 

'''Include_a_file.jq'''

 

 

'''gort.jq'''

 

{{ out }}

 

=={{header|Jsish}}==

''jsish'' can include other source via '''System.source('filename');'''. Versioned moduled can be included via '''System.require('module', version);'''. Methods in the ''System'' object are automatically exported as top level globals (and the module version argument defaults to 1), so those can be shortened to

 

 

Compiled code can also be included via '''System.load('shlib');''', but that feature requires a known named init function, Jsi_Init[shlib] to be an exported symbol in the Dynamic Shared Object file.

=={{header|Julia}}==

Julia's <code>include</code> function executes code from an arbitrary file:

or alternatively <code>include_string</code> executes code in a string as if it were a file (and can optionally accept a filename to use in error messages etcetera).

 

Julia also has a module system:

imports the content of the module <code>MyModule.jl</code> (which should be of the form <code>module MyModule ... end</code>, whose symbols can be accessed as <code>MyModule.variable</code>, or alternatively

will import the module and all of its exported symbols

 

 

For example:

 

We can now import and invoke this from code in the default package as follows:

 

 

import package1.f // import f from package `package1`

fun main(args: Array<String>) {

f() // invoke f without qualification

 

{{out}}

=={{header|LabVIEW}}==

In LabVIEW, any VI can be used as a "SubVI" by changing the icon and wiring the terminals to the front panel. This cannot be explained concisely in code; instead, see the [http://zone.ni.com/reference/en-XX/help/371361E-01/lvconcepts/creating_subvis/ documentation]. =={{header|LabVIEW}}==

 

=={{header|Lasso}}==

 

=={{header|Lingo}}==

 

fp = xtra("fileIO").new()

fp.openFile(_movie.path&"someinclude.ls", 1)

 

-- use it instantly in the current script (i.e. the script that contained the above include code)

 

=={{header|Logtalk}}==

:- object(foo).

 

 

:- end_object.

 

=={{header|Lua}}==

To include a header file myheader.lua:

 

 

=={{header|M2000 Interpreter}}==

Without use of New in Load we get any cached file with same name. Using load from M2000 command line we always load file, but from code interpreter use a cache to hold it for next load.

Document A$={

Module Global Beta {

\\ now Beta erased (after return form Checkit)

Print Module(Beta)=False

 

Running code of a module, as code is inline and not in that module. Now X is a variable in CheckIt

\\ we can delete global

Module Global alfa {

}

Checkit

 

=={{header|m4}}==

 

 

=={{header|Maple}}==

For textual inclusion, analogous to the C preprocessor, use the "$include" preprocessor directive. (The preprocessor is not a separate program, however.) This is frequently useful for large project development.

Or

It is also possible to read a file, using the "read" statement. This has rather different semantics.

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

 

 

=={{header|MATLAB}} / {{header|Octave}}==

New functions can be included, either by storing a new function in an existing path, or by extending the existing path to a new directory. When two functions have the same name, the function found first in the path takes precedence. The later is shown here:

 

path(path,newdir);

addpath(newdir,'-end'); % same as before

% add a new directory at the beginning

addpath(newdir);

 

=={{header|Maxima}}==

 

/* or if source.mac is in Maxima search path (see ??file_search_maxima), simply */

 

=={{header|Modula-2}}==

 

=={{header|Modula-3}}==

 

=={{header|Nanoquery}}==

 

=={{header|Nemerle}}==

To include classes, static methods etc. from other namespaces, include those namespaces with the <tt>using</tt> keyword

<tt>using</tt> is for accessing code that has already been compiled into libraries. Nemerle also allows for creating

<tt>partial</tt> classes (and structs), the source code of which may be split amongst several files as long as the class is

marked as <tt>partial</tt> in each place that part of it is defined. An interesting feature of partial classes in

Nemerle is that some parts of partial classes may be written in C# while others are written in Nemerle.

{ // the class that a partial class inherits from only needs to

... // be specified in one location

 

=={{header|NewLISP}}==

(load "file.lsp")

 

;; URLs (both http:// and file:// URLs are supported)

 

=={{header|Nim}}==

As other modular languages, accessing from a module to symbols of other modules is done by importation.<br/>

After <code>import someModule</code> an exported symbol <code>x</code> can be accessed as <code>x</code> and as <code>someModule.x</code>.

import strutils except parseInt

import strutils as su, sequtils as qu # su.x works

 

But Nim provides also a way to include the content of a file, using the <code>include</code> statement:

 

The import statement is only allowed at top level whereas the include statement can be used at any level as it simply includes the text (at the appropriate indentation level). Here is an example from the Nim manual:

<br/>

proc main() =

include A

 

 

=={{header|OASYS Assembler}}==

 

In script mode and in the interactive loop (the toplevel) we can use:

 

In compile mode (compiled to bytecode or compiled to native code) we can use:

 

=={{header|Oforth}}==

 

In order to load a file with name filename :

 

In order to load a package with name pack :

 

=={{header|Ol}}==

Ol has a module system, so usually there is no need of a textual inclusion of a text file.

(import (otus random!))

 

You can do a textual inclusion from the global scope using REPL command ",load" (not a part of core language itself, but a REPL extension).

,load "otus/random!.scm"

 

=={{header|ooRexx}}==

ooRexx has a package system and no ability for textual inclusion of other text files. Importing of other packages is done via the ::requires directive.

 

=={{header|OpenEdge/Progress}}==

Curly braces indicate that a file should be included. The file is searched across all PROPATH directory entries.

 

Arguments can be passed to the file being included:

 

 

=={{header|Openscad}}==

 

include <foo.scad>;

 

//Import modules and functions, but do not execute

 

=={{header|PARI/GP}}==

main.perl:

 

do "include.pl"; # Utilize source from another file

 

include.pl:

print "Hello World!";

 

From documentation:<pre>

 

=={{header|Phix}}==

 

=={{header|PHP}}==

There are different ways to do this in PHP. You can use a basic include:

You can be safe about it and make sure it's not included more than once:

You can crash the code at this point if the include fails for any reason by using require:

And you can use the require statement, with the safe _once method:

 

=={{header|PicoLisp}}==

The function '[http://software-lab.de/doc/refL.html#load load]' is used for recursively executing the contents of files.

 

=={{header|Pike}}==

compile() and compile_file() functions can be used.

 

 

=={{header|PL/I}}==

 

=={{header|PowerBASIC}}==

Note also that <code>#INCLUDE</code> and <code>$INCLUDE</code> function identically.

 

 

=={{header|PowerShell}}==

<#

A module is a set of related Windows PowerShell functionalities, grouped together as a convenient unit (usually saved in a

#>

. .\MyFunctions.ps1

 

=={{header|Processing}}==

Processing also supports the `import` keyword for explicitly including Processing / Java 8 library files. This can be used to import standard part of Java 8, for example the Map class:

 

 

It can also be used to import contributed libraries, which may be installed via PDE Contributions Manager or locally on the Processing Libraries path. For example, if the G4P library is installed, its files are then imported into a sketch with:

 

 

3. Local Java JAR files may be added to the sketch /code subfolder, then imported with `import`. For example, if you have a file code/test.jar:

...and it contains a Java class file `foo/bar/Test.class`, then that can be imported from the file. The specific jar file name does _not_ need to be identified -- any resource in any jar file can be imported so long as you specify the in-jar path and class name in the import statement.

 

 

==={{header|Processing Python mode}}===

One can write:

 

# then you may use

# one.one_function()

 

otherwise use

 

 

or, recommended style:

 

# then you may use

# one_function()

 

=={{header|Prolog}}==

 

 

=={{header|PureBasic}}==

IncludeFile will include the named source file at the current place in the code.

XIncludeFile is exactly the same except it avoids including the same file several times.

 

IncludeBinary will include a named file of any type at the current place in the code.

IncludeBinary don't have to, but should preferably be done inside a [http://www.purebasic.com/documentation/reference/data.html data block].

 

=={{header|Python}}==

Python supports the use of [http://docs.python.org/library/functions.html#execfile execfile] to allow code from arbitrary files to be executed from a program (without using its modules system).

 

 

includes the content of mymodule.py

Names in this module can be accessed as attributes:

 

=={{header|R}}==

 

 

=={{header|Racket}}==

Including files is usually discouraged in favor of using modules, but it is still possible:

 

#lang racket

(include "other-file.rkt")

 

=={{header|Raku}}==

Raku provides a module system that is based primarily on importation of symbols rather than

on inclusion of textual code:

However, one can evaluate code from a file:

One can even do that at compile time:

None of these are true inclusion, unless the <tt>require</tt> cheats and modifies the current input string of the parser. To get a true textual inclusion, one could define an unhygienic textual macro like this:

 

=={{header|RapidQ}}==

$INCLUDE "RAPIDQ.INC"

 

=={{header|Retro}}==

 

 

=={{header|REXX}}==

 

The REXX Compiler for CMS and TSO supports a directive to include program text before compiling the program

 

===Including a file at time of execution===

{{works with|ARexx}}

{{works with|REGINA 3.8 and later, with options: AREXX_BIFS and AREXX_SEMANTICS}}

/* Include a file and INTERPRET it; this code uses ARexx file IO BIFs */

say 'This is a program running.'

say 'The usual program resumes here.'

exit 0

Note: &nbsp; due to the way most REXX interpreters work, functions and jumps (SIGNALs) inside an INTERPRETED program won't work. &nbsp; Neither are &nbsp; ''labels'' &nbsp; recognized, which would then exclude the use of those subroutines/functions.

 

 

'''Program1.rexx'''

/* This is program 1 */

say 'This is program 1 writing on standard output.'

say 'Thank you, program 1 is now ending.'

exit 0

'''Program2.rexx'''

/* This is program 2 */

say 'This is program 2 writing on standard output.'

say 'We now return to the caller.'

return

If a REXX interpreter finds a function call, it first looks in the current program for a function or procedure by that name, then it looks in the standard function library (so you may replace the standard functions with your own versions inside a program), then it looks for a program by the same name in the standard paths. This means that including a file in your program is usually not necessary, unless you want them to share global variables.

 

=={{header|Ring}}==

 

=={{header|RPG}}==

{{works with|ILE RPG}}

 

/include library/file,member

 

/copy library/file,member

 

 

=={{header|Ruby}}==

Note that in Ruby, you don't use the file extension. Ruby will first check for a Ruby (.rb) file of the specified name and load it as a source file. If an .rb file is not found it will search for files in .so, .o, .dll or other shared-library formats and load them as Ruby extension. <code>require</code> will search in a series of pre-determined folders, while <code>require_relative</code> behaves the same way but searches in the current folder, or another specified folder.

 

 

=={{header|Run BASIC}}==

You don't use the file extension. .bas is assumed.

 

=={{header|Rust}}==

The compiler will include either a 'test.rs' or a 'test/mod.rs' (if the first one doesn't exist) file.

 

fn main() {

test::some_function();

 

Additionally, third-party libraries (called <code>crates</code> in rust) can be declared thusly:

fn main() {

foo::some_function();

 

=={{header|Scala}}==

 

In a Scala REPL[https://docs.scala-lang.org/overviews/repl/overview.html] it's possible to save and load source code.

 

=={{header|Seed7}}==

Therefore seed7_05.s7i must be included before other language features can be used (only comments can be used before).

The first include directive (the one which includes seed7_05.s7i) is special and it must be introduced with the $ character.

All following include directives don't need a $ to introduce them.

The [http://seed7.sourceforge.net/libraries/float.htm float.s7i]

[http://seed7.sourceforge.net/libraries library] can be included with:

 

=={{header|Sidef}}==

Include a file in the current namespace:

 

Include a file as module (file must exists in '''SIDEF_INC''' as '''Some/Name.sm'''):

 

=={{header|Smalltalk}}==

there is no such thing as source-file inclusion in Smalltalk. However, in a REPL or anywhere in code, source code can be loaded with:

or:

In Smalltalk/X, which supports binary code loading, aFilename may either be sourcecode or a dll containing a precompiled class library.

 

{{Works with|SNOBOL4}}

{{Works with|Spitbol}}

 

=={{header|SPL}}==

 

=={{header|Standard ML}}==

{{Works with|SML/NJ}}

 

=={{header|Tcl}}==

The built-in <code>source</code> command does exactly inclusion of code into the currently executing scope, subject to minor requirements of being well-formed Tcl script that is sourced in the first place (and the ability to introspect via <code>info script</code>):

 

Note that it is more usually considered good practice to arrange code into ''packages'' that can be loaded in with more regular semantics (including version handling, only-once semantics, integration of code written in other languages such as [[C]], etc.)

In the case of packages that are implemented using Tcl code, these will actually be incorporated into the program using the <code>source</code> command, though this is formally an implementation detail of those packages.

 

 

{{works with|Bourne Shell}}

 

==={{header|C Shell}}===

 

==={{header|Bash}}===

 

GNU Bash has both <code>.</code> and the C-Shell style <code>source</code>. See [http://www.gnu.org/software/bash/manual/html_node/Bash-Builtins.html#index-source Bash manual on <code>source</code>]

=={{header|Ursa}}==

Ursa can read in and execute another file using the import statement, similar to Python.

 

=={{header|Vala}}==

 

Functions can be called then using Gee.<function> calls:

 

or with a using statement:

 

 

=={{header|VBScript}}==

VBScript doesn't come with an explicit include (unless you use the wsf form). Fortunately vbscript has the Execute and ExecuteGlobal commands which allow you to add code dynamically into the local (disappears when the code goes out of scope) or global namespaces. Thus, all you have to do to include code from a file is read the file into memory and ExecuteGlobal on that code. Just pass the filename to this sub and all is golden. If you want an error to occur if the file is not found then just remove the FileExists test.

 

Include "D:\include\pad.vbs"

 

if fso.FileExists(file) then ExecuteGlobal fso.OpenTextFile(file).ReadAll

End Sub

If you use the wsf form you can include a file by

<script id="Connections" language="VBScript" src="D:\include\ConnectionStrings.vbs"/>

 

 

If you use the following form then you can define an environment variable, %INCLUDE% and make your include library more portable as in

 

Include "%INCLUDE%\StrFuncs.vbs"

 

ExecuteGlobal(fso.OpenTextFile(wso.ExpandEnvironmentStrings(file)).ReadAll)

End Function

 

=={{header|Verbexx}}==

* /# @INCLUDE file:"filename.filetype"

* - file: is just the filename

Not in preprocessor -- include_counter = 3

Not in preprocessor -- include_counter = 3

 

=={{header|Wren}}==

 

Here's a simple example.

 

{{out}}

<pre>

</pre>

 

 

{{works with|FASM on Windows}}

 

{{works with|nasm}}

 

=={{header|XPL0}}==

 

{{out}}

09-28-12

</pre>

 

=={{header|zkl}}==

 

=={{header|ZX Spectrum Basic}}==

It is possible to include the contents of another program using the merge command. However, line numbers that coincide with those of the original program shall be overwritten, so it is best to reserve a block of line numbers for merged code:

 

5000 REM We reserve line numbers 5000 to 8999 for merged code

9000 STOP: REM In case our line numbers are wrong

9955 MERGE "MODULE"

9960 REM Jump to the merged code. Pray it has the right line numbers!