tenerary operator in c++

Ternary_operation

Multiple Inheritance in C++

http://publib.boulder.ibm.com

Diamond_problem

Syntax,Semantics,Pragmatics

1. Syntax refers to the ways symbols may be combined to create well-formed sentences (or programs) in the language. Syntax defines the formal relations between the constituents of a language,thereby providing a structural description of the various expressions that make up legal strings in the language. Syntax deals solely with the form and structure of symbols in a language without any consideration given to their meaning.

2. Semantics reveals the meaning of syntactically valid strings in a language. For natural languages,this means correlating sentences and phrases with the objects,thoughts,and feelings of our experiences. For programming languages,semantics describes the behavior that a computer follows when executing a program in the language. We might disclose this behavior by describing the relationship between the input and output of a program or by a step-by-step explanation of how a program will execute on a real or an abstract machine.

3. Pragmatics alludes to those aspects of language that involve the users of the language,namely psychological and sociological phenomena such as utility,scope of application,and effects on the users. For programming languages,pragmatics includes issues such as ease of implementation,efficiency in application,and programming methodology

Struct packed attribute

Wie padding verhindern?

http://openbook.galileocomputing.de/c_von_a_bis_z/015_c_strukturen_012.htm

CIL (MSIL)

Common Intermediate Language

Common Intermediate Language (CIL,pronounced either “sil”or “kil”) (formerly called Microsoft Intermediate Language or MSIL) is the lowest-level human-readable programming language defined by the Common Language Infrastructure specification and used by the .NET Framework andMono. Languages which target a CLR-compatible runtime environment compile to CIL,which is assembled into an object code that has a bytecode-style format. CIL is an object-oriented assembly language,and is entirely stack-based. Its bytecode is translated into native code or executed by avirtual machine.

CIL was originally known as Microsoft Intermediate Language (MSIL) during the beta releases of the .NET languages. Due to standardization of C# and the Common Language Infrastructure,the bytecode is now officially known as CIL.[1]

During compilation of .NET programming languages,the source code is translated into CIL code rather than platform or processor-specific object code. CIL is a CPU- and platform-independent instruction set that can be executed in any environment supporting the Common Language Infrastructure,[2] such as the .NET runtime on Windows,or the cross-platform Mono runtime. In theory,this eliminates the need to distribute different executable files for different platforms and CPU types. CIL code is verified for safety during runtime,providing better security and reliability than natively compiled executable files.

The execution process looks like this:

  1. Source code is converted to Common Intermediate Language,CIL’s equivalent to Assembly language for a CPU.
  2. CIL is then assembled into a form of so called bytecode and a .NET assembly is created.
  3. Upon execution of a .NET assembly,its code is passed through the runtime’s JIT compiler to generate native code. Ahead-of-time compilation may also be used,which eliminates this step,but at the cost of executable file portability.
  4. The native code is executed by the computer’s processor.

 

(From Wikipedia,the free encyclopedia)

Marshalling

Marshalling in the context of computer programming is the transformation of components stored in the memory of the device into usable data that may be utilized by one or more of the programs residing on the hard drive. The action of gathering data into storage areas for easy retrieval is greatly enhanced by the process of marshalling,as it allows programs to recover the data for use without the need to translate the components each time the action is called for. From this perspective,marshalling aids in the speedy function of many of the software programs used in homes and businesses every day.

Along with converting objects into data and preparing the data for storage or transmissionwhen needed,marshalling also acts as a buffer between the stored data and the various files or programs that make use of the data. This buffer helps to maintain the integrity of the stored data and allow it to be used for simultaneous actions involving more than one file or one program. The overall effect is to keep the system functioning at optimal levels without delays. For example,marshalling helps to make it possible to work with a spreadsheet,a word processing document,and an open Internet connection all at the same time,without delays. Marshalled data may be in use by all of these applications simultaneously without creating a drain on the resources of the hard drive.

Many persons who are knowledgeable about computer science in general consider marshallingto be somewhat similar to a process that is known as serialization. Serializing an object involves converting the object from the original state into a byte stream,but in a manner where the byte stream can be converted back into the original state if necessary. Marshallingdiffers from serialization in that serialization does not record codebases. Marshalling handles both the functions of conversion and the recording of codebases. In addition,marshalling can be utilized with remote objects,whereas serialization cannot. This means that for some configurations,the marshall approach to object conversion,storage,and transmission may be preferable.

 

Stubs

Stubs (and harnesses) facilitate testing of applications/systems.
In top-down development,you need to stub certain methods,or entire sub-systems so that you can test the higher layer of code. Stubs allow you to quickly implement such bits without much thought,allowign you to concventrate on the part of the system you’re actively developing.
If you’re developing one bit in parallel with another team developing another part,you may develop a quick stub of THEIR system so that you can develop and unit-test yur system independently of theirs. For example,you’re developing a web app that’s meant to get its data from a web service. The web service is being developed at the same time by another company. You’d want to stub their proposed web service so that you can independently develope and unit-test your web app without waiting for them.
For bottom-up development,you’d need to develop harnesses that call your bottom-level components and methods with test data so that you can test such bottom-level methods (and be confident that they work) before moving onto the higher-level components that call them.

FreeRTOS

http://www.highintegritysystems.com/images/stories/downloads/OPENRTOS_Quick_Reference_Guide_10.pdf

makefiles

http://www.ijon.de/comp/tutorials/makefile.html

Application Binary Interface (ABI)

The Application Binary Interface (ABI) for the ARM Architecture (Base Standard) (BSABI) is a collection of standards. Some of these standards are open. Some are specific to the ARM architecture. They regulate the inter-operation of binary code and development tools in ARM architecture-based execution environments,ranging from bare metal to major operating systems such as ARM Linux.

By conforming to this standard,objects produced by the toolchain can work together with object libraries from different producers.

The ABI for the ARM Architecture is a family of specifications that describe the processor-specific aspects of the translation of a source program into object files. Object files produced by any toolchain that conforms to the relevant aspects of the ABI can be linked together to produce a final executable image or library.

Each document in the specification covers a specific area of compatibility. For example,the C Library ABI for the ARM Architecture (CLIBABI) describes the parts of the C library that are expected to be common to all conforming implementations.

The ABI documents contain several areas that are marked as platform specific. To define a complete execution environment these platform-specific details have to be provided. This gives rise to a number of supplemental specifications,for example theARM GNU/Linux ABI supplement.

The Base Standard ABI for the ARM Architecture (BSABI) enables you to use ARM,Thumb,and Thumb-2 objects and libraries from different producers that support the ABI for the ARM Architecture. The ARM compilation tools fully support the BSABI,including support for Debug With Arbitrary Record Format (DWARF) 3 debug tables (DWARF Debugging Standard Version 3).

The ARM C and C++ libraries conform to the standards described in the BSABI,the CLIBABI,and the C++ ABI (CPPABI) for the ARM Architecture.

About the Base Platform Application Binary Interface (BPABI)

Many embedded systems use an operating system to manage the resources on a device. In many cases this is a large,single executable with a Real-Time Operating System (RTOS) that tightly integrates with the applications. Other more complexOperating Systems (OS) are referred to as a platform OS,for example,ARM Linux. These have the ability to load applications and shared libraries on demand.

To run an application or use a shared library on a platform OS,you must conform to the Application Binary Interface (ABI) for the platform and also the ABI for the ARM architecture. This can involve substantial changes to the linker output,for example,a custom file format. To support such a wide variety of platforms,the ABI for the ARM architecture provides the Base Platform Application Binary Interface (BPABI).

The BPABI provides a base standard from which a platform ABI can be derived. The linker produces a BPABI conforming ELF image or shared library. A platform specific tool called a post-linker translates this ELF output file into a platform-specific file format. Post linker tools are provided by the platform OS vendor. The following figure shows the BPABI tool flow.

 

An embedded-application binary interface (EABI) specifies standard conventions for file formats,data types,register usage,stack frame organization,and function parameter passing of an embedded software program.

Compilers that support the EABI create object code that is compatible with code generated by other such compilers,thus allowing developers to link libraries generated with one compiler with object code generated with a different compiler. Developers writing their own assembly language code may also use the EABI to interface with assembly generated by a compliant compiler.

The main differences of an EABI with respect to an ABI for general purpose operating systems are that privileged instructions are allowed in application code,dynamic linking is not required (sometimes it is completely disallowed),and a more compact stack frame organization is used to save memory.[4]

ARM EABI

EABI ist die neue “Embedded”ABI definiert von ARM ltd.
Die EABI ist eine Familie von Spezifikationen und Dokumentationen für
die ARM Architektur, ARM Funktionsaufrufe, ARM ELF Format usw.

 
Application Binary Interface for the ARM® Architectur

http://infocenter.arm.com/help/topic/com.arm.doc.ihi0036b/IHI0036B_bsabi.pdf

C Library ABI for the ARM®Architecture

http://infocenter.arm.com/help/topic/com.arm.doc.ihi0039b/IHI0039B_clibabi.pdf

C++ ABI for the ARM®Architecture

http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0529c/Babibbbe.html