OpenLLM-France/wikimedia huggingface dataset:
# Ada Programming/Platform/VM/Java
## Ada and the JVM

The Ada→J-Code compilers translate Ada programs directly to Java bytecode for the Virtual Machine. Both Ada programmers and Java programmers can use each other's classes almost seamlessly, including inheritance. Ada adds desirable language features like a strong base type system and full generics, Java VMs add garbage collection and a rich set of libraries.
There are (at least) two compilers that support this: AppletMagic and JGNAT. The following example assumes AppletMagic. Changes required to make them work with JGNAT should be minimal. Some are explained in due course.
Ada programs for JVMs (see for example Programming:J2ME) appear to be surprisingly smooth. Unlike creating, and sometimes using, a binding to some library, using Ada→J-code compilers will make binding issues disappear.

### Naming Conventions

AppletMagic and JGNAT use naming conventions for deciding how to distribute compiled code across Java class files. When a (tagged) type together with its surrounding package should be mapped to one Java class file, AppletMagic requires the type name to have a known suffix, and otherwise to be the same as the package name:
Similarly, JGNAT has some conventions that effectively turn type names into key words. These names tend to be short, and general, here is Typ:

### Java Uses References, So Does Ada, Then

The mapping of Java's primitive types to corresponding Ada types is straightforward. (The semantics of integer types differ between the languages when the values approach a subtype's limits. JVM integers can jump from positive to negative when adding in excess of the maximum integer, Ada programs should not permit this. The compiler docs will explain to what extent Ada semantics will be preserved on the JVM.)
For reference types—everything is allocated in the heap—there is another convention.
(JGNAT sources use Ref instead of Foo_Ptr.) The classwide pointers can be used just like Java references. Notice that primitive operations can have access parameters. This is a natural choice when interfacing to Java.
When Ada programmers wish to use Java objects in their programs, they will see the Java classes as normal packages, and the objects following the conventions outlined above. The compilers offer tools for creating Ada packages from Java .class files. Given the Java class Foo, the Ada package will be as show below.

