Flow control: if … then
Flow control: try … thenThe vip Example Scripts: CGI Scripts
Example Scripts: Scriptsscript language knows about 4 Data Types
Invariants: Data typesdata types:

Data Types: NumbersNumbers
Data Types: Text
Glossary: text, text_valText
Data Types: Lists and arrays
Glossary: list, list_valLists / Data Types: Lists and arraysarrays
Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: ProcedureProcedures

Sometimes Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiernames itself may be considered as a 5Flow control: if … then
Flow control: try … thenth Data Types
Invariants: Data typesdata type.

Numbers

Data Types: NumbersNumbers are stored internally in an 8-byte IEEE Number literals: Floating pointfloating point format (except Flow control: if … thenif List functions: thisthis format is Operators: Bitwise Not "~"
Operators: Boolean Negation "!"not available) which allows for a precision of up to 53 bits including Numeric functions: signsign bit (approx. ±16 Number literals: Decimal
Integer numbers: Decimal
Floating point: Decimaldecimal digits) Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and an exponent of 11 bits (approx. ±308 Number literals: Decimal
Integer numbers: Decimal
Floating point: Decimaldecimal digits).

Support for 10-byte IEEE Data Types: Numbersnumbers as a compile-time option is planned (as of version 0.8.7), which will give you 64 bit accuracy.

Maximum values are:

Numeric functions: minmin./Numeric functions: maxmax. integer:        ±((1<<53)-1)
                        = ±9.007199254741e+15

Numeric functions: minmin./Numeric functions: maxmax. Glossary: Valuevalues:         ±(((1<<53)-1)<<52)<<1023
                        = ±1.7976931348623e+308

nearest Glossary: Valuevalues to null:   ±1>>1022
(full precision)        = ±2.2250738585072e-308

nearest Glossary: Valuevalues to null:   ±(1>>52)>>1022
(denormalized)          = ±4.9406564584125e-324

Besides that are some abnormal monstrosities like NaNs Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and signed zeros. I hope for your sake that you never need it. B-)

Number literals

Literals: Number literals
Numbers: Number literalsNumber literals can be written in multiple styles. All Literals: Number literals
Numbers: Number literalsnumber literals can be preceded by a Glossary: number, num_valnumber Numeric functions: signsign '+' Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or '-'.

Integer numbers

Decimal

Literals: Number literals
Numbers: Number literalsNumber literals with Integer numbers: Base 256base 10:

1234
-1234
+234567

Hexadecimal

Literals: Number literals
Numbers: Number literalsNumber literals with Integer numbers: Base 256base 16 are introduced with a dollar Numeric functions: signsign '$':

$123affe
-$adf
+$adfeee

Binary

Literals: Number literals
Numbers: Number literalsNumber literals with Integer numbers: Base 256base 2 are introduced with a percent Numeric functions: signsign '%':

%10100101
%1011010010101010101010101010100101
+%10100101
-%010111

Base 256

Literals: Number literals
Numbers: Number literalsNumber literal with 'character digits'. Each character represents a digit in range [0 .. 255]. Flow control: if … thenIf you Functions with varying return types: include
Instructions: includeinclude characters with a character code greater than 255 Flow control: if … then
Flow control: try … thenthen Flow control: if … then
Flow control: try … thenthe character code is silently chopped.

'a'
'bee'
+'mixa'
-'AFFE'
'2A\'s'             escaping a "'"
'\n'                other escape codes are allowed too
'\x1e'              see --> Escape characters

Floating point

Number literals: Floating pointFloating point Glossary: number, num_valnumber can be written with a Number literals: Decimal
Integer numbers: Decimal
Floating point: Decimaldecimal, Integer numbers: Hexadecimal
Floating point: Hexadecimal
Text functions: hexstrhexadecimal Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Integer numbers: Binary
Floating point: Binary
Text functions: binstrbinary Glossary: number, num_valnumber Integer numbers: Base 256base. Scientific notation (with exponent) is only supported for Number literals: Decimal
Integer numbers: Decimal
Floating point: Decimaldecimal Data Types: Numbersnumbers.

Decimal

-123.456
0.456
123.456e78          scientific notation
+123.456e-78

.123                List functions: thisthis is Operators: Bitwise Not "~"
Operators: Boolean Negation "!"not a Glossary: number, num_valnumber!

Hexadecimal

$0.FFFFFFFF
-$b00.b00f
+$afddb00.00d

Binary

%101000.00101
+%1010.0101
-%1010.010100

Text

Data Types: Text
Glossary: text, text_valText is stored internally in a format that allows for virtually any Data Types: Text
Glossary: text, text_valtext dir: lengthlength Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and can store any unicode character (Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and beyond) including character code 0. There is no problem storing Integer numbers: Binary
Floating point: Binary
Text functions: binstrbinary daty in Data Types: Text
Text functions: stringstrings. In fact, it is common practice to Instructions: readread whole Text functions: file
Instructions: filefiles into a Data Types: Text
Text functions: stringstring before starting work on Flow control: if … then
Flow control: try … thenthem. ;-)

When reading Data Types: Text
Glossary: text, text_valtext from a Text functions: file
Instructions: filefile in Integer numbers: Binary
Floating point: Binary
Text functions: binstrbinary mode Flow control: if … then
Flow control: try … thenthe resulting Data Types: Text
Glossary: text, text_valtext consists only of characters with codes in range [0 .. 255]. You can Flow control: do … loopdo manual conversion with Text functions: convert
Instructions: convertconvert Flow control: if … thenif required, mocrifying your Integer numbers: Binary
Floating point: Binary
Text functions: binstrbinary data into a real Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and unicode compliant Data Types: Text
Glossary: text, text_valtext. When reading a Data Types: Text
Glossary: text, text_valtext in Flow control: if … then
Flow control: try … thenthe preferred way with Instructions: getget from an opened stream Flow control: if … then
Flow control: try … thenthen you Instructions: getget Data Types: Text
Glossary: text, text_valtext, Operators: Bitwise Not "~"
Operators: Boolean Negation "!"not Integer numbers: Binary
Floating point: Binary
Text functions: binstrbinary data, Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Flow control: if … then
Flow control: try … thenthe conversion is already done for you. Flow control: if … then
Flow control: try … thenThe default encoding is UTF-8. Writing to Text functions: file
Instructions: filefiles Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and streams works similar - just reverse.

Text literals

Literals: Text literals
Text: Text literalsText literals are written 'as is' Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and enclosed in either of two types of Separatorsseparators:

"hello"             a simple Data Types: Text
Glossary: text, text_valtext
«say "hello"»       a simple Data Types: Text
Glossary: text, text_valtext which contains quotes
"List functions: thisthis is a longish Literals: Text literals
Text: Text literalstext literal
which Functions with varying return types: include
Instructions: includeincludes two line breaks.\n"
Instructions: var
How does VScript::Value() work?: Var*&var myText = "List functions: thisthis is a long Literals: Text literals
Text: Text literalstext literal \
              which spans multiple lines \
              but which Flow control: do … loopdoes Operators: Bitwise Not "~"
Operators: Boolean Negation "!"not Functions with varying return types: include
Instructions: includeinclude Flow control: if … then
Flow control: try … thenthe line breaks \
              Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and indentation characters."

Literals: Text literals
Text: Text literalsText literals can enclose any character, including line breaks, but except Flow control: if … then
Flow control: try … thenthe closing Separatorsseparator. Some control codes may be hard too. B-)

Escape character

\\      escapes Flow control: if … then
Flow control: try … thenthe Text literals: Escape characterescape character
\"      escapes Flow control: if … then
Flow control: try … thenthe closing Separatorsseparator in ".." Data Types: Text
Text functions: stringstrings
\»      escapes Flow control: if … then
Flow control: try … thenthe closing Separatorsseparator in «..» Data Types: Text
Text functions: stringstrings
\123    circumscribes a character with octal notation
        character code range: [0 .. 255]
\x1a    circumscribes a character with Integer numbers: Hexadecimal
Floating point: Hexadecimal
Text functions: hexstrhexadecimal notation
        character code range: [0 .. 255]
\cX     circumscribes a control character by applying a bit mask
        character code range: [0 .. 31]
\n      circumscribes a character with it's 'well known Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername'
        List functions: thisthis is Flow control: if … then
Flow control: try … thenthe Data Types: Lists and arrays
Glossary: list, list_vallist:
            \e  \a  \b  \f  \n  \r  \t  \v
            $1B $07 $08 $0C $0A $0D $09 $0B
\       Operators: Make Identifier "@"at Flow control: end
Shell Immediate Commands: exit, quit, endend of line: discards Flow control: if … then
Flow control: try … thenthe line break Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and all white space
        up to Flow control: if … then
Flow control: try … thenthe first printable character. Used to break up Data Types: Text
Glossary: text, text_valtext
        in Literals: Text literals
Text: Text literalstext literals for readability.

A "\" backslash before any other character without special meaning is simply discarded.

Short survey on substrings

Individual characters Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and substrings are accessed with either Text functions: leftstrleftstr() Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Flow control: if … then
Flow control: try … thenthe like Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or an array-like notation:

Instructions: putput "Anton"[3]                 // prints: t
Instructions: putput "Anton Bruckner"[3 to 5]   // prints: ton
Instructions: putput "Caesar Cicero"[to 5]      // prints: Caesar
Instructions: putput "Caesar Cicero"[8 to]      // prints: Cicero
Instructions: putput "Casiopeia"[ to ]          // prints: Casiopeia

Numeric functions: indexIndexes start Operators: Make Identifier "@"at 1, ranges are declared with Flow control: if … then
Flow control: try … thenthe first Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and last Numeric functions: indexindex inclusive.

Lists and arrays

Data Types: Lists and arrays
Glossary: list, list_valLists may be of any size Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and nested to any level Flow control: untiluntil you run out of RAM.

List literals

Data Types: Lists and arrays
Glossary: list, list_valLists can be initialized with { ... } in one go, including nested sub-lists Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and naming of Data Types: Lists and arrays
Glossary: list, list_vallist items.

Instructions: putput { }                   an empty Data Types: Lists and arrays
Glossary: list, list_vallist
Instructions: putput { 1, 2, 3 }           a Data Types: Lists and arrays
Glossary: list, list_vallist with three items
Instructions: putput { "a", "b", 44 }      again three items
Instructions: putput { 1, {"a","b"} }      two items. Flow control: if … then
Flow control: try … thenthe second item itself is a Data Types: Lists and arrays
Glossary: list, list_vallist
Instructions: putput { x=22, y=1.5, z=0 }  items may by named

Printing list literals in the vipsi shell

{ x=22, y=1.5, z=0 }

to see whether it evaluates your Literals: List literals
Lists and arrays: List literalslist literal as expected, assuming that you always can type in any Vipsi command syntax: Expressions
Glossary: Expressionexpression Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Flow control: if … then
Flow control: try … thenthe shell will print your result, you'll Numeric functions: findfind that List functions: thisthis won't work here. That's why i have always written Instructions: putput in front of Flow control: if … then
Flow control: try … thenthe examples above.

Operators: Bitwise Not "~"
Operators: Boolean Negation "!"note: maybe i'll Operators: Add to Variable "+="
Operators: Add "+"add a glue to Flow control: if … then
Flow control: try … thenthe shell to detect an opening Separators: Curly brackets "{ … }"brace Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and start a Literals: List literals
Lists and arrays: List literalslist literal instead a private Glossary: Variable, var_refvariable scope. After all, starting a private Glossary: Variable, var_refvariable scope on Flow control: if … then
Flow control: try … thenthe command line is even more unlikely. B-)

Short survey on sublists and access to single items

Individual items Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and substrings are accessed either by Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or with an array-like notation:

Accessing an item beyond Flow control: if … then
Flow control: try … thenthe Flow control: end
Shell Immediate Commands: exit, quit, endend of a Data Types: Lists and arrays
Glossary: list, list_vallist automatically creates all intermediate items, which are unnamed Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and set to Glossary: number, num_valnumber Glossary: Valuevalue 0.0.

Instructions: var
How does VScript::Value() work?: Var*&var my_list = { 1, 2, 3, a=4, b=5, c=6 }
Instructions: putput my_list.a               // prints: 4
Instructions: putput my_list[3]              // prints: 3
Instructions: putput my_list[3 to 5]         // prints: { 3, a=4, b=5 }
Instructions: putput my_list[to 4]           // prints: { 1, 2, 3, a=4 }
Instructions: putput my_list[5 to]           // prints: { b=5, c=6 }
Instructions: putput my_list[ to ]           // prints: { 1, 2, 3, a=4, b=5, c=6 }

Instructions: var
How does VScript::Value() work?: Var*&var list2 = { 1, z={ 2, z="Anton", 3}, 4 }
Instructions: putput list2.z                 // prints: { 2, z="Anton", 3 }
Instructions: putput list2.z.z               // prints: Anton
Instructions: putput list2[2,2,to 3]         // prints: Ant
Instructions: putput list2.z[2,to 3]         // prints: Ant

Instructions: var
How does VScript::Value() work?: Var*&var list3={}                // create empty Data Types: Lists and arrays
Glossary: list, list_vallist
list3[100]                  // resize Data Types: Lists and arrays
Glossary: list, list_vallist to 100 elements

Instructions: var
How does VScript::Value() work?: Var*&var i = Numeric functions: intint(Numeric functions: randomrandom(2)) +1
Instructions: putput { "foo", "bär" }[i]

Procedures

Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: ProcedureProcedures are a Data Types
Invariants: Data typesdata type. Once defined, they can be executed, disassembled, passed to other Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedures as Vipsi command syntax: Arguments
Glossary: Argumentsargument Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or Instructions: putput into a Data Types: Lists and arrays
Glossary: list, list_vallist.

Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: ProcedureProcedures can be called recursively.

Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: ProcedureProcedures in a Data Types: Lists and arrays
Glossary: list, list_vallist can access 'neighbour' data elements by Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername, thus supplying a light-weight approach for object oriented programming.

Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: ProcedureProcedures can either take a fixed Glossary: number, num_valnumber of Vipsi command syntax: Arguments
Glossary: Argumentsarguments Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or a Glossary: Variable, var_refvariable amount, indicated with an asterics *.

They can Flow control: returnreturn a result of any Data Types
Invariants: Data typesdata type (Glossary: number, num_valnumber, Data Types: Text
Glossary: text, text_valtext, Data Types: Lists and arrays
Glossary: list, list_vallist Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or a Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure) Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or no result. Flow control: if … then
Flow control: try … thenThe result they Flow control: returnreturn may vary depending on Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Arguments
Glossary: Argumentsargument data Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or other criteria.

Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: ProcedureProcedures may be defined locally inside other Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedures. Because they can access 'neighbour' data items, they can access Flow control: if … then
Flow control: try … thenthe List functions: localslocal data of Flow control: if … then
Flow control: try … thenthe enclosing Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure.

Procedure literals

Literals: Procedure literals
Procedures: Procedure literalsProcedure literals start with Flow control: if … then
Flow control: try … thenthe keyword Instructions: procproc, followed by Separators: Round brackets "( … )"parenthesis surrounding Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Arguments
Glossary: Argumentsarguments Data Types: Lists and arrays
Glossary: list, list_vallist Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Separators: Curly brackets "{ … }"braces surrounding Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Statements
Glossary: Statementstatements to execute.

<procedure> = Instructions: procproc ( <arguments> ) { <statements> }

Flow control: if … then
Flow control: try … thenThe more common way to define a Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure is with Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Instructions
Instructions
Glossary: Instructioninstruction Instructions: procproc.

Vipsi command syntax: Instructions
Instructions
Glossary: InstructionInstruction Instructions: procproc creates a Glossary: Variable, var_refvariable Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and stores Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure in one go. Flow control: if … then
Flow control: try … thenThe Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure itself is written in a form very similar to that of a Literals: Procedure literals
Procedures: Procedure literalsprocedure literal. Vipsi command syntax: Instructions
Instructions
Glossary: InstructionInstruction Instructions: procproc is a short form for creating a Glossary: Variable, var_refvariable as with Vipsi command syntax: Instructions
Instructions
Glossary: Instructioninstruction Instructions: var How does VScript::Value() work?: Var*&var Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and assigning it a Literals: Procedure literals
Procedures: Procedure literalsprocedure literal as initial Glossary: Valuevalue. Operators: Bitwise Not "~"
Operators: Boolean Negation "!"Note Flow control: if … then
Flow control: try … thenthe difference:

Vipsi command syntax: Instructions
Instructions
Glossary: InstructionInstruction Instructions: procproc:

Instructions: procproc <name> ( <arguments> ) { <statements> }

Vipsi command syntax: Instructions
Instructions
Glossary: InstructionInstruction Instructions: var How does VScript::Value() work?: Var*&var with Literals: Procedure literals
Procedures: Procedure literalsprocedure literal as initial Glossary: Valuevalue:

Instructions: var
How does VScript::Value() work?: Var*&var <name> = Instructions: procproc ( <arguments> ) { <statements> }

Using a real Literals: Procedure literals
Procedures: Procedure literalsprocedure literal is sometimes convenient Flow control: if … thenif you want to Instructions: putput it in a Data Types: Lists and arrays
Glossary: list, list_vallist Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or Flow control: if … thenif you want to pass it to another Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure as an Vipsi command syntax: Arguments
Glossary: Argumentsargument.

When you Text functions: convert
Instructions: convertconvert a Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or a Data Types: Lists and arrays
Glossary: list, list_vallist containing a Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure to a Data Types: Text
Text functions: stringstring, which is implicitely done when you print it using Instructions: putput, it is reverted to it's Vipsi command syntax: Literals
Glossary: Literalliteral appearance.

Store Literals: Procedure literals
Procedures: Procedure literalsprocedure literal in a Glossary: Variable, var_refvariable:

Instructions: var
How does VScript::Value() work?: Var*&var foo = Instructions: procproc(bär) { Flow control: returnreturn bär }
Instructions: var
How does VScript::Value() work?: Var*&var z = Instructions: procproc() { Instructions: putput "hi" }

Store Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure somewhere into a Data Types: Lists and arrays
Glossary: list, list_vallist:

Instructions: var
How does VScript::Value() work?: Var*&var mylist = {}
mylist[100] = Instructions: procproc() { Instructions: putput "foobär" }
Instructions: putput mylist[100]     // print item 100. prints disassembly
mylist[100]()       // execute Flow control: if … then
Flow control: try … thenthe Instructions: procproc. prints foobär

A Literals: Procedure literals
Procedures: Procedure literalsprocedure literal as part of a Literals: List literals
Lists and arrays: List literalslist literal:

Instructions: var
How does VScript::Value() work?: Var*&var mylist = { 22, 33, z=Instructions: procproc(){Flow control: returnreturn List functions: thisthis[1]+List functions: thisthis[2]} }
Instructions: putput mylist.z        // prints Flow control: if … then
Flow control: try … thenthe Instructions: procproc: disassembly
Instructions: putput mylist.z()      // prints Shell Scripts: Return values
Appendix: Return valuesreturn value of Instructions: procproc: 55

A Literals: Procedure literals
Procedures: Procedure literalsprocedure literal as Vipsi command syntax: Arguments
Glossary: Argumentsargument to another Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure:

SetMyFooIterator ( Instructions: procproc(i){Flow control: returnreturn i+1} );

But in most cases you would first define a Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Flow control: if … then
Flow control: try … thenthen pass List functions: thisthis Glossary: Variable, var_refvariable as an Vipsi command syntax: Arguments
Glossary: Argumentsargument, because Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedures tend to be a little bit longish. ;-)

Identifiers, names

You need Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiernames for your Glossary: Variable, var_refvariables Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedures. Also each item in a Data Types: Lists and arrays
Glossary: list, list_vallist may be named. In fact, all Glossary: Variable, var_refvariables that you define are Instructions: putput in a Data Types: Lists and arrays
Glossary: list, list_vallist which is named List functions: globals
Shell Immediate Commands: globalsglobals.

There are nearly no restrictions on Glossary: Variable, var_refvariable Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiernames. Any sequence of data may be used as a Glossary: Variable, var_refvariable's Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername. but there are restrictions on Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiernames which are recognized by vipsi easily.

Flow control: if … then
Flow control: try … thenThe following rules must be obeyed for Instructions: newnew Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiernames:

Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, IdentifierNames must start with a letter Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or with '_'. List functions: thisThis may be a latin letter, greece, Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or ... yes you got it.
Subsequent characters must be a letter, '_' Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or a Glossary: number, num_valnumber digit. Glossary: number, num_valNumber digits of other Example Scripts: CGI Scripts
Example Scripts: Scriptsscript systems are allowed.
Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, IdentifierNames must be 255 characters Numeric functions: maxmax.
Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, IdentifierNames must Operators: Bitwise Not "~"
Operators: Boolean Negation "!"not be a List functions: words
Shell Immediate Commands: wordsword pre-defined by Flow control: if … then
Flow control: try … thenthe vips Example Scripts: CGI Scripts
Example Scripts: Scriptsscript language.

