Project Wolframe

The simpleform language has 3 commands:

Structures in FORM or STRUCT declarations are defined as list of elements in curly brackets '{' '}'.

The following example shows an empty structure declaration

STRUCT myStructure
{
}
	

The following example shows an empty form declaration

FORM myDocumentSchema
{
}
	

An element in the list is either a declaration of a substructure or an atomic element. The elements are separated by comma ',' or end of line.

The following example shows a structure that is a list with 3 elements separated by end of line

{
    number int
    name string
    id int
}
		

And the same example with a comma as element separator

{
    number int, name string, id int
}
		

An element starts with an identifier, the name of the element. The name is followed by some special characters defining the element attributes and the element type. The element attributes will be described later. The element type is either an embedded substructure in '{' '}' brackets or an identifier naming an atomic type or a substructure declared previously as a STRUCT.

Here is an example with a embedded substructure

{
    number int
    name string
    address {
        street string, country string
    }
}
		

Embedded substructure declarations follow recursively the same rules as structures defined here.

Named types referencing atomic types can be followed by an assignment operator '=' and a string that declared a default value initialization of the structure element. Here is an example with a default value assignment

{
    number int = 1
    name string
}
		

The atomic element type names are either the reserved keyword string or a type defined as sequence of normalizer functions in a normalize definition file. The normalizer functions assigned to a type validate the value and transform it to its normalized form. The next section will explain how data types are defined.

The element attributes are marked with some special characters listed and explained in the following table:

Non contradicting attributes can be combined:

id ?@int = 1
		

Using a single underscore '_' as atomic element name means that the atomic element is representing the unnamed content value of the structure. Using a single underscore for a substructure means that the substructure is embedded into the structure without being referenceable by name. The embedding into a structure is used to express inheritance.

Here is an example with embedding of a named structure

STRUCT content
{
    name string
    birth string
}

FORM insertedContent
{
    id int
    _ content
}
		

Document meta data in FORM definitions are declared after the form declaration header and before the form structure declaration. A meta data declaration starts with a dash '-' followed by the meta data attribute name as identifier or string and the value as string.

Here is an example of a form with meta data declarations

FORM myDoc
    -root = 'doc', -schemaLocation = 'http://bla.com/schema'
{
}
		

or with end of line as attribute separator

FORM myDoc
    -root = 'doc'
    -schemaLocation = 'http://bla.com/schema'
{
}
		

Now all elements of simpleform are explained. Here is an example that shows a complete form definition in simpleform DDL.

		
FORM Customer
	-root customer
{
    ID !@int                  ; Internal customer id (mandatory)
    name string               ; Name of the customer
    canonical_Name string     ; Customer name in canonical form
    country string            ; Country
    locality ?string          ; Locality (optional)
}

		

Each type declaration in a .wnmp file starts with an identifier followed by an assignment operator '='. The left side identifier specifies the name of the type. This type name can be used in a DDL as name instead of the built-in type string. A token of this type is validated and normalized with the comma separated sequence of normalizer references on the right side of the assignment. A normalizer reference consists of an identifier plus an optional comma separated list of constant arguments in brackets ('(' and ')'). The interpretation of the arguments depend on the function type. An integer type for example could have the maximum number of digits of the integer type.

There are some standard modules you can use when you define your own type system. They are delivered with Wolframe: