Download the Full Version of textbook for Fast Typing at textbookfull.

com

Pro .NET 5 Custom Libraries: Implementing Custom

.NET Data Types 1st Edition Roger Villela

https://textbookfull.com/product/pro-net-5-custom-libraries-
implementing-custom-net-data-types-1st-edition-roger-
villela/

OR CLICK BUTTON

DOWNLOAD NOW

Download More textbook Instantly Today - Get Yours Now at textbookfull.com

 Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Pro .NET Framework with the Base Class Library:

Understanding the Virtual Execution System and the Common
Type System Roger Villela
https://textbookfull.com/product/pro-net-framework-with-the-base-
class-library-understanding-the-virtual-execution-system-and-the-
common-type-system-roger-villela/
textboxfull.com

Exploring the .NET Core 3.0 Runtime: Through Code

Generation and Metadata Inspection 1st Edition Roger
Villela
https://textbookfull.com/product/exploring-the-net-core-3-0-runtime-
through-code-generation-and-metadata-inspection-1st-edition-roger-
villela/
textboxfull.com

Pro C# 7 with .NET and .NET Core Andrew Troelsen

https://textbookfull.com/product/pro-c-7-with-net-and-net-core-andrew-
troelsen/

textboxfull.com

Pro ASP NET Core Identity Under the Hood with

Authentication and Authorization in ASP NET Core 5 and 6
Applications 1st Edition Adam Freeman
https://textbookfull.com/product/pro-asp-net-core-identity-under-the-
hood-with-authentication-and-authorization-in-asp-net-
core-5-and-6-applications-1st-edition-adam-freeman/
textboxfull.com
Building Custom Tasks for SQL Server Integration Services:
The Power of .NET for ETL for SQL Server 2019 and Beyond
2nd Edition Andy Leonard
https://textbookfull.com/product/building-custom-tasks-for-sql-server-
integration-services-the-power-of-net-for-etl-for-sql-server-2019-and-
beyond-2nd-edition-andy-leonard/
textboxfull.com

Building Custom Tasks for SQL Server Integration Services

The Power of NET for ETL for SQL Server 2019 and Beyond
Second Edition Andy Leonard
https://textbookfull.com/product/building-custom-tasks-for-sql-server-
integration-services-the-power-of-net-for-etl-for-sql-server-2019-and-
beyond-second-edition-andy-leonard/
textboxfull.com

Pro C 9 with NET 5 Foundational Principles and Practices

in Programming Tenth Edition Andrew Troelsen Phillip
Japikse
https://textbookfull.com/product/pro-c-9-with-net-5-foundational-
principles-and-practices-in-programming-tenth-edition-andrew-troelsen-
phillip-japikse/
textboxfull.com

Pro C 9 with NET 5 Foundational Principles and Practices

in Programming Tenth Edition Andrew Troelsen Phillip
Japikse
https://textbookfull.com/product/pro-c-9-with-net-5-foundational-
principles-and-practices-in-programming-tenth-edition-andrew-troelsen-
phillip-japikse-2/
textboxfull.com

Mobile Development with NET Build cross platform mobile

applications with Xamarin Forms 5 and ASP NET Core 5 2nd
Edition Can Bilgin
https://textbookfull.com/product/mobile-development-with-net-build-
cross-platform-mobile-applications-with-xamarin-forms-5-and-asp-net-
core-5-2nd-edition-can-bilgin/
textboxfull.com
Roger Villela

Pro .NET 5 Custom Libraries

Implementing Custom .NET Data Types
1st ed.
Roger Villela
Sao Paulo, Sã o Paulo, Brazil

Any source code or other supplementary material referenced by the

author in this book is available to readers on GitHub via the book’s
product page, located at www.​apress.​com/​978-1-4842-6390-7. For
more detailed information, please visit www.​apress.​com/​source-code.

ISBN 978-1-4842-6390-7 e-ISBN 978-1-4842-6391-4

https://doi.org/10.1007/978-1-4842-6391-4

© Roger Villela 2020

This work is subject to copyright. All rights are reserved by the

Publisher, whether the whole or part of the material is concerned,
specifically the rights of translation, reprinting, reuse of illustrations,
recitation, broadcasting, reproduction on microfilms or in any other
physical way, and transmission or information storage and retrieval,
electronic adaptation, computer software, or by similar or dissimilar
methodology now known or hereafter developed.

The use of general descriptive names, registered names, trademarks,

service marks, etc. in this publication does not imply, even in the
absence of a specific statement, that such names are exempt from the
relevant protective laws and regulations and therefore free for general
use.

The publisher, the authors and the editors are safe to assume that the
advice and information in this book are believed to be true and accurate
at the date of publication. Neither the publisher nor the authors or the
editors give a warranty, expressed or implied, with respect to the
material contained herein or for any errors or omissions that may have
been made. The publisher remains neutral with regard to jurisdictional
claims in published maps and institutional affiliations.

Distributed to the book trade worldwide by Springer Science+Business

Media LLC, 1 New York Plaza, Suite 4600, New York, NY 10004. Phone
1-800-SPRINGER, fax (201) 348-4505, email orders-ny@springer-
sbm.com, or visit www.springeronline.com. Apress Media, LLC is a
California LLC, and the sole member (owner) is Springer Science +
Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a
Delaware corporation.
This book is dedicated to my mother, Marina Roel de Oliveira.
January 14, 1952 to March 17, 2017 (†)
Introduction
This book covers programming with .NET 5 to develop custom data
types and custom libraries for use on Microsoft Windows, Linux, and
Apple macOS. These custom libraries can be used in different operating
system platforms because they are written using .NET 5 (a cross-
platform implementation of the ECMA-335 specification) and because
all source code is written in the C# programming language and uses
only cross-platform Base Class Library (BCL) types.
This book focuses on how to best exploit the .NET 5 custom data
types for software libraries so that companies and software engineers
can design and implement internal/commercial tools for various
scenarios on myriad target platforms. Contextual modeling and
planning is difficult without a fundamental understanding of the .NET 5
platform, which this book seeks to provide. The book also covers
internal aspects of the BCL .NET types and APIs, with walkthroughs
covering the implementation process of custom .NET data types and
.NET custom libraries.
You will also learn about .NET assembly and .NET module
structures, the inner workings of the BCL implementation on the .NET
platform, custom data types available through the .NET platform, and
how to write a custom library that incorporates .NET APIs available
through the .NET BCL.
Acknowledgments
I want to thank to the Apress team who worked with me on this book:
Smriti Srivastava (Acquisitions Editor), Shrikant Vishwakarma
(Coordinating Editor), Matthew Moodie (Development Editor),
Welmoed Spahr (Managing Director), and Carsten Thomsen (Technical
Reviewer). It was a pleasure and an honor to work with such a highly
professional team.
I also want to thank my parents, with a special nod to my dad
(Gilberto), my two brothers (Eder and Marlos and his wife Janaína), my
nephew Gabriel, my nieces Lívia and Rafaela, and my cousin Ariadne
Villela.
I must also express special thanks to my friends Paula Carolina
Damasio, Alessandro Augusto de Jesus, and Neide Pimenta. I also want
to acknowledge and thank all the people who work really hard on team
Praxio Tecnologia developing one of the greatest specialized enterprise
resource planning (ERP) products on the market; congratulations to all
of you for your efforts.
I also want to thank my professional colleagues and friends who
have worked with me throughout the years.
Table of Contents
Chapter 1:​.​NET Platform
Acronyms
ECMA-335 and .​NET
ECMA-335
.​NET Platform
About the Common Type System
Fundamental Types and Hardware Platform
The Organization of Fundamental Data Types
CTS for Fundamental Types
Virtual Execution System
.​NET Module
.​NET Assemblies
Chapter 2:​Custom .​NET Data Type
Management of Data Types
Working with System.​Object, the Root of .​NET Reference Types
System.​ValueType, the Root of .​NET Value Types
Methods
Chapter 3:​.​NET Methods:​Implementation Details
Methods
About the Use of Operators
Operator Overloading:​Programming Language Semantics
and Syntaxes
Working with System.​Object.​GetType()
Constructors in a .​NET Data Type
Chapter 4:​.​NET Special Members:​Constructors in a Managed
Environment
Acronyms
Special Members
About Constructors in a Managed Execution Environment
Default Constructor
Summary
Chapter 5:​Finalizer Method:​The .​NET Special Member
Special Members
Special Member Destructor
Special Member Finalizer Method (Destructor)
Chapter 6:​.​NET Manifest and Versioning for Managed Libraries
Assemblies, Modules, Manifest, Versioning
Assembly
Manifest
Module
Versioning
Chapter 7:​.​NET Assemblies in a Managed Execution Environment
Managed Libraries
Data Types, Components, and Functionalities
Native Code and Managed Code
Index
About the Author
Roger Villela
is a software engineer and entrepreneur
with almost 30 years of experience in the
industry and works as an independent
professional. Currently, he is focused on
his work as a book author and technical
educator and specializes in the inner
workings of orthogonal features of the
following Microsoft development
platforms and specialized application
programming interfaces (APIs):
Microsoft Windows operating system
base services
Microsoft Windows APIs architecture and engineering
Microsoft Universal Windows Platform (UWP)
Microsoft WinRT platform
Microsoft .NET Framework implementation of the runtime
environment (Common Language Runtime [CLR])
His work is based on Microsoft Windows software development kit
(SDK) tools and libraries, Microsoft Visual Studio, and platform
foundational APIs, architectures, and engineering. He works with the
Microsoft Windows operating system, incorporating the following
programming languages, extensions, and projections:
C/C++
Assembly (Intel IA-32/Intel 64 [x64/amd64])
Component extensions/projections for runtimes
C++/CLI
C++/CX
C++/WinRT
C#
Common Intermediate Language (Microsoft Intermediate
Language [MSIL]) implementation for CLR platforms
About the Technical Reviewer
Carsten Thomsen
is a back-end developer primarily, but he
works with smaller front-end bits as
well. He has authored and reviewed a
number of books, and created numerous
Microsoft Learning courses, all to do
with software development. He works as
a freelancer/contractor in various
countries in Europe, using Azure, Visual
Studio, Azure DevOps, and GitHub as
some of his tools. He is an exceptional
troubleshooter, asking the right
questions, including the less-logical ones
(in a most-logical to least-logical
fashion). He also enjoys working with
architecture, research, analysis,
development, testing, and bug fixing.
Carsten is a very good communicator with great mentoring and team-
lead skills, and he also excels at researching and presenting new
material.
© Roger Villela 2020
R. Villela, Pro .NET 5 Custom Libraries
https://doi.org/10.1007/978-1-4842-6391-4_1

1. .NET Platform
Roger Villela1
(1) Sao Paulo, Sã o Paulo, Brazil

This chapter provides an overview of .NET 5 (previously .NET Core) and describes the fundamental
architectural and the engineering features that you should expect in any implementation of .NET 5
(regardless of hardware, operating system, or execution system).

Acronyms
The following acronyms are introduced in this chapter:
Base Class Library (BCL)
Common Intermediate Language (CIL)
Common Language Infrastructure (CLI)
Common Language Runtime (CLR)
Common Type System (CTS)
Framework Class Library (FCL) (Although not specific to the .NET Framework implementation, the
term is used for the full range of .NET types available in an official distribution of .NET.)
Intermediate Language (IL)
Microsoft Intermediate Language (MSIL)
Virtual Execution System (VES)
Windows Presentation Foundation (WPF) (a.k.a. execution engine)

ECMA-335 and .NET

ECMA-335
The ECMA-335 standard specification defines the Common Language Infrastructure (CLI) , which
includes a set of conceptual definitions and rules to be followed and engineering mechanisms to be
implemented, independent of the target operating system and hardware platforms. The CLI ensures
that applications, components, and libraries can be written in multiple high-level languages and can
be executed in different target system environments without needing to be rewritten.
We can access the ECMA-335 specification at www.ecma-
international.org/publications/standards/Ecma-335.htm. Figure 1-1 shows an
excerpt. The download link is www.ecma-international.org/publications/files/ECMA-
ST/ECMA-335.pdf, and the XML specification download link is www.ecma-
international.org/publications/files/ECMA-ST/ECMA-335.zip.
Figure 1-1 Excerpt of web page with information about the ECMA-335 standard specification
More objectively, the CLI is an open specification that describes executable code and an execution
environment that enables multiple high-level languages to be used on different architectural
platforms without being rewritten.
This execution environment must follow the architectural infrastructure described by the
following:
Base Class Library (BCL): Foundational library defined by and part of the CLI standard
specification. It is implemented by .NET Framework, .NET Core, .NET 5, and .NET 6 (early stages,
available on Github.com), and is the main reason for the existence of the .NET standard.
Common Language Specification (CLS): Rules (restrictions and models) required for language
interoperability. The detailed information on the CLS group is a subset of what is in the CTS, but the
content is primarily for language designers and class library designers (frameworks). So, learning
about CTS will offer a great base of knowledge for you and your team for when we start working
with the rules in the CLS.
Common Type System (CTS): The CTS is a set of data types and operations that are shared by all
languages that support the CTS, and learning about the CTS will offer a great base of knowledge to
you and your team when we start working with the rules in the CLS.
Metadata: The metadata describes the program structure, enabling languages and tools to work
together. Detailed understanding of the metadata group is not a requisite for a component
developer or application developer. Instead, detailed information about such is primarily for tool
builders and compiler writers.
Virtual Execution Engine (VES): How code is executed (and how types are instantiated),
interacts, and dies. More abstractly, it is also known as an execution engine or execution
environment. This execution system is responsible for loading, instantiating, executing, and
ensuring the cohesiveness of the interactions between the instances. In brief, it offers entire
lifecycle support for the instance of the types. The execution engine understands concepts,
 architecture, and implementation details of two fundamental areas of the platform: the CTS and the
VES.
Semantics:
Capability to recognize contextuality (semantics), meaning mechanisms to constantly observe
your own environment and ways to guarantee advanced security rules, data integrity (acting
based on more flexible or disciplined rules), dynamic extensibility and expandability. In addition,
we have the capability to interact with highly specialized environments (advanced data
management systems, for example), development software environment systems (for instance,
Microsoft Visual Studio), different target operating systems and hardware platforms (for
example, the Microsoft Windows operating system implementations and UNIX-based operating
system implementations, including Linux distributions, Apple MacOS, Apple iOS, Google Android,
FreeBSD, IBM AIX, Red Hat Linux, Intel x86/Intel x64, ARM 32-bit, ARM 64-bit, IoT high-
specialized environment for embedded systems, web development, desktop development, mobile
development, game development, artificial intelligence development, machine-learning
development, quantum computing environments, supercomputing highly specialized
environments, scientific highly specialized research and development environments, research
and development for enterprise and government at any level of complexity [local to global], and
many more).
Capable of hosting, and be hosted by, other environments (such as Microsoft SQL Server
advanced data management system, Microsoft Visual Studio 2017, Microsoft Visual Studio 2019,
and the Microsoft Azure set of advanced cloud products and services).
The CLI standard specification also includes an intermediate assembly language , and it is the
Common Intermediate Language (CIL). Here is a necessary distinction:
Intermediate Language: An IL is an abstract language used by a compiler as a step between
program code and assembly code.
CIL: The CIL is a formal instruction set to the CIL described in the CLI standard specification.
Microsoft Intermediate Language (MSIL) : MSIL is Microsoft’s implementation of the formal
instruction set based on the ECMA-335 CIL described in the CLI standard specification.
When writing code using a programming language that adheres to the CLI standard specification,
the result of the compiled code is a sequence of instructions of the CIL instruction set, as examples
show in Listing 1-1 and Listing 1-2.
Open the sample solution RVJ.Core.sln at
<install_dir_on_your_local_computer>\Sources\APIs\DotNET\5.0\ProCustomLi
bs\Ch01\RVJ.Core\.
In the first sample project (Buffers_Console_Client), we have in the Program.cs C# file a .NET
custom data type named Program derived from System.Object, the .NET root data type for every
kind of .NET concrete or abstract class or struct data type, directly or indirectly, as shown in Figure 1-
2, Figure 1-3, and Figure 1-4, respectively.
Figure 1-2 Every .NET data type inherits, directly or indirectly, from the System.Object root data type. In .NET, we have
a reference type and a value type

Figure 1-3 Some .NET types (for example, System.Array) are abstract data types and are implemented partially by code
generation of the compiler (for example, a C# compiler)
Figure 1-4 System.ValueType is a reference type, and System.Int32 is a value type derived from System.ValueType, which
inherits from the System.Object reference type
In the C# programming language, because C# treats System.Object as the base class, we do not
need to use the System.Object root data type explicitly when we do not have another class as the
base data type.
In fact, the execution environment of the CLR (the VES) assumes this; therefore, most
programming languages do not require that System.Object be informed explicitly in this scenario.
However, it is good programming practice to explicitly use the base data type in such cases. Otherwise,
this can become error prone when using more than one programming language in a project,
potentially resulting in erroneous perceptions about the inheritance model supported by the .NET
execution environment and the transfer of the desired feature to the programming language and the
adoption of different programming languages (all because of basic resources of syntax).

#region Namespaces
using System;
#endregion

namespace ConsoleClient {
public static class Program : System.Object {
public static void Main() {
return;
}
};
};
Listing 1-1 Typical Source Code in the C# Programming Language for a Console Application with an Entry-Point
Member Method Called Program.Main()

.class public abstract auto ansi sealed beforefieldinit

ConsoleClient.Program
extends [System.Runtime]System.Object {
.method public hidebysig static void Main() cil managed {

.entrypoint
// Code size 1 (0x1)
.maxstack 8
ret

} // end of method Program::Main

} // end of class ConsoleClient.Program

Listing 1-2 Source Code in MSIL Generated in the Binary File, .EXE, or .DLL
These instructions are not for real hardware or processors. Instead, the CLI standard specification
describes a virtual environment that includes some characteristics and functionalities of the elements
available in a real computer.

.NET Platform
Microsoft .NET is the official commercial name for the group of technologies and tools designed and
implemented based on what is in the ECMA-335 standard specification.
Common Language Runtime, as the name suggests, is an implementation based on the CLI
standard specification, and an implementation of the CLR has a set of elements for a fundamental
architectural model. Each element has a fundamental set of conceptual definitions and rules to be
followed, and engineering mechanisms to be implemented, independently of the target operating
system and hardware platforms.
When we are implementing a CLR environment and technologies of a .NET platform, we are
creating software elements for a platform that is a nonspecific hardware-based computer (more
specifically, a software-only computer, and more commonly known as a virtual computer ). This
description includes when planning and implementing custom data types, custom components,
custom controls, custom libraries, and specialized tools and frameworks.
For this text, we are using a .NET 5 implementation of the CLR for the sample projects and
respective source code.
You can check for the most up-to-date versions of .NET 5 at the official Microsoft website:
https://dotnet.microsoft.com/download/dotnet/5.0.
You can also use GitHub to access the source code of the runtime, libraries, and frameworks made
using the CLR components and technologies and BCL fundamental library, as we have with Windows
Forms (Microsoft Windows only), Windows Presentation Foundation (Microsoft Windows only),
ASP.NET Core (Windows, Apple MacOS, Linux), and the .NET SDK Installer:
https://github.com/dotnet/runtime
https://github.com/dotnet/aspnetcore
https://github.com/dotnet/winforms
https://github.com/dotnet/wpf
https://github.com/dotnet/installer
Independently or together, these abstract aspects focus on management of data types. So,
reasonably, that form of environment and its components is known as a managed environment .
As mentioned previously, in this book we use a .NET 5 implementation of the CLR for the sample
projects and respective source code. So, whenever you see CLR mentioned, this means the .NET 5
running on Microsoft Windows 10 2004 and Microsoft Visual Studio 2019 16.7.3 or more recent
(Community, Professional, Enterprise). The following programming languages are used in this book:
C#
MSIL
 For example, when we are developing some application and choose the System.String
reference type, we are using one of the fundamental types available through the BCL.
However, the string reference type exists only because the CTS has the string fundamental built-
in type defined on it, which is one of the platform-specific fundamental built-in types upon which
string operations are built. In fact, the string content (value of) in any instance is made up of a
sequence of values of the CTS char platform fundamental built-in type, which is System.Char
fundamental data type in the BCL. These platform fundamental built-in types, BCL fundamental types,
and any other types derived or based on them follow the rules described by the unified type system.
In the CLI specification, this unified type system is the CTS, which describes rules about
conceptual, structural, and behavioral elements that must be followed by the CLI itself and specialized
tools (such as compilers and runtime environments).
You’ll learn more information about these types in Chapter 2 and in discussions about the CLR
throughout this book. For now, though, Table 1-1 shows the types defined by the CTS and described by
the metadata.

Table 1-1 Fundamental Types Defined Through CTS

BCL Types CTS Types

C# CIL/MSIL
System.Boolean bool
System.Char char

System.Object object

System.String string
System.Single float32

System.Double float64

System.SByte int8
System.Int16 int16

System.Int32 int32

System.Int64 int64
System.IntPtr native int

System.UIntPtr native unsigned int

System.TypedReference typedref
System.Byte unsigned uint8

System.UInt16 unsigned uint16

System.UInt32 unsigned uint32

System.UInt64 unsigned uint64

Table 1-2 Fundamental Data Types

Numeric Data Type Description

Byte unsigned integer All bits used to represent the value.
Values range from 0 to 255.
(2^8-1)
Word unsigned integer All bits used to represent the value.
Values range from 0 to 65,535.
(2^16-1)
Numeric Data Type Description
Doubleword unsigned All bits used to represent the value.
integer Values range from 0 to 4,294,967,295.
(2^32-1)
Quadword unsigned All bits used to represent the value.
integer Values range from 0 to 18,446,744,073,709,551,615.
(2^64-1)
Byte signed integer The first 7 bits (6…0) used to represent the value, the most significant bit (MSB) used as the
signed bit.
When the MSB has value 0, the number is positive. When the MSB has value 1, the number
is negative.
Values range from -128 to +127.
Word signed integer The first 15 bits (14…0) used to represent the value, he MSB used as the signed bit .
When the MSB has value 0, the number is positive. When the MSB has value 1, the number
is negative.
Values range from -32,768 to +32,767.
Doubleword signed integer The first 31 bits (30…0) used to represent the value, the MSB used as the signed bit.
When the MSB has value 0, the number is positive. When the MSB has value 1, the number
is negative.
Values range from -2^31 to +2^31-1.
Quadword signed integer The first 63 bits (62…0) used to represent the value, the MSB used as the signed bit
When the MSB has value 0, the number is positive. When the MSB has value 1, the number
is negative.
Values range from -2^63 to +2^63-1.

Table 1-3 CTS System.Object (Root Managed Object Type)

BCL Types CTS Types

C++/CLI projection C# programming language CIL
System::Object^ (same root C# object is the keyword used for CTS/BCL object (same root
managed object type) System.Object (same root managed object type) managed object type)

Table 1-4 Contextual Resources and Their Fundamental Purposes

Your .NET Applications, services, components, libraries, and frameworks.

specialized
applications
.NET Software development kit (SDK, a specialized tools for software development, analysis,
deployment, and some types of management)
Specialized components, libraries, and frameworks
CLR Implementation of a specialized managed environment based of CLI specification
Uses the resources of the underlying hardware and operating system platform (for example,
Microsoft Windows operating system)
Adaptable and capable of using the specialized resources of the underlying hardware and
operating system (for example, Microsoft Windows 10, Microsoft Windows Server 2016, Linux
distributions, Apple iOS, and Apple MacOS.
Remember that this is not a one-to-one mapping between reserved words, data structures,
specialized resources, or anything else in the programming languages. That is, what is formalized
through the instructions in CIL, what is defined in the CLI specification, and what is implemented by
the mechanisms on the platform is what prevails.
 As a reminder, unmanaged code means executable and nonexecutable code that is not in CIL and is
not under management and the rules of the CLR environment. Erroneously, the unmanaged code is
often considered synonymous with native code; this is incorrect. For example, the CIL instruction set
includes the following attributes:
cil is a code implementation attribute that specifies that the method declaration and
implementation consist only of CIL code (that is, managed code).
native is a code implementation attribute that specifies that the method declaration and
implementation consist only of native code (that is, native instructions of a specific
hardware/processor platform). Currently, this functionality of the managed environment CLR
implementation is used specifically as one of the base technologies of Platform Invoke (P/Invoke).
P/Invoke is one of the mechanisms of the platform, and it is described in the CLI specification.
runtime is a code implementation attribute that specifies that the implementation of the
method be provided automatically by the runtime.
Two more of these attributes are available and can be combined with them:
managed is a code implementation attribute that is used with methods for which
implementation is written using only CIL code.
unmanaged is a code implementation attribute that is used to describes that the
implementation is not external. Currently, this code implementation attribute is used by P/Invoke
technology, but it is not restricted to just that use.
The following implementation attributes are properly categorized as code implementation
attributes:
cil
native
runtime
managed
unmanaged
When unmanaged code needs to be used from the managed code, the unmanaged code
implementation attribute must be applied on the method implementation. In the specific case of the
P/Invoke mechanism, the use of the unmanaged code implementation attribute is required.
The pinvokeimpl method attribute is used to indicate that the runtime will switch from a
managed state to an unmanaged state when executing the unmanaged code.
Listing 1-3 shows an example of a managed code implementation that uses an unmanaged code
implementation of a well-known Windows application programming interface (API) HeapAlloc()
function . The method has been applied the unmanaged and native code implementation
attributes.
A switch from a managed state to an unmanaged state, and vice-versa, is performed automatically
by the P/Invoke.

.method assembly static pinvokeimpl( lasterr stdcall)

void*
modopt([mscorlib]System.Runtime.CompilerServices.CallConvStdcall)
HeapAlloc(void* A_0,
uint32
modopt([mscorlib]System.Runtime.CompilerServices.IsLong) A_1,
uint32
modopt([mscorlib]System.Runtime.CompilerServices.IsLong) A_2) native
unmanaged preservesig
{
 .custom instance void
[mscorlib]System.Security.SuppressUnmanagedCodeSecurityAttribute::.ctor()
= ( 01 00 00 00 )
// Embedded native code
}
Listing 1-3 Excerpt in MSIL of Unmanaged Code (Using P/Invoke to Call the HeapAlloc() Function of Windows
Memory Management, the Windows API)
At this point, we have the following sequence of elements: the CLI standard specification that is
composed by and describes the CTS group, the metadata group, the CLS and VES group, and the CLI
itself.

About the Common Type System

When working with a sequence of bits, it is necessary to define the organization of these bits to do
something useful. So, the data signified by the bit pattern should identify the data type (or a
contextualized type based on the data).
The data type must have a purpose and contextually well-defined characteristics. For example,
with regard to structural terms, the data type must have the required number of bits as defined and
the fundamental operations that the type supports.
A type’s conceptual, structural, and behavioral fundamental characteristics create a model as to
what can be done and what cannot be done with any particular type: a type system model. Because
the number of types is constantly increasing, a type system model is necessary to enforce rules to
ensure that the environment works as designed and expected.

A type system model describes the necessary rules related to each type’s conceptual, structural,
and behavioral characteristics.

Fundamental Types and Hardware Platform

For this discussion, we use Intel IA-32/x64 and Intel 64 fundamental built-in data types (or
fundamental built-in types), and we use some defined assembly instructions (implemented and
supported) that derive the hardware architecture and the contextual interpretation of the bits on the
data type.
The fundamental built-in data types are those defined as integral elements of the platform (in this
case, the Intel IA-32/x64 and Intel 64 processor hardware architecture). Therefore, these types are
integral elements of the hardware architecture and are not defined by an external library or execution
environment.
These are the fundamental types:
Byte (8 bits) (1 byte)
Word (16 bits) (2 bytes)
Doubleword (32-bits) (4 bytes)
Quadword (64 bits) (8 bytes)
Double quadword (128 bits) (16 bytes)
Although these fundamental built-in data types are supported by a common set of assembly
instructions (such as MOV) that perform a common set of operations such move data from one place
to another, some assembly instructions support additional interpretation of fundamental built-in data
types.
The purpose of this additional interpretation is to allow numeric operations to be performed, and
within this context these fundamental built-in data types are viewed and manipulated as numeric data
types.
The Intel IA-32/x64 and Intel 64 processors recognize two integer types: signed and unsigned.
 Assembly instructions such as ADD and SUB can perform operations on both signed integers and
unsigned integers, but some assembly instructions can perform operations only with one type.

The Organization of Fundamental Data Types

Here are the bits as a single pattern, without additional rules or interpretation, except for the
fundamental requirements of the hardware platform:
Byte (8 bits)
Bits 7…0
Word (16 bits)
Bits 15…0
Bits 15…8 (high byte)
Bits 7…0 (low byte)
Doubleword (32 bits)
Bits 31…0
Bits 31…16 (high word)
Bits 15…0 (low word)
Quadword (64 bits)
Bits 63…0
Bits 63…32 (high doubleword)
Bits 31…0 (low doubleword)
Double quadword (128 bits)
Bits 127…0
Bits 127…64 (high quadword)
Bits 63…0 (low quadword)
Table 1-2 describes the bits in more detail, including information about fundamental hardware
requirements and integer types (signed and unsigned).

CTS for Fundamental Types

The CTS supports types that describe values and types that specify contracts (behaviors that the type
supports), and the support for these types must be present in an implementation of a CLR. These two
types are supported because one of the principles of the CTS is to support object-oriented
programming (OOP), procedural, and functional programming languages.

A value is a bit pattern used to represent types such as numbers (for example, integer numbers and
float-pointing numbers).

Listing 1-4 shows examples in C# for two variables for instances of the System.UInt32 BCL
value type (and not a simple value).

const uint LimitOne = 72; // C# code.

const System.UInt32 LimitTwo = 144; // C# code.

Console.WriteLine( "{0}", LimitTwo.ToString() );

Listing 1-4 C# Examples Declaring Variables Using uint and System.UInt32, the Same Kind of Object (An Instance of
the Value Type of System.UInt32 Data Type of BCL)
 A value type is not an object type, but it is defined using a class definition (declaration and
implementation).

Remember that this way of work is defined by CTS and supported by VES in the CLR. From the
perspective of the type system and execution environment, it is necessary that an object be declared,
defined, and implemented to work within the CLR.
Table 1-3 describes the fundamental built-in types defined by CTS. As the table shows, the root
object type is accessible through the object keyword of the CIL. So that programming languages
such as C#, C++/CLI projection, F#, VB.NET, and others can access this root object type of the
platform, there is a library of fundamental types that is part of the CLI specification. This foundational
library is the BCL.
This root object type is the System.Object reference type. When declaring a variable of the
object type (CTS model definition) or System.Object (BCL) reference type using any high-level
programming language such as C#, C++/CLI projection, F#, VB.NET, and so on, the compiler generates
an intermediate code using the object keyword of the CIL. Table 1-4 summarizes and helps you
understand and memorize this sequence in a straightforward way.

Virtual Execution System

The VES provides an environment for running managed code, security boundaries, and memory
management.
Two fundamental built-in types (string and array) are used as a starting point in this discussion to
explain various aspects of CTS and VES.
These platform built-in fundamental types are present in any kind of software, so they stand as
orthogonal elements.
However, the .NET platform also has a special foundational library, also part of the CLI
specification, that supplies specialized types necessary to design and implement any kind of software:
the BCL.
As we explore the the organization of the BCL, we’ll use the System.Object, System.String,
and System.Array reference types as starting points and deconstruct many aspects of their
implementation. This discussion will then enable us to explore the interface types implemented by
these types in various specialized frameworks (such as Windows Forms, Windows Presentation
Foundation [WPF], Universal Windows Platform [UWP] applications, and ASP.NET).
The VES provides direct support for a set of platform-specific built-in fundamental types, defines a
hypothetical machine with an associated machine model and state, and provides a set of control flow
constructs and an exception-handling model.
To a considerable extent, the purpose of the VES is to provide the support required to execute the
MSIL instruction set.
The VES is the system that implements and enforces the CTS model. For example, the VES is
responsible for loading and running programs written to CLI.
The VES provides the services needed to execute managed code and data using the metadata to
connect separately generated modules together at runtime. The VES is also known as the execution
engine.

.NET Module
When we use C++ to write code, the result of the compiled and linked code is a binary file in a specific
format. In this case, we are working with PE/COFF (Portable Executable / Common Object File
Format), which is used by the Microsoft Windows operating system. When we use C# to write code, or
when we use any other programming language or group of extensions that adhere to the CLI
specification, the resulting binary file is in the same PE/COFF format. However, that resulting binary
file has some data structures changed/included to support the requirements described by CLI
specification and aspects of the Microsoft Windows operating system. This is called the CLI PE/COFF
module.
Currently, on Microsoft Windows, the CLI PE/COFF module can have .EXE, .DLL, .netmodule,
.WinMD, and .UWP extensions created and recognized by the operation system or development tools.
In addition, it can have any other extension that can be registered and recognized by the operating
system or specialized tools (for software development or not).
In fact, the use of an extension is not required, but it is a good practice and the accepted standard.
If we are using .NET 5 or .NET Core (not the old Windows-only .NET Framework) in a different
operating system and on a different hardware platform, the extensions and file formats used are
specific to such software and hardware environments. However, the fundamental structural resources
defined in CLI as a starting point are the same.
One VES responsibility is to load the CLI PE/COFF modules. Doing so includes verifying some
structural rules about the file format and guaranteeing that all information is as expected. The VES
uses the metadata information in the CLI PE/COFF modules to verify that the structural aspects are
recognized by the rules that it knows as valid, required, or optional. If the structural elements exist
and are valid, the next step is to apply the rules based on the nature of the elements and the context of
use.
For example, if the element is a managed type, the execution system needs to verify whether it is a
value type or a reference type.
If the element is an assembly reference type, one responsibility of this type is to describe various
characteristics of the managed module (structural and behavioral), such as the relationships it has
with other managed modules and what managed types are in it (and in any other managed module).

.NET Assemblies
People often wonder what a .NET assembly is exactly. Put simply, and as defined and described by the
CLI, an assembly is a logical unit for management and deployment of resources designed to work
together. In an implementation of CLR, assemblies can be static or dynamic.

Static Assemblies
Static assemblies are those stored in a storage device, such as a typical hard disk. In Microsoft
Windows, the file format of each module is the CLI PE/COFF. These assemblies have typical .NET 5
types and other specialized resources (audio/video files, localization support files, images, and
custom files created specifically for the application), depending on the purpose of each application.
.NET 5 and .NET Core include the following assemblies and modules, for example:
Assembly mscorlib
Module mscorlib.dll
Module System.Runtime.dll
Module netstandard.dll
Assembly System.Activities (part of Microsoft Windows Workflow Foundation)
Module System.Activities.dll
Assembly System.Diagnostics.Debug
Module System.Diagnostics.Debug.dll
Module System.dll
Module netstandard.dll

Dynamic Assemblies
Dynamic assemblies are created dynamically at runtime and are created via specialized API calls of
.NET 5/Core. These dynamic assemblies are created and executed directly in memory. However, the
dynamic assembly can be saved in a storage device, but only after being executed.
In a typical project, though, we have many files—binary files with executable code or binary files
with other types of data (for example, images)—that are part of the software. Therefore, the
description, verification, and reinforcement of the relations and dependencies among them are made
in part by the metadata.

Metadata is partly responsible for making resources available to perform these tasks.

Working with Assemblies and Modules

For a static assembly or a dynamic assembly, the principles prevails, a way of keep the cohesiveness of
the types and resources designed to work together. Deployment, Execution and Management. The
information stored in the modules and created through assemblies is what helps the runtime
environment understand and apply the rules to the relations among the elements.
Let’s use a typical static assembly.
There are four elements:
CIL that implements all the types and required logic to the module
Metadata
The resources (audio/video files, localization support files, images and custom files created
specifically for the application)
The assembly manifest
From the perspective of the runtime environment and basic structural rules described in the CLI,
of these four elements, only the assembly manifest is a required item. However, considering even the
simplest application or component, if we do not have the other elements, the application or
component does not have a practical use (except for learning about the assemblies and modules,
which I consider a quite practical use).

Organization of Elements in a Module (Physical File)

We start with a basic example here and continue with more details in Chapter 2.
Follow these steps:
1. Using the code editor of your preference, create a simple file and save it with the name
RVJ.ProDotNETCustomLibs.il in the directory of your choice that can be used to build source
code.

2. Open (as administrator) one of the developer command prompts installed and configured by
Microsoft Visual Studio 2019.

3. Copy the following sequence of MSIL code into the file RVJ.ProDotNETCustomLibs.il and save the
file:

.assembly extern System.Runtime {

.ver 5:0:0:0
}

.assembly RVJ.ProDotNETCustomLibs.Buffers {

.ver 1:0:0:0

}
4. In the developer command prompt, write the following command:

ilasm /DLL /Output=RVJ.ProDotNETCustomLibs.dll

RVJ.ProDotNETCustomLibs.il

If the code compiles without error, the output will be a binary file with the name
RVJ.ProDotNETCustomLibs.dll.
By following these steps, we have created a single-file static assembly, with only the assembly
manifest.

Using the ILDASM Tool

With the code compiled and the binary generated, we now can use the Intermediate Language
Disassembler (ILDASM) tool. (ISLASM , in contrast, stands for Intermediate Language Assembler.) On
the same command prompt that we used to compile the code, write the following command:

ildasm RVJ.ProDotNETCustomLibs.dll

With the module RVJ.ProDotNETCustomLibs.dll loaded by the ILDasm.exe tool, we see the
screen shown in Figure 1-5.

Figure 1-5 ILDASM showing a single-file static assembly

Now double-click in the manifest. A new window will open with information about the assembly
manifest, as shown in Figure 1-6.

Figure 1-6 ILDASM showing the assembly manifest of a single-file static assembly
Implementing the entrypoint Method
We have created a single-file static assembly, with only the assembly manifest. If we want to create an
.EXE, we need to change the source code. Using the same RVJ.ProDotNETCustomLibs.il, update the
source code to include a managed method that is the entry point:

.assembly extern System.Runtime {

.ver 5:0:0:0
}
.assembly RVJ.ProDotNETCustomLibs.Buffers {

.ver 1:0:0:0

.method static public void MyEntryPointMethod() cil managed {

.entrypoint

ret
}

As you can see, the name of the .entrypoint method does not need to be main.
To build this code, use the following command:

ilasm /Output=RVJ.ProDotNETCustomLibs.exe RVJ.ProDotNETCustomLibs.il

After the code compiles without error and with the binary generated, we can use the ILDasm.exe
tool to load the module RVJ.ProDotNETCustomLibs.exe, and then we have more than just the
assembly manifest, as shown in Figure 1-7.

Figure 1-7 ILDASM showing a single-file static assembly

As shown in Figure 1-8, we have created a single-file static assembly, with the assembly manifest
and one method (in this case, the entry-point method). When RVJ.DotNETProCustomLibs.exe
runs, it runs like any other .NET managed executable.
Figure 1-8 ILDASM showing a single-file static assembly, with the assembly manifest and one managed method
Listing 1-5 shows an example of managed instructions from one of the sample projects that comes
with the companion content of this book. The .module directive indicates the name of the binary
module (in this case, RVJ.ProDotNETCustomLibs.exe). The .assembly directive describes
which assemblies make this a logical unit of management and deployment of resources designed to
work together. The .assembly RVJ.ProDotNETCustomLibs.Buffers (without the extern
keyword) describes that this assembly is in the current module. The use of .assembly extern
directive describes to the assembly the types that your .assembly or .module are referencing.
For example, .assembly extern System.Runtime indicates that the assembly
RVJ.ProDotNETCustomLibs.Buffers is using one or more types of the assembly mscorlib.
The highlighted CIL instructions are the same that you can read in the
RVJ.ProDotNETCustomLibs.dll or RVJ.ProDotNETCustomLibs.exe modules. Chapter 2
discusses these and other instructions in more detail (with even fuller detail following in subsequent
chapters).

.assembly extern System.Runtime {

.ver 5:0:0:0
}

.assembly RVJ.ProDotNETCustomLibs.Buffers
{
.ver 1:0:0:0
}
.module RVJ.ProDotNETCustomLibs.exe
.imagebase 0x00400000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003 // WINDOWS_CUI
.corflags 0x00000001 // ILONLY
.method public static void MyEntryPointMethod() cil managed {
.entrypoint
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
Random documents with unrelated
content Scribd suggests to you:
geluk mocht hebben, kwamen ook de tijgers, die van de kleine tot de
groote hetzelfde deden en … eindelijk de slangen, die, na ook met haar
tong haar plicht gedaan te hebben, langzaam wegkropen. Met dit alles
ging geruimen tijd voorbij, en eerst met het aanbreken van den dag was
aan den optocht een einde gekomen, zoodat de man met zijn
geweeklaag kon ophouden.

Toen het goed dag was geworden, zag hij een vreemde gestalte naar
zich toekomen. Het was Wau-oeta, die een vreemdsoortigen pijl in de
hand had. „Zoo, waart gij het”, zei ze, „die al dat lawaai van nacht
maakte en mij uit den slaap hield?” „Ja”, antwoordde de man, „ik was
het”. „Wel”, zei Wau-oeta, „kijk eens langs je arm, van je schouder tot je
hand”. Hij keek, en zag dat hij met een soort schimmel 82 bedekt was. Hij
keek ook naar zijn anderen arm en zag precies hetzelfde. Toen hij van
Wau-oeta gehoord had, dat het deze schimmel was, die hem zoo
ongelukkig op de jacht maakte, wreef hij zijn armen goed af.

De pijl van Wau-oeta zag er, zooals ik zei, zeer vreemd [161]uit. Hij was
in drie of vier stukken gebroken 83 en ieder stuk was gespleten. Wau-
oeta ruilde dezen pijl voor den zijnen en verzocht hem, den hare te
willen probeeren om naar een lange liaan te schieten, die op grooten
afstand naar beneden hing, en .… ja, de pijl trof doel. Toen hij weêr den
pijl op den boog zette, vroeg Wau-oeta hem in de lucht te willen
schieten, en .… onbegrijpelijk, in welke richting hij ook zijn pijl
wegschoot, telkens als hij de aarde bereikte, raakte hij een dier: eerst
een Doroquara, en zoo voort in dezelfde volgorde, als waarin de vogels
hem aan zijn voet hadden gepikt, tot den powies* toe. En het vreemde
was, dat als hij schoot, hij zelf den pijl niet kon zien.

Toen hij nu met schieten op den grond begon, raakte de pijl

achtereenvolgens een rat, een Acouri enz. tot hij eindelijk een
prachtigen tapir schoot. Eindelijk kwamen de tijgers en de slangen aan
de beurt, in de volgorde waarin zij hem gelikt hadden.
Toen al dit wild bijeen was, schonk Wau-oeta hem voor goed den
merkwaardigen pijl, in ruil voor den zijne, doch op uitdrukkelijke
voorwaarde, dat hij tegen niemand zou zeggen, wie hem een zóó
zeldzamen pijl had gegeven. Ze zei hem daarop vaarwel en vertrok.

Onze vriend keerde nu naar zijn twee vrouwen terug, en natuurlijk werd
nu zijn naam, dien hij reeds wegens het dooden van Tobe-horo-anna
had, nog veel grooter. Iedereen werd echter nieuwsgierig, om te weten,
waar hij die kennis vandaan had gekregen en probeerde hem uit te
hooren, maar hij weigerde, trouw aan zijn gegeven woord, iets te
zeggen. Zijn schoonbroêrs dachten: laten wij onzen tijd afwachten, en
toen er een groot paiwarri-feest zou plaats hebben, haalden zij hem
over, dit bij te wonen; en … het is al weêr dezelfde geschiedenis: drank
werd zijn verderf. Zijn tong kwam los en hij vertelde alles wat er
gebeurd was. Den [162]volgenden morgen, toen hij weêr geheel was
bijgekomen, wilde hij, als gewoonlijk, zijn pijl grijpen, die Wau-oeta hem
gegeven had, maar zijn vroegere pijl lag er weêr voor in de plaats—en
van dat oogenblik was hij al zijn geluk weêr kwijt.

No. 38. De Legende van Letterhoutstomp.

Penalo ame weipiompo. Eertijds, voor nog de grootvader van mijn

grootmoeder geboren was, kwamen de Indianen veel talrijker voor dan
thans. Zij leefden tevens gelukkiger, wijl de macht der toenmalige
piaimannen de booze Geesten overal in bedwang hield. Paiwarri
ontbrak nooit; kinderen gehoorzaamden hunnen ouders; nimmer
doofden de barbakot-vuren uit, wijl het wild altijd in overvloed
voorhanden was en de visschen in de kreken krioelden.

Maar dit aardsche paradijs veranderde, toen aan onze kusten schepen
vol strijders verschenen, aan wier hoofd stond een man, genaamd
Paira-oende of Paira-oendepo, d.w.z. Letterhoutstomp. Hij was een
blanke, die de algemeene opmerkzaamheid tot zich trok door zijn
vreemd uiterlijk; zijn mond bevond zich nl. ter plaatse, waar bij gewone
menschen de borst moet zijn. 84

Letterhoutstomp was een menscheneter. Moordend en roovend trok hij

langs onze kusten. Wee! den Indianen, die in zijne handen vielen, want
levend werden ze verbrand of gevild en opgegeten!

Overal waar Paira-oende verscheen, vluchtten de roodhuiden naar alle

richtingen, doch hij vervolgde hen onmeêdoogend, tot zij ten einde raad
besloten zich te vereenigen, om aan het geweld een einde te maken.
[163]

Bij de beraadslagingen, die volgden, voerden de verschillende

piaimannen het hoogste woord. En nadat zij door hunne bezweringen
den slangengeest bekoord hadden, gaven zij te kennen, dat de Geest
van Twee Lichamen 85 bevolen had, dat alle Indianen zich moesten
terugtrekken op een bepaald tabbertje* (of tabbetje) in de nabijheid
eener groote savanne*. Daar herhaalden de gezamenlijke piaimannen
hunne bezweringen, met het gevolg, dat toen Stomp, die, het gebeurde
hoorende, in kokende woede naderde, het tabbertje begon te
bewegen 86 en acht dagen lang zich niet liet zien.

Paira-oendepo zocht overal naar de verdwenen Indianen, doch hen niet

vindende, kon hij hen ook niet dooden, integendeel was hij verplicht tot
den terugtocht, waarna de Roodhuiden weder uit het tabbertje te
voorschijn kwamen. Maar nauwelijks had Letterhoutstomp dit
vernomen, of hij vervaardigde een vreeselijken kaaiman als vaartuig,
om daarmede met één slag de Roodhuiden uit te roeien. Deze gingen
toen kampen maken in de nabijheid van een rots, genaamd Kaiwiri-
oendepo, of Skroertjes stomp 87. Daar hielden de gezamenlijke
piaimannen weêr een geweldige bezwering, ten einde den Dubbelgeest
te bekoren en van hem te verkrijgen, dat hij den Kaaiman 88 [164]zou
inslikken. Dagen lang duurden de ceremoniën en van zulk een invloed
waren de smeekbeden op het hart van den Slangegeest, dat deze
beloofde alles te zullen doen, wat zijne roode kinderen verlangden.
Letterhoutstomp naderde Kwaloe (Akaloe der Franschen?), het riviertje,
waar de Indianen zich verzameld hadden, van uit de plaats waar thans
de Fransche gevangenen verblijven (St. Laurent). Trotsch stevende hij
in zijn vreemd vaartuig de Marowijne op, ten einde de Roodhuiden
onverhoeds op het lijf te vallen. Maar ziet, eensklaps verhief zich een
Geest van Bekoring uit het water op, en Paira-oendepo werd met huid
en haar ingeslokt, terwijl zijn vaartuig van den oever (van de Kwaloe)
dreef tot een plaats, waar het nog te zien is als een steenen kaaiman,
die op een anderen steen rust.

Een verschrikkelijk gejubel weerklonk van alle zijden. Duizenden met

veeren versierde Caraïben dansten den overwinningsdans en te
midden der algemeene feestvreugde werd de gebeurtenis vereeuwigd
op den Temere-rots 89, die thans nog in de Marowijne staat.… [165]

In ’t stroomgebied der Marowijne,

Bezongen door het golfgeklots,
Staat, prijkende in al haar glorie,
D’wijd vermaarde Temere-rots,
Die eeuwen lang reeds heeft gedragen
Het teeken van den zwaren strijd,
Toen Paira-oende werd verslagen
Door Piai van den ouden tijd.

Die blanke in zijn Kaaiman-vaartuig,

Had aan zijn borst een grooten mond,
Waarmede hij in koelen bloede
Rood menschenvleesch als prooi verslond.
Maar ziet, het water rees verbolgen,
De Worgslang der Piai verscheen,
En Houten Stomp, hij werd verzwolgen;
Zijn Kaaiman werd een dubb’le steen.

Victorie! juichten duizend kelen,

Alom weerklonk de zegezang:
 Ons bloed is weêr in bloed gewroken
Aan U de eer, o, Geest der Slang!
Toen naderde een oude Piaiman
En grifte in het hard graniet,
Paira-oende en zijn Kaaiman,
Zooals gij dien nog heden ziet.

No. 39. De Legende van Arimoribo en Jorobodie. (C.)

Lang geleden, voor nog Paramaribo was gesticht 90, bevond zich ter
plaatse, waar nu het Fort Zeelandia ligt, de hoofdplaats der
Arowakken 91. Een zekere Arimoribo was hun opperhoofd; hij woonde
op de plaats van het tegenwoordige Gouvernementshuis. Een in de
nabijheid in de Suriname-rivier mondende kreek werd Parimoribo
genoemd (d.i. kreek van Arimoribo 92).

Het ontbrak Arimoribo niet aan krijgsvolk. Op zijn wenk greep heel de
stam naar de wapenen. Dit mocht [166]echter niet gebeuren, wanneer
niet de piaiman was geraadpleegd en de beschermgeesten goed
gestemd schenen. Tijdens een groot feest nu begon onder de
bedwelming der feestvreugde de gebruikelijke schildwacht, een op een
staak gestoken houten raaf 93, eensklaps te weeklagen, welk
onheilspellend teeken de vreugde voor een onbeschrijfelijk misbaar
deed plaats maken. Allen sprongen op en ziet .… op de rivier naderden
schepen met zeilen van ongekende grootte. Zulke dingen hadden de
Indianen nog nooit gezien. Meer verbaasd dan bevreesd vroegen zij
zich af, wat voor wezens dat wel konden zijn, die met zulke reusachtige
vleugels zich over het water heen bewogen. Het moesten reusachtige
vleermuizen zijn, besloten ten slotte de wijzen onder hen. Maar die
vleermuizen naderden en spoedig bleek het, dat zij soldaten en ook
vuurwapenen met zich meevoerden. Voor de eerste maal maakten de
Indianen met blanke menschen kennis.
Het sprak van zelf, dat de piaimannen onmiddellijk aan het werk gingen,
want er was immers geen krachtiger middel van tegenweer dan de piai-
kunst. Vóór alles moest deze worden aangewend; en zóó krachtig
slaagde deze, dat drie schepen tot zinken werden gebracht. Hoewel de
Indianen ook van hun pijlen gebruik maakten, moesten zij zich, toen
hun voorraad verschoten was, in de bosschen terugtrekken. Van dien
tijd dagteekent het, dat de Indianen zich in onderaardsche woningen
gingen verschuilen, zooals er nog heden ten dage te Onoribo en Topibo
aan de Para 94 bestaan. Deze woningen bestonden echter reeds in oude
tijden, toen de vaderen hunner [167]vaderen het land bewoonden 95 en
de seizoenen niet waren zooals zij thans zijn 96. Want telkens als de
droge tijd intrad, heerschte er een zóó ontzettende koude over de
wereld, dat iedereen er van bibberde en de voorvaderen der Arowakken
zich genoodzaakt zagen, bedoelde holen te graven, teneinde zich tegen
de koude te beschermen 97. Wat kwamen deze nu aan het nageslacht
als kostbare schuilplaatsen te stade!

Omtrent dezen tijd werd de zoo beroemde Jorobodie geboren, een

Arowak, die zich zou onderscheiden door zijn onverzoenlijken haat
tegen de blanken, en wiens beeltenis, zooals zijn nazaten beweren, nog
boven het Gouvernementshuis in Paramaribo 98 prijkt.

Jorobodie was een dracht van niet meer dan drie weken, die zich
wonderbaarlijk snel ontwikkelde, en wiens optreden algemeen ontzag
inboezemde. Hij toog ten strijde tegen de blanken, die niets tegen hem
vermochten, en versloeg hen. Geen vuur deerde hem, geen staal trof
hem, geen gewicht was zwaar genoeg, om hem te doen zinken. Alle
banden werden door hem verbroken en toen de blanken hem eindelijk
in een vat hadden gesloten, en hem aan het water hadden
prijsgegeven, deed hij een tijger tot [168]zich naderen, stak hem door
een gaatje zijn staart toe en zoo werd hij overal heengesleept, waar hij
maar wilde. Nooit werd een zonderlinger vaartuig door zulk een dier, en
nog wel onbeteugeld, voortgetrokken.
Zooals het mannen betaamt, wien men een buitengewone roeping
toedicht, was ook Jorobodie in ieder opzicht een wonder van kracht en
slimheid 99. Zijn voedsel bestond uitsluitend uit krabben, en dit sober
voedsel maakte hem tot den man van kracht, den trots zijner natie.
Wee! den Caraïb, die hem aandurfde! Wie slechts de hand uitstak, was
een man des doods! Zijn groote verdienste voor de Arowakken bestond
echter hierin, dat hij de schrik der blanken was. Deze toch waren
toenmaals hunne grootste vijanden 100, die hen niet alleen tot slaven
maakten, maar hen ook naar zee voerden, waar zij, na met teer
bestreken te zijn, levend verbrand werden.

Maar deze wreedheden zouden niet ongewroken blijven. Tot nu toe

hadden de Indianen steeds een rustige zee gekend. De booten voeren
zonder roeiriemen of parels* door eigen kracht op zee en rivier. De Boa
constrictor* diende als ankertouw en loopplank tevens. Zelfs meerde
deze de boot aan strand en oever vast.

Dit alles hield echter op, toen de menschen slecht werden. Geen kwaad
toch kan ongestraft blijven. Toen bijv. eens een Indiaan van den kapitein
een boot had geleend en deze niet terug bracht, werd hij gestraft. Hij
veranderde n.l. in een duizendpoot*, en werd vader van die millioenen
veelbeenige stekelige dieren, die nu door iedereen zoozeer gevreesd
worden. [169]

Op hetzelfde oogenblik veranderde alles in de natuur. Tot nu toe

hadden de rivieren, evenals de zee, onveranderlijke stroomingen. Eb en
vloed kende men te voren niet. Nadat de ongehoorzaamheid in de
wereld was gekomen, kwam er eb en vloed; de bruisende baren
kwamen opzetten, waartegen de booten niet langer bestand waren.

De vaartuigen moesten verbeterd worden en het varen vorderde

voortaan stuurmanskunst. De toestanden waren dus sedert Jorobodie’s
leven wel heel erg veranderd. Nochthans waarborgden verschillende
onthoudingen 101 de Indianen voor verdere onheilen. Wanneer zij bijv.
maar zorgden, op zee niet den naam te noemen der dingen, wier daarin
huizende geest zij hadden te vreezen, zouden zij steeds voor
stormweer gevrijwaard blijven. Het woord „krab” mocht o.a. volstrekt
niet genoemd worden, want anders zou de Geest opeens duizenden
krabben uitbraken.

Het ergste van alles voor de Indianen was wel, dat die ellendige
blanken zich aan dit alles niet storen wilden, zoodat zij het laatste
overblijfsel van den gelukstaat verloren deden gaan. Welk een schat
was voor hen in die omstandigheden een man van zulk een overwicht
als Jorobodie was!

Maar helaas! hij kwam ten val en wel door een vrouw, die hij geschaakt
had 102 en waardoor hij den haat zijner natie op den hals haalde. Het
aannemen van een spin, hem door zijn vrouw aangeboden, richtte
Jorobodie ten gronde, want nauwelijks had hij deze met de woorden
„zoek uwen weg”, door haar uitgesproken, aangenomen of Jorobodie
was niet meer.

De held was gevallen 103. [170]

No. 40. Uitdrijven van een priester uit den Indiaanschen hemel.

Penalo ame weipiompo. Eertijds enz. voor nog de grootvader van mijn
grootmoeder geboren was, werden de oevers der Boven-Marowijne
door talrijke Indianen bewoond. Maar hun aantal slonk bij den dag, wijl
zij veel te lijden hadden van allerlei booze geesten, die zich niet door
piaien lieten verdrijven. Vele Roodhuiden verlieten dan ook de behekste
streken, ten einde zich te begeven naar Mazwano, een plaats, die zij
reeds menigmaal in hunne droomen hadden bezocht. Ontelbare
Roodhuiden woonden daar in kampen, die elken morgen schitterend
verlicht werden door de morgenzon.
In het midden stond het wonderkamp van Tamoesi*. De [171]grond was
wit als het glinsterende witte kwartszand der savanne. Wit was ook de
kleur van de wateren, die door dit aardsche Paradijs vloeiden.

De Indiaansche God zag er geweldig uit. Zijn huid had, zooals van zelf
spreekt, een roode kleur. Hij was versierd met vederen, franjes en
kralen. In zijn hand hield Hij een ongehoord groote malaka*, waarin zich
de geesten bevonden van alle wezens; de steel was als een Boa
bewerkt.

Wanneer Tamoesi aan het piaien was, kon het geluid dagreizen ver
gehoord worden. Priesters en andere Booze Geesten vluchtten dan
ijlings naar de duistere wateren, zoodat de omtrek der Mazwano steeds
rein en wit bleef. Daar toch heerschte slechts gelukzaligheid. Men dronk
en danste er den geheelen dag. Overal liepen beeldschoone vrouwen
den mannen achterna. Ziekten en sterfgevallen kwamen er nooit voor,
terwijl Tamoesi van tijd tot tijd nederdaalde, ten einde met zijn geliefde,
roode kinderen feest te vieren. Geen wonder, dat de Indianen, die na
het doorstaan van vele duistere gevaren dit lustoord wisten te bereiken,
geen lust gevoelden tot hun familie terug te keeren.

Door de piaimannen werd het losbreken der Booze Geesten

toegeschreven aan een Pater, aan wien het gelukt was, vele Indianen
tot het Christendom te bekeeren. En, zeiden zij, zoo dit niet ophield, zou
de Marowijne geheel ontvolkt worden, wijl alle Indianen zich naar het
Paradijs zouden begeven.

De Priester, die van zijn volgelingen vernomen had, wat de Roodhuiden

tot de Mazwano aantrok, besloot een bezoek aan de plaats te brengen.
Zulk een stoutmoedig plan verbaasde den Indianen ten zeerste. Ga
niet, waarschuwden zij, want Paters worden niet in de Mazwano
toegelaten. De Priester luisterde echter niet, doch vertrok, [172]vergezeld
van eenige zijner bekeerlingen, in een boot. De reis duurde drie weken.
De piaimannen in de Mazwano waren door den Dubbelgeest in kennis
gesteld, dat er gevaar naderde in den vorm van een Pater. Tamoesi was
juist afwezig, en men besloot eens te probeeren, den stoutmoedige
zedenprediker te bekeeren tot een piaiman. Alle slangenpriesters togen
aan het werk. Zij piaiden de wateren, zoodat het vaartuig met groote
snelheid naar de Mazwano werd aangetrokken. Nauwelijks hadden
echter de Priester en zijn volgelingen voet aan wal gezet, of de wateren
liepen terug, het vaartuig met zich sleurende.

In het Paradijs der Roodhuiden werd lustig feestgevierd. De lucht

daverde van het geroffel der samboela’s* en het eentonig geluid der
kwama’s*. Het aantal vrouwen was zóó groot, dat de Indianen, die in
hunne hangmatten lagen, slechts de hand behoefden uit te strekken,
om een wonderschoon meisje te grijpen. Niemand voelde ooit honger,
doch slechts een voortdurenden dorst naar paiwarri*.

Bij het aanschouwen van dit, in zijn oogen zoo vreeselijk Paradijs, kon
de Priester niet nalaten een zucht te slaken. De piaimannen lieten hem
evenwel geen tijd tot bedenken. „Welkom vriend, in de Mazwano”,
riepen zij hem toe, „gij zult hier een heerlijk leventje hebben”.

Verscheidene beeldschoone meisjes naderden thans met kalebassen

vol drank. De Priester weigerde echter. „Wat”, riepen de piaimannen uit,
„drinkt gij niet?” „Ja”, antwoordde de Pater, „maar slechts met mate”.
„Danst gij?” „Neen”. „Hebt gij geen vrouwen?” „O! Neen”.

„Dan”, schreeuwden de piaimannen gebelgd, „moet gij nog de

genoegens van het leven leeren kennen”. Zij wierpen zich nu op den
weerloozen Pater, rukten hem de kleeren van het lijf, besmeerden zijn
leelijk, wit lichaam [173]met mooie, roode koesoewé*, trokken hem een
kamisa* aan en versierden hem met vederen, koralen en franjes. Toen
werden hem opnieuw kalebassen met drank aangeboden.

„Drink”, riepen de piaimannen. De Priester weigerde echter, doch toen

hij de dreigende aangezichten en de opgeheven apoetoe’s* om zich
heen zag, dronk hij achtereenvolgens drie kalebassen leeg. „Braak”,
werd hem toegebulderd. En hij braakte, waarna hem wederom drank
werd aangeboden. Toen moest hij dansen en zingen, totdat hij van
uitputting neêrviel en in een hangmat werd gelegd, om zijn roes uit te
slapen.

Toen hij den volgenden morgen wakker werd, voelde de Pater iets
naast zich in de hangmat. Hij keek en daar lag een beeldschoon
Indiaansch meisje. Vlug (volgens de verteller uiterst vlug) sprong hij op
en wilde hij wegvluchten. Maar de piaimannen grepen hem aan, en
riepen hem toe: „Nu kent gij de genoegens van het Paradijs; wilt gij hier
blijven?”

„Neen”, antwoordde de Pater.

Weder togen nu de piaimannen aan het werk; de wateren stroomden nu

opwaarts en brachten de boot van den Pater met zich mede. Maar toen
de Priester instapte, zag hij slechts één zijner volgelingen, een blanke,
aan het roer staan. De overigen, alle Roodhuiden, waren voor de
verleiding bezweken en hadden zich voor goed in de Mazwano
gevestigd.

Weder keerde nu de koers van het water. Het vaartuig schoot

stroomafwaarts, en eerst na een langen vermoeienden tocht gelukte het
beide mannen het dorp der bevriende Indianen aan de Marowijne te
bereiken.

Eenige vrouwen waren er juist bezig, cassave-brood te bakken, toen

een harer toevallig opkeek en een gil van ontzetting slaakte. „In de verte
komen witte Indianen”, riep [174]zij. Allen vluchtten dadelijk in de hutten,
waar zij door de paloeloe*-bedekking heen naar de komenden
gluurden.

De mannen van het dorp liepen hen echter tegemoet, en den Pater
herkennende, riepen zij uit: „Wij hebben U wel gewaarschuwd, niet naar
de Mazwano te gaan; maar gij hebt ons niet willen gelooven”.
„Gij hebt gelijk”, antwoordde de Priester, en hij vertelde alles wat hem
daar was overkomen; toen hij eindelijk was gekomen aan het
Indiaansche meisje, dat hij bij zijn ontwaken in de hangmat gevonden
had, barstten zij allen in een schaterlach uit. Hun verstand ging het te
boven, dat iemand z o o i e t s kon weigeren.

De verteller begreep echter zeer goed, dat in een dergelijk Paradijs de

Paters, die juist matigheid en kuischheid prediken, niet kunnen geduld
worden.

No. 41. Uitdrijving der Indianen uit den Hemel der Paters.

Penalo ame weipiompo. Eertijds, voor nog mijn grootvader geboren was
enz. was een Roodhuid bezig, boomen om te hakken, teneinde een
kostgrond aan te leggen. Het werk vermoeide hem, zoodat het zweet
hem langs het lichaam liep, en de mooie roode koesoewe*, waarmede
hij zich had ingesmeerd, geheel werd weggewasschen. Hij zuchtte luide
en verwenschte zijn ongelukkig lot. Doch ziet, als uit de lucht
verschenen twee mannen, die hem medelijdend aanzagen. „Waarom
zucht gij zoo”, vroegen zij hem. „Ach”, luidde het antwoord, „ziet gij niet,
hoe hard ik moet werken? En als ik des nachts wil uitrusten, gonzen de
muskieten mij om de ooren; ik ben de ongelukkigste Indiaan van mijn
stam.”

„Wel”, zeiden de vreemdelingen, „we zijn met uw lot begaan, kom met
ons meê; want we zijn juist op weg naar een plaats, waar niemand
behoeft te werken.”

De Roodhuid stemde toe en vertrok met zijn beide [175]geleiders.

Maanden duurde de reis. Vele gevaren hadden zij te overwinnen, maar
eindelijk stonden de drie reizigers voor een groote poort. Zij klopten
aan. „Wie daar?” klonk het van binnen. „Roodhuiden, goede menschen,
zonder toelala.” 104
De poort werd ontsloten door een grooten, krachtigen Pater, die de
Indianen welkom heette in het paradijs der Blanken.

De drie Roodhuiden traden schoorvoetend binnen en keken om zich

heen. Voor zoover het oog reikte, zagen zij niets dan zwartgerokte
Priesters, die hen toeriepen, dat elke Indiaan maar één vrouw mocht
hebben, en dat er geen jenever, brandewijn enz. te drinken viel.

Zij werden gedoopt en herdoopt. Eindelijk bereikten zij den zetel van
den Tamoesi der Blanken. Hij was zóó oud als de Roodhuiden nog nooit
een mensch hadden gezien. Een lange, witte baard hing tot aan zijn
voeten, maar Zijn hoofd was kaal. Hij zat op een soort van hobbelstoel,
prachtig versierd met tijger-, boa- en stinkvogelkoppen. Aan Zijn zijde
lag een groot kruisbeeld. Zijn lichaam was gehuld in een langen rok,
zooals de Paters ze thans dragen.

De Indianen traden eerbiedig nader. Tamoesi glimlachte en zei:

„Welkom, mijne roode kinderen, gij zijt zeker vermoeid van den langen
tocht, laten we ververschingen gaan gebruiken”. Hij stond op en den
Roodhuiden bij de hand nemende, leidde Hij hen rond in het Paradijs.
Overal langs de straten waren prachtige kerken, waar den geheelen
dag psalmen werden gezongen. Slechts hier en daar liep een blanke
met zijn vrouw. Toch was hun aantal zeer gering, in aanmerking
genomen de ontelbare Paters, die overal, waar Tamoesi zich vertoonde,
voor Hem nederknielden. [176]

Tusschen de kerken in zagen de Indianen eenige herbergen, waar

limonade, sodawater, kassiri enz. gratis werd geschonken aan een
ieder, die er om vroeg. Een dezer plaatsen traden zij binnen, en toen zij
er weêr uitkwamen glommen hunne aangezichten van genoegen. Vol
vreugde zeiden zij tot Tamoesi: „Wij willen altijd bij U blijven”.

Zij gingen verder. Langs den weg lagen eenige Indianen te slapen. De
Roodhuiden knikten elkander veelbeteekenend toe, doch zwegen. Zij
kwamen vervolgens bij plaatsen, waar visschen van zelf uit de
masoewa’s* aan de barbakot gingen hangen. Pijlen, door niemand
afgeschoten, snorden door de lucht en troffen wegvluchtende Tapirs en
Agoeti’s, die, na hun eigen vleesch in stukken te hebben gesneden,
zich zelf kookten en roosterden. Enkele Indiaansche vrouwen lagen
naast de matapi’s*, maar de cassave-wortels schrapten zich zelf,
persten zich zelf uit, en sprongen dan in de pannen, om gebakken te
worden.

De Indianen waren verrukt; en dat vooral, toen Tamoesi aan elk een
mooie vrouw schonk, en hij op staanden voet een huwelijk voltrok. Af en
toe gingen zij herbergen binnen; en elken keer kwamen zij er vroolijk
weêr uit. Eindelijk begon een der Roodhuiden met onvaste schreden te
loopen, daarbij onbetamelijke liedjes zingende en probeerende,
Tamoesi op heel familiare wijze te omhelzen.

Tamoesi keek den slingerenden Indiaan achterdochtig aan. Maar, toen

bij den tweeden en derden zich dezelfde verschijnselen begonnen te
vertoonen, begreep hij alles. Bulderend riep hij uit: „Dronken Indianen in
het Paradijs; dat is iets ongehoords.” En de Roodhuiden, die zoo zalig
langs den weg lagen uit te rusten, sliepen inderdaad hun roes uit!

Alle Indianen in het Paradijs verzamelden zich nu om Tamoesi. Zij

verzekerden Hem, dat het niet hun schuld was, maar dat de Blanken
hen den drank hadden geschonken. [177]„Dat is niet waar”, zei Hij, „want
nog nooit heb Ik hier in den hemel een dronken Pater of Blanke gezien”.

Tamoesi gaf nu bevel, alle sodawater, limonade, kassiri enz. bij Hem te
brengen. Van alles dronk hij een kalebas vol, maar, daar Hij geen
verstand van zulke dingen had, verklaarde Hij, dat alles in orde was, en
dat de ververschingen zeer goed smaakten! En toch, zoowel het
sodawater als de limonade en de kassiri waren even rijk aan alkohol als
zuivere jenever. Geen wonder dan ook, dat de Roodhuiden zich
bedronken; de verleiding was te groot voor hen. De Priesters en andere
Blanken dronken met mate, zoodat zij nooit dronken werden.
Tamoesi gebood daarom den Roodhuiden, dat zij onmiddellijk den
Hemel moesten verlaten. Alle Caraïben, Arowakken, Warrau’s enz.
vertrokken, en aan de poort riep Tamoesi hen nog na: „Door uw
dronkenschap hebt gij het Paradijs verloren; thans zult ge werken en
het zweet, dat uit uw lichaam stroomt, zal wegwasschen de koesoewé*,
waarmeê ge u besmet. Maar, als ge niet meer drinkt, zal de poort weêr
voor u geopend worden.”

Alle Indianen keerden nu ontmoedigd tot hunne stamgenooten terug,

aan wien zij hunne ondervinding vertelden, en menigmaal verschijnt in
hun droom het Paradijs der Priesters en Blanken aan de verrukte
blikken van den Roodhuid, vooral als hij bezig is boomen te kappen en
het werk zoo nu en dan door een dutje onderbreekt. Bij zijn ontwaken
zucht hij dan luide. Maar niemand verschijnt weêr, om hem den weg te
wijzen naar het voor hem onbereikbare Paradijs. En klagend neemt hij
weêr zijn bijl op en hakt woedend in den stam der omliggende boomen,
totdat het zweet hem uit de poriën vloeit en de koesoewé, waarmeê hij
zijn lichaam insmeert, wegwascht, zooals Tamoesi voorspeld had. [178]

No. 42. Bezoek van Caraïben aan Macoesiland. (C.)

In oude tijden kwamen de Indianen veel talrijker voor dan thans. Zij
leefden tevens gelukkiger, want er was overvloed van wild, terwijl het in
de rivieren en kreken krioelde van visschen.

Van de Indianenstammen, met welke de Caraïben in die tijden in

betrekking stonden, werden vooral de Macoesi’s als goede vrienden
beschouwd. Deze stam woonde ver over de Corantijn naar den kant der
Orinoco.

Om hun land te bereiken, moesten de Caraïben van Suriname weken

lang reizen en allerlei gevaren doorstaan. Dit hield de treklustigen niet
terug, en toen nu eens een aantal Macoesi’s een Surinaamsch
Caraïben-dorp hadden bezocht, besloten een twintigtal Kalienja’s* aan
Macoesiland een tegenbezoek te brengen.

De piaiman riep den Dubbelgeest op en deze voorspelde, dat de tocht

goed zou afloopen. Vroolijk vertrokken onze jongelieden dan ook en na
een voorspoedige reis bereikten zij de plaats hunner bestemming.

Zij vonden daar alles in rep en roer, daar Kenaima’s* zich in den omtrek
vertoond hadden.

De Macoesi’s ontvingen hunne vrienden met open armen en stonden

hun zelfs de beste en grootste hut van het dorp af. Zij waarschuwden
hen echter niet te gaan slapen, daar het zou kunnen gebeuren, dat de
Kenaima’s nog dien zelfden nacht een aanval op het dorp zouden doen.

Maar de Caraïben, vermoeid van hun langen tocht, hadden rust noodig
en de piaiman gelastte, dat, terwijl tien man sliepen, de overigen
zouden waken. Daartoe moesten zij langwerpige kijkgaten in de
wanden der hut maken.

Om negen uur des avonds verschenen werkelijk de Kenaima’s 105.

Onhoorbaar als slangen kropen ze over den [179]grond. Het gelukte hen
echter niet, de Kalienja’s te verrassen. Integendeel, toen zij de hut
genaderd waren, werden zij van uit de kijkgaten door een hagelbui van
pijlen begroet, zoodat zij genoodzaakt waren, zich in allerijl in het bosch
terug te trekken. De Caraïben achtervolgden hen en slaagden er in,
velen te dooden.

De piaiman, die onmiddellijk geraadpleegd werd, vond evenwel, dat,

hoe goede vrienden de Macoesi’s ook waren, hun land veel te
gevaarlijk voor een Kalienja was, zoodat tot den terugtocht besloten
werd.

Maar nauwelijks op weg, bleek het, dat de Kalienja’s door talrijke

Kenaima’s achtervolgd werden. De piaiman gelastte onmiddellijk, dat
allen zouden beginnen te zingen, te lachen en pijlen af te schieten, om
de vervolgers in den waan te brengen, dat zij met een groot leger te
doen hadden. Deze list gelukte uitstekend en zingende en lachende
bereikten de Kalienja’s de Corantijn. Toen eerst konden zij uitrusten,
want de Kenaima’s waren niet in staat—waarom weet men niet—de
Corantijn over te steken 106, en nu nog, zoo besluit de legende, kunnen
deze Kenaima’s het hollandsche grondgebied niet binnendringen,
omdat allen ongedoopte heidenen zijn!

No. 43. Legende van Paramaribo.

Penalo ame weipiompo. Eertijds, voor nog de grootvader van mijn

grootmoeder geboren was, werden de oevers der Suriname-rivier door
talrijke Caraïben bewoond, die gelukkig en tevreden met elkander
leefden tot op een [180]goeden dag een schip de rivier binnenzeilde en
het anker liet vallen vóór de plaats, waar thans het fort Zeelandia staat.
De kapitein kwam aan wal en werd vriendelijk door de Indianen
ontvangen. „Ik ben door mijn Koning gezonden”, zei hij, „om U in zijn
naam om dit land te verzoeken”. „Neen”, antwoordde de hoofdman,
„laat hem zelf komen, want wij onderhandelen niet met
ondergeschikten”.

Wat de kapitein ook deed, het Indiaansche opperhoofd liet zich niet
bepraten. Hij vertrok dan ook en keerde na eenigen tijd met den koning
terug. Deze begon niet terstond met de Indianen te onderhandelen,
doch liet hen eerst flink drinken. Toen allen dan ook smoordronken
waren, vroeg hij hun: „geef mij dit land ten geschenke”. En zij
antwoordden: „Neem het vriend, maar geef ons drank”.

Toen de Roodhuiden, na hun roes te hebben uitgeslapen, beseften, wat

ze hadden gedaan, kregen zij berouw. Maar het was te laat, het
eenmaal gegeven woord mocht niet verbroken worden.
De koning bouwde nu een huis naast de plaats, waar thans de
Sommelsdijksche kreek, die bij de Caraïben Paramoeloe heet, in de
Suriname-rivier uitloopt. Later kwamen er meer blanken en zoo
ontstond de stad Paramaribo. 107

No. 44. De Legende van Post Sommelsdijk.

Eertijds werden de negerslaven door de blanken gruwelijk mishandeld,

zoodat zij in menigte naar de bosschen vluchtten, waar zij de
bescherming inriepen van Konokokoeja*, de Geestmoeder der wouden.
Deze verhoorde [181]hunne smeekbeden en kwam tot hen in de
gedaante van een Indiaanschen piaiman. „Ik zal u uit de handen der
blanken redden,” sprak zij, „maar gij moet mijne bevelen trouw
opvolgen.”

De negers stemden toe. De geestenbezweerder piaaide toen den

omtrek op zoodanige wijze, dat er overal vergiftige pijlen te voorschijn
kwamen, die allen met hunne punten naar ééne richting toewezen.
Vervolgens trok zij naar de plantage Asati en bevrijdde veertig negers.

De blanken waren woedend. Onder commando van een kapitein

zonden zij soldaten, om de weggeloopen slaven te achterhalen, die
echter door den Piaiman veilig voorbij de vergiftigde pijlen waren geleid.
Toen nu de soldaten verschenen, trad deze te voorschijn en schoot met
een swaroedaroe* den kapitein dood.

Onder de blanken ontstond nu een hevige paniek. Zij vluchtten naar alle
richtingen; overal floten onzichtbare pijlen 108, door onzichtbare strijders
afgeschoten, door de lucht, waardoor vele soldaten gedood werden.

De negers en hunne bondgenooten namen nu alles wat de blanken

hadden achtergelaten, mede, en daaronder bevond zich ook een groote
pot. Onmiddellijk togen piaiman en obiaman* nu gezamenlijk aan het
werk en bereidden uit de lichamen der gevallen blanken een obiapiaai*
van zulk een sterkte als nog nooit te voren was bereid. Met dit
toovermiddel vulden zij den pot, die vooraf met den naam Konoko-
dakodwada* gedoopt was.

Negers en Indianen trokken nu naar Saloewa, een arm der

Mapanakreek, en zetten daar den pot zóó neêr, dat de opening naar de
monding der kreek wees, zoodat al de tooverij den blanken zou
toestroomen, wanneer zij het zouden wagen, hier binnen te dringen.
[182]

Het gebeurde werkelijk zoo, want toen de blanken, vol woede over den
dood hunner kameraden, de kreek wilden opvaren, werden hunne
oogen verduisterd door het toovermiddel, zoodat zij de monding van het
kreekje niet konden zien.

Konokokoeja leidde daarop de negers naar Pramaka, waar de blanken

hen nimmer hebben kunnen bereiken, maar alvorens zich weêr in het
bosch terug te trekken, zei de Geestmoeder der wouden tot de
Indianen, die de slaven zoo goed geholpen hadden: „Alle menschen,
die in huizen wonen, van den Gouverneur tot den laagsten neger, zijn
slaven. Alleen zij, die in kampen in het woud en op de savanne* wonen,
zijn vrije, onafhankelijke menschen.” 109

Dit is de reden, waarom de Indianen nimmer huizen hebben gebouwd,

maar zich met eenvoudige hutten vergenoegen.

No. 45. Einde van den Indiaanschen broederoorlog. (A.)

Wij, Arowakken hebben in den strijd met de Kalienja’s het laatste woord
gehad. Eens was het, dat wij onze vijanden in een hinderlaag wisten te
lokken. Boven een waterval hadden wij drijvende boomstammen
geplaatst, waarachter een deel onzer strijders verborgen was, terwijl de
overigen zich langs den oever verscholen hadden.

Toen nu de Caraïben, na met veel moeite hunne booten langs den

waterval naar boven te hebben gesleept, de vaartuigen weêr te water
lieten, zagen zij opeens tot hunne verbazing boomstammen aandrijven,
en wel met zulk een geweld, dat de booten zonken. Woeste kreten
weerklonken op hetzelfde oogenblik van den oever, gevolgd door een
[183]hagelbui van vergiftige pijlen. Wie niet getroffen werd, geraakte in
den bruisenden waterval.

Slechts een gewonde jongeling ontsnapte. Tot zijn stamgenooten

teruggekeerd, gaf hij hun den raad, den strijd op te geven. Den
volgenden dag trokken de overgebleven Caraïben met omhoog
gehouden pijlen den Arowakken tegemoet, en er werd vrede gesloten.
En zoo eindigde de laatste der Indiaansche broederoorlogen. 110

No. 46. De groote bloedzuigende vleermuis. (A.)

Op een lange reis naar het land der steenen bijlen* kwam een groote
boot, geheel gevuld met Indianen, van een landingsplaats. Deze
bevond zich in het gebied van den vleermuizenstam, zoodat de oude
man, die het gezelschap leidde, zijn bende op het hart drukte, hunne
hangmatten niet tusschen de boomen op te hangen (zooals de Indianen
in den drogen tijd gewoon zijn te doen), omdat de vleermuizen er
buitengewoon groot waren. Hij ried den mannen daarom aan, een
gesloten tijdelijke hut te bouwen, dus een aan alle kanten gesloten
banab*. Een der jongeren, die wat vadsig was uitgevallen, had er geen
lust in, de anderen met den bouw van de schuilplaats te helpen. Hij
beweerde, dat hij het niet geloofde, dat de vleermuizen, al waren zij ook
nog zoo groot, hem vóór het aanbreken van den dag iets zouden doen.
Tegen de redeneeringen van den ouden man in, weigerde hij in de hut
te kruipen, en nadat hij zijn hangmat tusschen twee boomen had
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

textbookfull.com