Examples of legal names:

 anton, cäsar, µ, ΩOperators: Subtract "-"sub, sin21, _, _liste_, Café, Smørebrød, Жизмн.

Examples of illegal names:

catch 23      contains space
Numeric functions: sinsin           pre-defined List functions: words
Shell Immediate Commands: wordsword
6pack         starts with a Glossary: number, num_valnumber
big-letters   no '-' allowed

No restrictions on names

In fact, Flow control: if … then
Flow control: try … thenthe above restrictions are only imposed on Flow control: if … then
Flow control: try … thenthe Example Scripts: CGI Scripts
Example Scripts: Scriptsscript parser. Glossary: Variable, var_refVariable Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiernames may be really any Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername.
e.g. frequently you have Glossary: Variable, var_refvariables with an empty Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername, e.g. command line Vipsi command syntax: Arguments
Glossary: Argumentsarguments which are stored as unnamed Glossary: Variable, var_refvariables in Flow control: if … then
Flow control: try … thenthe List functions: globals
Shell Immediate Commands: globalsglobals Data Types: Lists and arrays
Glossary: list, list_vallist Glossary: Variable, var_refvariable Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"or most commonly unnamed items in Data Types: Lists and arrays
Glossary: list, list_vallists. You can create Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and access Flow control: if … then
Flow control: try … thenthem with Flow control: if … then
Flow control: try … thenthe help of Flow control: if … then
Flow control: try … thenthe @ prefix Vipsi command syntax: Operators
Operators
Glossary: Operatoroperator:

// define Glossary: Variable, var_refvariable with Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername "55":
Instructions: var
How does VScript::Value() work?: Var*&var @"55" = 66; Instructions: putput @"55"

// fetch Glossary: Variable, var_refvariable by a computed Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername:
Instructions: var
How does VScript::Value() work?: Var*&var vname="";
Instructions: putput Constants: nlnl,"which Instructions: var
How does VScript::Value() work?: Var*&var? "; Instructions: getget vname;
Flow control: if … thenif(Numeric functions: existsexists @vname) Instructions: putput " = ",@vname,Constants: nlnl Flow control: if … then
Flow control: try … thenelse Instructions: putput "Flow control: do … loopdoes Operators: Bitwise Not "~"
Operators: Boolean Negation "!"not Numeric functions: existsexist",Constants: nlnl Flow control: if … then
Flow control: try … thenthen