#### new_Foo

    This is a constructor function corresponding to the default constructor of the Java type. (Usually you won't be concerned with default constructors.) There is a special convention identifier for constructors, Java_Constructor.

#### pragma Import

    As both the constructor and the op method are defined in the Java class, they will be imported just like when importing C, or Fortran functions, using convention identifiers Java_Constructor, and Java, respectively.

### Constructors

To be continued.

## Further reading

* S. Tucker Taft (1996). Programming the Internet in Ada 95
* Cyrille Comar, Gary Dismukes, and Franco Gasperoni (1997). Targeting GNAT to the Java Virtual Machine
# Ada Programming/Platform/Windows

The following Libraries and Tools help you when you target the MS-Windows Platform.

## GNAVI

    Visual RAD (Rapid application development) Development environment including: GWindows, a Win32 binding, and GNATCOM, a binding to COM/DCOM/ActiveX.

## CLAW

    Another Win32 binding that works with any Ada 95 compiler. An introductory edition is available free of charge for non-commercial use.

## Console

    Libraries for console I/O.

## Visual C++ - GNAT interface

    Guide for calling Ada functions from C++ using GNAT and Visual C++.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Libraries
# Ada Programming/Portals
## Forges of open-source projects
### SourceForge

    Currently, there are more than 200 Ada projects hosted at SourceForge — including the example programs for Ada Programming wikibook.

### GitHub

    A source code repository based on Git with many recent developments.

### Codeberg

    Codeberg is a democratic community-driven, non-profit software development platform based on Forgejo. It contains a few Ada projects.

### Disroot

    Disroot is another public Forgejo instance. It also contains a few Ada projects.

### Ada-centric sites

    There are some Ada-centric forges/catalogues hosted by Ada associations and individuals:
   * http://codelabs.ch
   * http://www.adaforge.org

## Directories of freely available tools and libraries
### Open Hub (language summary, ada tag, language search)

    Open Hub is a directory of Open Source projects. Its main features are source code analysis of public repositories and public reviews of projects.

## Collections of Ada source code
### The Public Ada Library (PAL)

    The PAL is a library of Ada and VHDL software, information, and courseware that contains over 1 BILLION bytes of material (mainly in compressed form). All items in the PAL have been released to the public with unlimited distribution, and, in most cases (the exceptions are shareware), the items are freeware.

### Ada and Software Engineering Library Version 2 (ASE2)

    The ASE2 Library contains over 1.1GB of material on Ada and Software Engineering assembled through a collaboration with over 60 organizations. Walnut Creek CD-ROM once sold copies of this library. Nowadays, it is no longer maintained, but is still hosted in the archive.adaic.com server. It may contain useful resources, but it is highly redundant with other libraries.

### AdaPower

    A directory and collection of Ada tools and resources.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Tutorials
* Ada Programming/Web 2.0
# Ada Programming/Platform/VM/dotNET

There are two ports of GNAT to the Microsoft .NET platform:
* A# is an open-source port under GNU General Public License terms developed at the Department of Computer Science at the US Air Force Academy.
* AdaCore provides a port of their GNAT compiler for the .NET platform. The port is available for their customers, or in the public version (libre).

## See also
### External links
#### A# by Martin Carlisle

    Home page | Sourceforge project page

#### GNAT Pro for .NET

    Product page | Press release

### Wikipedia

* A#
* Microsoft .NET
# Ada Programming/Platform/VM

The following tools help you when you target a virtual machine.

## Java

    Programming Ada 95 for Java's JVM (JGnat, AppletMagic)

## .NET

    Programming Ada for the .NET Platform (GNAT Pro .NET, A#)

## See also
### Wikibook

* Ada Programming
* Ada Programming/Libraries

### Ada Reference Manual

—does not apply—
# Ada Programming/Platform/Portable builds

GPRbuild can be used to make portable builds.

## Platform-independent code

Create a project for platform-independent code which is common to all supported platforms.
portable.gpr

## Platform-specific code

For example, open portable-windows.gpr with GPS or GPRbuild to build a project for Windows.
portable-windows.gpr
# Ada Programming/Platform/Windows/GNAVI

GWindows is a community supported Ada binding to Windows. It is part of the GNAVI project, a Delphi like environment for Ada. http://www.gnavi.org/gwindows
GNATCOM is a community supported Ada binding to COM+/COM/DCOM/ActiveX. It is part of the GNAVI project, a Delphi like environment for Ada. http://www.gnavi.org/gnatcom
GNAVI is a community supported RAD (Rapid application development) visual development environment that uses GWindows and GNATCOM.

## See also
### Library links
#### Authors

    David Botton and others

#### Homepage

    http://gnavi.sourceforge.net

#### Project Info

    http://sourceforge.net/projects/gnavi

#### CVS Archive

    http://gnavi.cvs.sourceforge.net/gnavi/

#### Download

    http://sourceforge.net/projects/gnavi/download

### Wikibook

* Ada Programming
* Ada Programming/Libraries
# Ada Programming/Platform/Windows/Visual C++ - GNAT interface

This is a guide for interfacing from Ada to C++ in Windows, using GNAT and MS Visual C++.
Before starting, you should check your environment. This was the environment used while writing this guide.
* Ada GPL 2006 and GPS.
* Microsoft Visual Studio 2005
These are the steps we will follow:
* write your Ada code and build dynamic library
* make a .lib file (for static linking)
* work together
* run your code

## Step 1. Write Ada source code

And most important thing is your project file. It make you more easy.
You can configure almost all settings in your GPS IDE. But note that GPS cannot do Library_Interface setting correctly. After configuring it, you should check the project file and modify it accordingly. Library_Interface means which package contains export functions in DLL.
Library_Auto_Init is interesting and you must choose a correct setting in your project.
If you choose True, it will call adaInit when library load (which means elaboration appears in loading time automatically) if choose False, it will export init and finalize functions in DLL and you must call them by yourself.
If you export functions like C/C++ "normal" functions without any elaboration parts, you may set library_auto_init to True.
If your Ada code does not only work like C/C++ but also needs Ada elaboration function, you should initialize/finalize by yourself.
"DANGEROUS" DANGEROUS" DANGEROUS"DANGEROUS"DANGEROUS"
For example, if you have a library level task needing elaboration in load time and use implied linking and loading it will "deadlock WAITING" when DllMain calls init code. It's unexpected behaviour that you don't want to.
DANGEROUS"DANGEROUS"DANGEROUS"DANGEROUS"DANGEROUS"
In some case, you may use LoadLibrary / GetProcAddress to work (Explicit loading). But it is not easy to manage your code, especially if you export many functions.

## Step 2. Make a .lib file (for static linking)

You can use utilities dumpbin and lib to generate .lib file (2.A)
the file content is
Dump of file te.dll
(2.b) remove all in Te.def but leave ...
The Teinit and Tefinal is used to elaborate and terminate the Ada elaboration part after Te.dll loaded. (the name does not call adainit/adafinalize but still the same function as adainit/adafinalize)

## Step 3. Work together in MS VC++

Start Visual Studio C++ project and add Te.lib to your linker setting.
Writing a Te.h header for Ada DLL (GPS should generate .lib and .h for you).
And write a C/C++ test code to generate a .exe file

## Step 4. Run your code

Put .exe and .dll in the same directory and run the test
The loader will find dll following in this order:
* current directory
* path variable
* Windows directory
Put the dll and exe in the same directory, it is the best option.
# Ada Programming/Platform/Windows/Console

The following libraries will help you when doing Input Output in the Windows console.

## NT Console

    A library for doing output with format and for moving the cursor.

## Console IO

    A library for correct I/O of Latin 1 characters (i.e. 'Pos greater than 127) in the Windows console.

## NT Mouse

    A library for controlling the mouse under the Windows console.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Libraries

### Ada Reference Manual

—does not apply—
# AnyLang Programming Language Comparison/Appendix:PLEAC Crossref:Internet services
## InternetServices
### Simple DNS Lookups

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |

### Being an FTP Client

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |

### Sending Mail

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |

### Reading and Posting Usenet News Messages

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |

### Reading Mail with POP3

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |

### Simulating Telnet from a Program

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |

### Pinging a Machine

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |

### Using Whois to Retrieve Information from the InterNIC

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |

### Program: expn and vrfy

| ada | c++ | commonlisp | cposix | erlang | factor | forth |
| groovy | guile | haskell | haskell-on-steroids | java | masd | merd |
| nasm | ocaml | perl | php | pike | pliant | python |
| R | rexx | ruby | smalltalk | tcl | | |
# Adventist Youth Honors Answer Book/Recreation/Letterboxing - Advanced

Letterboxing - Advanced :
| Recreation North American Division | Skill Level 2 |
| Recreation North American Division | Year of Introduction: 2008 |

## 1. Complete the Letterboxing honor.

Instructions and tips for earning the Letterboxing honor can be found in the Recreation chapter.

## 2. Create a letterbox stamp, post clues on a web site, establish and maintain a letterbox for six months.

Each club or unit may want to establish a series of stamps with other units or clubs. There is a potential for using your letterbox as a witnessing tool. The stamps could have a Biblical theme or the box could be located at your church. Our local clubs are making a series on the life of Moses. Another idea is for the boxes to contain stamps images that when interconnected produce one picture.
Everyone should be involved in creating the cache stamp. If more than five are working on the honor, two or more caches should be established. When hiding a new box you must contact the landowner for permission. No letterboxes are to be hidden in National Parks or National Forests.
The 3 month maintenance is a minimum, but Pathfinders should not be made to wait too long before receiving their honor. You should visit the box once a month to insure it is intact. Some smugglers or non-letterboxers find the cache and steal or scatter the contents.

## 3. As a unit, club or family find the clues and then locate an additional twenty letterboxes not found for the basic honor, eight which can be part of two or more series. Individually “stamp in”, imprint the letterbox stamp in your log book and record your find on the web site.

See answer to basic Letterboxing, requirement 5.

## 4. Design, create and carve your own hitchhiker stamp. Hide in a letterbox, post on a web site and track its travels for six months.

Many letterboxing stamps don’t have a wood backing on them, but the stamp looks better and is more durable when you add the backing. However, a hitchhiker stamp must not be very big, so you wouldn’t put a wood backing on it.

## 5. Participate in an exchange with letterboxers other than your local club members and obtain a minimum of 20 stamp images.

This would be a great activity at a camporee. Similar interaction as pin trading, but cheaper.
# Adventist Youth Honors Answer Book/Recreation/Orienteering

Like many honors, the requirements for Orienteering differ from one division to the next. If your division is not listed below, use the General Conference version.
Orienteering (General Conference) Orienteering (South Pacific Division)
See also Map and Compass
# Apache Ant/Task

A task is a piece of code that can be executed.
A task can have multiple attributes (or arguments, if you prefer). The value of an attribute might contain references to a property. These references will be resolved before the task is executed.
Tasks have a common structure:
<name attribute1="value1" attribute2="value2" ... />
where name is the name of the task, attributeN is the attribute name, and valueN is the value for this attribute.
There is a set of built-in tasks, along with a number of optional tasks, but it is also very easy to write your own.
All tasks share a task name attribute. The value of this attribute will be used in the logging messages generated by Ant.
Tasks can be assigned an id attribute:
<taskname id="taskID" ... />
where taskname is the name of the task, and taskID is a unique identifier for this task. You can refer to the corresponding task object in scripts or other tasks via this name. For example, in scripts you could do:
<script ... >
</script>
to set the foo attribute of this particular task instance. In another task (written in Java), you can access the instance via project.getReference("task1").
Note 1: If "task1" has not been run yet, then it has not been configured (i.e., no attributes have been set), and if it is going to be configured later, anything you've done to the instance may be overwritten.
Note 2: Future versions of Ant will most likely not be backward-compatible with this behaviour, since there will likely be no task instances at all, only proxies.
# Apache Ant/References
## References
##### Links

* ant.apache.org
* Manual
* Wikipedia.org

##### Books

* Ant: The Definitive Guide, 2nd Edition by Holzner Steve (April 14, 2005)
* Pro Apache Ant by Matthew Moodie (Nov 16, 2005)
* Java Development with Ant by Erik Hatcher and Steve Loughran (Aug 2002)
* Ant Developer's Handbook by Allan Williamson, et al. (Nov 1, 2002)

##### Articles

* Top 15 Ant Best Practices
# Apache Ant/Running Saxon
## Motivation

You want to have an Apache Ant task that runs the Saxon XSLT transform.

## Method

Download the Saxon jar file. Put the saxon.jar file in a lib folder. Run the following test.

## Source Code
### Build File

The following is how Saxon is invoked from Apache Ant.
Note that if you are running in Eclipse you will have to go to the "Preferences" menu and add the saxon9.jar file to Ant/Runtime/Ant Home Entries. Just click the "Add JARs" and add the saxon9jar file the end of this list.

## XSLT Version Check

check-version.xsl:
Or if you are generating a web page:

## Results for XALAN

Results for Apache XALAN

## Results for Saxon

Version: 2.0 Vendor: SAXON 9.1.0.7 from Saxonica Vendor URL: http://www.saxonica.com/
# Apache Ant/Store XML data
## Motivation

You want to upload a file or a hierarchy of files into eXist.

## Method

We will use the xdb:store function and demonstrate how to use its options to load subfolders.

## Sample Code

Each build file must have four key components
* a reference to internal files on your hard drive (ideally in a properties file)
* a typedef for your Ant eXist extensions
* a path to tell it where to get the jar files
* a target to do the load

## Using a local.properties File to Load XML Data

The script above will work fine if you have a single use with one set of local files. But if you have many user each user may put their local files in a different location. If that is the case then you will want to isolate all local file references in a file called local.properties.
The following example is from the eXist documentation project for a server running on port 8080 with the context being set to be "/":

## References

The eXist store task is documented here: http://exist-db.org/exist/apps/doc/ant-tasks.xml#D2.2.10
# Apache Ant/Reindex a Collection
## Motivation

You want a simple ant task that will reindex a collection.

## Method

We will us the ant task that will call an XQuery that has the reindex command in it. Because there is no ant task that does this we will use the xquery task to execute a remote XQuery that performs this task.
Here is a link to the ant task to run an XQuery http://exist-db.org/ant-tasks.html#N1041F
# Apache Ant/Passing Parameters to XSLT
## Motivation

You want to call a transform with a set of parameters. You want to be able to set these parameters from a build file.

## Input null.xml

XSLT must have an input, but this example does not use it.
# Apache Ant/Property

Ant does not have variables like in most standard programming languages. Ant has a structure called properties. Understanding how properties work is critical to understanding how (and why) Ant works so well.
Here is a simple demonstration of how to set and use properties
Note that to use a property you have to put a dollar sign and left curly brace before it and a right curly brace after it. Don't get these confused with parens.
When you run this you should get the following:
Ant properties are immutable meaning that once they are set they cannot be changed within a build process! This may seem somewhat odd at first, but it is one of the core reasons that once targets are written they tend to run consistently without side effects. This is because targets only run if they have to and you cannot predict the order a target will run.
Properties do not have to be used only inside a target. They can be set anywhere in a build file (or an external property file) and referenced anywhere in a build file after they are set.
Here is a small Ant project that demonstrates the immutability of a property:
When you run this, you should get the following output:
Note that despite trying to change MyProperty to be "Two", the value of MyProperty does not change. Ant will not warn you of this.
For newcomers this might seem strange, but this is ideally suited for building up complex trees of values that are set once and used over and over again. It makes your build scripts easy to maintain and reliable.
Ant also has a nice set of "built in" properties that you can use:
This demonstrates how to read system properties
When you run this program you should get an output similar to the following:
See the ant reference manual for a full list of built-in ant and Java properties or you can try the following link for the Java properties: getProperties
Next Chapter, Next Cookbook Chapter
# Apache Ant/Getting Started/Installation

Before starting, you will need to have a running version of the Java Development Kit (JDK) 1.2 or later. For Ant 1.7, JDK 1.5 is recommended. Ant will need a JAXP-compliant XML parser installed and available in your classpath. The binary distribution of Ant includes the latest version of the Apache Xerces2 XML parser.
To install Ant on Windows, you can use WinAnt the Windows installer for Apache Ant. Download and run the latest version of WinAnt, and follow the directions in the installer. WinAnt will place the "ant" executable on your system path, which allows you to run the command "ant" from the command line at any directory in your system. Or, you can follow these directions:
The first step is to download Apache Ant.
There are two options. You can compile the program from the source or for beginners we recommend just downloading a binary file called a zip file.
You can find the download page here: http://ant.apache.org/bindownload.cgi
You will need to download a file such as
This is a compressed archive file. You will need to uncompress it.
If you are not familiar with the process of uncompressing a file you should consult your computer operating system manual.
After this is done, you will see a folder such as:
This folder contains another folder called "bin". Within that there is a file called ant.bat that you can run directly from the command line.
Next Chapter