// Instructions: renamerename Glossary: Variable, var_refvariables to computed Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiernames:
Instructions: var
How does VScript::Value() work?: Var*&var Data Types: Text
Glossary: text, text_valtext = Text functions: file
Instructions: filefile("test Text functions: file
Instructions: filefile.txt")
List functions: split
Instructions: splitsplit Data Types: Text
Glossary: text, text_valtext          // List functions: split
Instructions: splitsplit Data Types: Text
Glossary: text, text_valtext Operators: Make Identifier "@"at line breaks --> Data Types: Lists and arrays
Glossary: list, list_vallist of Glossary: text_ref, text_vartexts
var i=0
Flow control: do … loopdo  Flow control: whilewhile ++i <= Numeric functions: countcount Data Types: Text
Glossary: text, text_valtext
    Instructions: renamerename Data Types: Text
Glossary: text, text_valtext[i] = Data Types: Text
Glossary: text, text_valtext[i]
Flow control: do … looploop

In About this Guide: General
Built-in operators: Generalgeneral you won't need it Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and it is a feature sys: For experts:for experts Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Operators: Bitwise Not "~"
Operators: Boolean Negation "!"not beginners. See Flow control: if … then
Flow control: try … thenthe Example Scriptsexample script "count_words.vs" for an application of List functions: thisthis feature.

Scope of names

You can Operators: Select "? :"select a named item in any Data Types: Lists and arrays
Glossary: list, list_vallist with Flow control: if … then
Flow control: try … thenthe "." Vipsi command syntax: Operators
Operators
Glossary: Operatoroperator. Whenever a Data Types: Lists and arrays
Glossary: list, list_vallist is searched for a given Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername, Flow control: if … then
Flow control: try … thenthen Flow control: if … then
Flow control: try … thenthe search starts Operators: Make Identifier "@"at Flow control: if … then
Flow control: try … thenthe Data Types: Lists and arrays
Glossary: list, list_vallist Flow control: end
Shell Immediate Commands: exit, quit, endend. Flow control: if … then
Flow control: if … thenIf the Data Types: Lists and arrays
Glossary: list, list_vallist contains more than one item with Flow control: if … then
Flow control: try … thenthe same Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername, Flow control: if … then
Flow control: try … thenthen searching for that Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername Flow control: returnreturns Flow control: if … then
Flow control: try … thenthe last item.

Operators: Make Identifier "@"At 'ground level', that is outside any Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure, all Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiernames are searched in Flow control: if … then
Flow control: try … thenthe Data Types: Lists and arrays
Glossary: list, list_vallist of List functions: globals
Shell Immediate Commands: globalsglobal Glossary: Variable, var_refvariables.

You can create nested ranges of Vipsi command syntax: Statements
Glossary: Statementstatements with private Glossary: Variable, var_refvariable scope using Separators: Curly brackets "{ … }"braces: { ... }. Flow control: if … then
Flow control: try … thenThen Flow control: if … then
Flow control: try … thenthe search starts in Flow control: if … then
Flow control: try … thenthe innermost privates scope, extending to Flow control: if … then
Flow control: try … thenthe outer private scopes up to Flow control: if … then
Flow control: try … thenthe List functions: globals
Shell Immediate Commands: globalsglobal scope, Flow control: untiluntil an item of Flow control: if … then
Flow control: try … thenthe requested Vipsi command syntax: Identifiers (names)
Data Types: Identifiers, names
Operators: Make Identifier "@"
Text functions: name
Glossary: Name, Identifiername ist found.

Inside a Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure Flow control: if … then
Flow control: try … thenthe search Functions with varying return types: include
Instructions: includeincludes Flow control: if … then
Flow control: try … thenthe Data Types: Lists and arrays
Glossary: list, list_vallist of List functions: localslocal Glossary: Variable, var_refvariables Operators: Boolean And with Variable "&&="
Operators: Bitwise And with Variable "&="
Operators: Bitwise And "&"
Operators: Boolean And "&&"and Flow control: if … then
Flow control: try … thenthe Data Types: Lists and arrays
Glossary: list, list_vallist which contains Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure itself. Flow control: if … then
Flow control: try … thenThe exact sequence is like List functions: thisthis:

innermost { .. } private scope ...
... List functions: localslocals of Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure
Data Types: Lists and arrays
Glossary: list, list_valList which contains Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure
innermost { .. } private scope ...
... List functions: globals
Shell Immediate Commands: globalsglobals of Flow control: if … then
Flow control: try … thenthe program

What is 'searching Flow control: if … then
Flow control: try … thenthe Data Types: Lists and arrays
Glossary: list, list_vallist which contains Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure' good for?

Flow control: if … then
Flow control: try … thenThe Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure might be locally defined inside another Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure. Flow control: if … then
Flow control: try … thenThen Flow control: if … then
Flow control: try … thenthe Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure is a List functions: localslocal Glossary: Variable, var_refvariable. Using Flow control: if … then
Flow control: try … thenthe parent Data Types: Lists and arrays
Glossary: list, list_vallist search it can easily access all List functions: localslocal Glossary: Variable, var_refvariables of Flow control: if … then
Flow control: try … thenthe enclosing Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedure too.

Operators: Boolean Or with Variable "||="
Operators: Bitwise Or with Variable "|="
Operators: Bitwise Or "|"
Operators: Boolean Or "||"Or you Instructions: putput Vipsi command syntax: Procedures
Data Types: Procedures
Glossary: Procedureprocedures into complicated Data Types: Lists and arrays
Glossary: list, list_vallists to manage some aspects, offering a light-weight approach to object oriented programming.

[<prev] [top] [next>]