System Library

• Abstruct
• Index
• Structs
• Variables
• Functions
• Event Handler
• Implementation Code

Abstract

The VCSSL System library is a standard library providing fundamental functions that are essential for general use.

The System library is automatically loaded by the implementation before the target VCSSL program itself is loaded.For this reason, the System library can exceptionally be used without import.

Specific examples of functions in the System library include basic operations and conversions for variables and arrays,input and output with the user, file input and output, simple interaction with the file system,and execution of operating-system commands.Some of these also have more advanced and complex counterparts provided by standard libraries specialized for each field.The design concept of standard libraries in VCSSL assumes that, for simple uses, the functions of the System library are used by default,and when those are insufficient, specialized libraries are imported and used as needed.

In the System library, the naming rules of identifiers are also somewhat different from those of the other standard libraries, as an exception prioritizing convenience in simple use cases.In principle, identifiers in VCSSL standard libraries are named in lower camel case without abbreviating English words.However, in the System library, many abbreviated identifier names are adopted, shortening English words to reduce typing and supplementing meaning with prefixes or suffixes when necessary.

Index

const string VER

Represents the VCSSL version code supported by the implementation.

const string REV

Represents the development revision code of the implementation.

const complex I

The imaginary unit of the complex type.

const varcomplex VCI

The imaginary unit of the varcomplex type.

const float INF

The Inf, that is, infinity, value of the float type.

const float NAN

The NaN, that is, not-a-number, value of the float type. Note that NaN is not equal to any value. In other words, comparisons such as value == NAN cannot be used to determine whether a variable value is NaN. To test for NaN, use the nan function.

const float FLOAT_MAX

The maximum value of the float type.

const float FLOAT_MIN_ABS_NORMAL

The smallest non-zero positive value representable by the float type within the range of normalized numbers.

const float FLOAT_MIN_ABS_DENORMAL

The smallest non-zero positive value representable by the float type including the range of denormalized numbers.

const float FLOAT_MIN

Equivalent to FLOAT_MIN_ABS_DENORMAL.Because this shorter name is somewhat ambiguous in meaning and specification, use of the more explicit namesFLOAT_MIN_ABS_DENORMAL orFLOAT_MIN_ABS_NORMAL is generally recommended.

const int INT_MAX

The maximum value of the int type.

const int INT_MIN

The minimum value of the int type.

const string EOL

The environment-dependent newline code. It stores the value appropriate for the current environment, such as CR, LF, or CR+LF.

const string CR

The newline code CR, that is, 0x0D.

const string LF

The newline code LF, that is, 0x0A.

const string OS

A string for roughly distinguishing the type or generation of the operating system in the execution environment, usually the OS name. Note that numbers representing generations in product branding are often included in this OS name rather than treated as version numbers.

const string OSVER

A string useful as a reference when distinguishing the generation of the operating system in the execution environment, specifically information such as the OS development or internal version. Note that it may differ from the version used in product information for general users.

const string READ

The file input/output mode for reading. It is used by the open function.

const string WRITE

The file input/output mode for writing. It is used by the open function.

const string APPEND

The file input/output mode for append writing. It is used by the open function.

const string READ_TSV

The file input/output mode for TSV reading. It is used by the open function.

const string WRITE_TSV

The file input/output mode for TSV writing. It is used by the open function.

const string APPEND_TSV

The file input/output mode for TSV append writing. It is used by the open function.

const string READ_CSV

The file input/output mode for CSV reading. It is used by the open function.

const string WRITE_CSV

The file input/output mode for CSV writing. It is used by the open function.

const string APPEND_CSV

The file input/output mode for CSV append writing. It is used by the open function.

const string READ_BINARY

The file input/output mode for binary reading. It is used by the open function.

const string WRITE_BINARY

The file input/output mode for binary writing. It is used by the open function.

const string APPEND_BINARY

The file input/output mode for binary append writing. It is used by the open function.

const string STDIN

A special file path for using file input/output functions with standard input.

const string STDOUT

A special file path for using file input/output functions with standard output.

const string STDERR

A special file path for using file input/output functions with standard error output.

const int UP

A rounding mode that performs upward rounding by specifying the number of digits in the fractional part relative to zero, that is, the decimal part. It is used by the round function.

const int UP_SIGNIF

A rounding mode that performs upward rounding by specifying the number of digits in the significant part. It is used by the round function. This mode had been introduced experimentally as "UP" before VCSSL 3.3.

const int DOWN

A rounding mode that performs downward rounding by specifying the number of digits in the fractional part relative to zero, that is, the decimal part. It is used by the round function.

const int DOWN_SIGNIF

A rounding mode that performs downward rounding by specifying the number of digits in the significant part. It is used by the round function. This mode had been introduced experimentally as "DOWN" before VCSSL 3.3.

const int HALF_UP

A rounding mode that performs half-up rounding by specifying the number of digits in the fractional part relative to zero, that is, the decimal part. It is used by the round function.

const int HALF_UP_SIGNIF

A rounding mode that performs half-up rounding by specifying the number of digits in the significant part. It is used by the round function. This mode had been introduced experimentally as "HALF_UP" before VCSSL 3.3.

const int HALF_DOWN

A rounding mode that performs half-down rounding by specifying the number of digits in the fractional part relative to zero, that is, the decimal part. It is used by the round function.

const int HALF_DOWN_SIGNIF

A rounding mode that performs half-down rounding by specifying the number of digits in the significant part. It is used by the round function. This mode had been introduced experimentally as "HALF_DOWN" before VCSSL 3.3.

const int HALF_TO_EVEN

A rounding mode that performs half-to-even rounding by specifying the number of digits in the fractional part relative to zero, that is, the decimal part. It is used by the round function.

const int HALF_TO_EVEN_SIGNIF

A rounding mode that performs half-to-even rounding by specifying the number of digits in the significant part. It is used by the round function. This mode had been introduced experimentally as "HALF_EVEN" before VCSSL 3.3.

macro print(...)

Outputs strings to the console. The arguments may be of any type and are automatically converted to strings.If multiple arguments are specified, how they are formatted in the output depends on the implementation.Normally, they will probably be output separated by spaces.

macro println(...)

Outputs strings to the console and then outputs a newline. The arguments may be of any type and are automatically converted to strings.If multiple arguments are specified, how they are formatted in the output depends on the implementation.Normally, they will probably be output separated by spaces.

macro output(...)

Outputs strings to the area for displaying the processing result of the program.The arguments may be of any type and are automatically converted to strings.If multiple arguments are specified, how they are formatted in the output depends on the implementation.Normally, they will probably be output separated by spaces.

macro input(...)

Accepts an arbitrary string input from the user.The arguments may be of any type and are automatically converted to strings and displayed as the message of the input field.If multiple arguments are specified, how they are displayed depends on the implementation.Normally, they will probably be displayed separated by newlines.Note that the last argument is used as the default value of the input field.

macro select(...)

Presents choices to the user and obtains the selected item.The arguments may be of any type and are automatically converted to strings and displayed as the choices.

macro alert(...)

Outputs a message to an alert window and waits until the user acknowledges it.If multiple arguments are specified, how they are displayed depends on the implementation.Normally, they will probably be displayed separated by newlines.For output of messages without a warning intention, the popup function with nearly the same function is available since VCSSL 3.4.From now on, alert is recommended for messages intended as warnings.

macro popup(...)

Outputs a message to a popup window and waits until the user acknowledges it.If multiple arguments are specified, how they are displayed depends on the implementation.Normally, they will probably be displayed separated by newlines.At present, this function behaves exactly the same as alert, but it was newly supported since VCSSL 3.4 for outputting messages without a warning intention.By distinguishing it from alert, it becomes clear in code whether the displayed message is intended as a warning or as a normal message.In the future, the display icon on the window and so on may become different from alert.

macro pop(...)

Equivalent to the popup function.This function had the same name as the pop function of the data.Stack library,so the popup function with the same behavior was added later for cases where it is desirable to make it easier to see in code which one is being called.Note that the pop function of the Stack library has type parameters, and in current VCSSL those type parameters cannot be omitted,so there is at least currently no possibility of a signature conflict with this function.This function is supported for compatibility and can continue to be used,but to avoid confusion as much as possible, it is recommended to prefer popup unless there is a special reason not to.

macro confirm(...)

Outputs a message and presents the user with the two choices of acceptance or rejection.If multiple arguments are specified, how they are displayed depends on the implementation.Normally, they will probably be displayed separated by newlines.

string[ ] choose()

Presents the user with a file selection dialog and waits until a file is selected.

string[ ] choose(string message)

Presents the user with a file selection dialog and waits until a file is selected.

string[ ] choose(string message, string directory)

Presents the user with a file selection dialog and waits until a file is selected.

void beep()

Sounds a beep. However, whether it can actually be sounded depends on the environment.In some cases, a sound other than a beep, such as an operating-system warning sound, may be played.

void beep(int repeat)

Sounds a beep. However, whether it can actually be sounded depends on the environment.In some cases, a sound other than a beep, such as an operating-system warning sound, may be played.

void beep(int repeat, int wait)

Sounds a beep. However, whether it can actually be sounded depends on the environment.In some cases, a sound other than a beep, such as an operating-system warning sound, may be played.

void clear()

Clears the contents of the console. However, the behavior of this function depends on the implementation.For example, when console contents are displayed in a window attached to the implementation, the result will probably be as expected.However, in an implementation based only on standard input and output without a console window, it will probably do nothing.

void hide()

Hides the console. However, the behavior of this function depends on the implementation.For example, when console contents are displayed in a window attached to the implementation, the result will probably be as expected.However, in an implementation based only on standard input and output without a console window, it will probably do nothing.

void show()

Shows the console if it has been hidden. However, the behavior of this function depends on the implementation.For example, when console contents are displayed in a window attached to the implementation, the result will probably be as expected.However, in an implementation based only on standard input and output without a console window, it will probably do nothing.

int time()

Returns the elapsed time since the start of program execution, in milliseconds.

macro sleep(int milliSecond)

Suspends execution of the program temporarily.

void exit()

Ends execution of the program.Note that this function requests termination of the program to the implementation, and it does not necessarily guarantee that execution will end immediately.The ideal timing for calling this function is when the implementation is in an idle state, such as at the final line of the program after leaving all loops and branches.If this function is called while the implementation is performing high-speed processing, it can become close to a forced termination.Details depend on the implementation and its optimization policy, but when this function is called, the implementation may be in the middle of a sequence of operations that cannot be interrupted immediately.In that case, a time lag may occur and execution may continue for a short while even after the call.

void exit(int code)

Ends execution of the program with a specified exit status code.Note that this function requests termination of the program to the implementation, and it does not necessarily guarantee that execution will end immediately.The ideal timing for calling this function is when the implementation is in an idle state, such as at the final line of the program after leaving all loops and branches.If this function is called while the implementation is performing high-speed processing, it can become close to a forced termination.Details depend on the implementation and its optimization policy, but when this function is called, the implementation may be in the middle of a sequence of operations that cannot be interrupted immediately.In that case, a time lag may occur and execution may continue for a short while even after the call.

void reset(string programName, string args[ ])

Resets the implementation and executes another program.

macro error(...)

Outputs an error message.After outputting the error message, whether program execution ends or continues depends on the implementation.If you want to ensure termination, call exit afterward.

macro assert(bool expectedCondition)

Evaluates the value of an expression, does nothing if it is true, and outputs an error message if it is false.Program execution will probably be terminated. This function is used for testing.

macro exec(...)

Executes an operating-system command or an external program asynchronously in another process.Execution of the calling program does not wait for completion of the process. It continues in parallel with the created process.If you want to wait for execution to finish or control standard input and output, use the Process library.

macro system(...)

Executes an operating-system command or an external program synchronously.Execution of the calling program waits until the process completes.

macro alloc(...)

Changes the number of elements of an array.Elements at the same indices keep the same values before and after the change.

macro free(...)

Sets the number of elements of all dimensions of an array to 0.

bool exists(string filePath)

Checks whether a file exists.

void mkdir(string directoryPath)

Creates a new directory, that is, a folder. If the directory already exists, nothing is done.

bool isdir(string filePath)

Checks whether a file is a directory.

string[ ] listdir(string directoryPath)

Returns the list of file names in a directory.

macro rank(...)

Returns the number of dimensions of an array.For example, for an array a[11][28][32], rank(a) is 3.

macro length(...)

Returns the number of elements of an array. The second argument specifies the dimension whose element count is to be obtained, as an index counted from the left as 0, 1, 2, and so on.For example, for an array a[11][28][32], length(a, 0) is 11, length(a, 1) is 28, and length(a, 2) is 32.

bool nan( float value )

Determines whether a float variable or value is NaN, that is, not a number.

bool inf( float value )

Determines whether a float variable or value is Inf, that is, infinity.

string bin( int number )

Returns a string representing an int variable or value in binary. The prefix 0b is added at the beginning.

string oct( int number )

Returns a string representing an int variable or value in octal. The prefix 0 is added at the beginning.

string hex( int number )

Returns a string representing an int variable or value in hexadecimal. The prefix 0x is added at the beginning.

macro digit(arg)

Specifies the number of operation digits for the varfloat type or the varcomplex type.

macro digit()

Gets the number of operation digits for the varfloat type or the varcomplex type.

float round(float value, int digit, int mode)

Rounds a float value to the specified number of digits in the specified mode.Note that float values are stored internally as binary floating-point data, while rounding is performed on a decimal basis, so care is required regarding binary-decimal conversion errors.In general, conversions between binary and decimal floating-point numbers may not fit into a finite number of digits, and small errors may occur.Therefore, the internal data of a float value may differ slightly from the value you imagine in decimal notation.Accordingly, if the target value is very close to the rounding boundary, the result may appear strange at first glance, although it is internally correct.Also, the relationship between the result of this function and the result obtained when converting a float value to a string or displaying it with the print function may sometimes seem strange,but this is because implicit rounding is also performed internally in the latter case. If you want to apply additional rounding to that displayed result, convert the argument value to string before passing it.

string round(string value, int digit, int mode)

Interprets the contents of a string value as a number, and rounds it to the specified number of digits in the specified mode.This function is used when you want to apply additional rounding based on the same content that is obtained when a float value is converted to a string or displayed by the print function,where implicit rounding is performed internally. Compared with rounding a float value directly, the effect of binary-decimal conversion errors may differ slightly.For details, refer to the description for the case where the argument value is of float type.

complex round(complex value, int digit, int mode)

Rounds a complex value to the specified number of digits in the specified mode.Note that the real and imaginary parts of a complex value are stored internally as binary floating-point data, while rounding is performed on a decimal basis, so care is required regarding binary-decimal conversion errors.For details, refer to the description for the case where the argument value is of float type.

varfloat round(varfloat value, varint digit, int mode)

Rounds a varfloat value to the specified number of digits in the specified mode.

varcomplex round(varcomplex value, varint digit, int mode)

Rounds a varcomplex value to the specified number of digits in the specified mode.

void round(int mode)

Specifies the default rounding mode for calculations on varfloat and varcomplex values.Note that rounding control for varfloat and varcomplex values, and the implementation of this function, are currently introduced on an experimental basis.At present, it is not always guaranteed that rounding control will be performed exactly as specified for all operations.Be sure to verify the behavior in advance before using it.Rounding control for varfloat and varcomplex values, and the implementation of this round function, are planned to be officially introduced in VCSSL 4 or later after this trial period.

float re( complex value )

Returns the real part of a complex value.

float im( complex value )

Returns the imaginary part of a complex value.

void re( complex value, float realValue )

Sets the real part of a complex value.

void im( complex value, float imagValue )

Sets the imaginary part of a complex value.

varfloat re( varcomplex value )

Returns the real part of a varcomplex value.

varfloat im( varcomplex value )

Returns the imaginary part of a varcomplex value.

void re( varcomplex value, varfloat realValue )

Sets the real part of a varcomplex value.

void im( varcomplex value, varfloat imagValue )

Sets the imaginary part of a varcomplex value.

macro save(string filePath, content)

A simple file output function. Saves the contents held by a string variable to a file.

void save(string filePath)

A simple file output function. Saves the contents currently displayed on the console to a file. However, the behavior of this function depends on the implementation.For example, if the console contents are displayed in a window provided by the implementation, you will probably get the expected result.However, in a standard-input/output-based implementation that has no console window, this function will probably do nothing.

string load(string filePath)

A simple file input function. Reads the entire contents of a file and returns them as a string. The file is closed automatically after reading.

string load()

A simple file input function. Obtains the contents currently displayed on the console and returns them as a string. However, the behavior of this function depends on the implementation.For example, if the console contents are displayed in a window provided by the implementation, you will probably get the expected result.However, in a standard-input/output-based implementation that has no console window, this function will probably obtain nothing.

int open(string filePath, string mode)

Opens a file, assigns and returns a unique identifier for it, called a file ID.Normally, specify a file name or path for the argument filePath,but you can also specify STDIN, STDOUT, or STDERR to read from or write to the standard input/output streams instead.

int open(string filePath, string mode, string textEncoding)

Opens a file, assigns and returns a unique identifier for it, called a file ID.Normally, specify a file name or path for the argument filePath,but you can also specify STDIN, STDOUT, or STDERR to read from or write to the standard input/output streams instead.

macro openw(...)

This function belongs to the VCSSL 1.0 generation, and opens a file with the same behavior as open( filePath, "wtsv" ). This function is supported for compatibility.

macro opencsvw(...)

This function belongs to the VCSSL 1.0 generation, and opens a file with the same behavior as open( filePath, "wcsv" ). This function is supported for compatibility.

macro openr(...)

This function belongs to the VCSSL 1.0 generation, and opens a file with the same behavior as open( filePath, "rtsv" ). This function is supported for compatibility.

macro opencsvr(...)

This function belongs to the VCSSL 1.0 generation, and opens a file with the same behavior as open( filePath, "rcsv" ). This function is supported for compatibility.

void close(int fileID)

Closes a file. All buffered output is flushed at that time.

void flush(int fileID)

Flushes buffered output for a file.

macro write(int fileID, ...)

Writes content to a file. The content may be of any type, and it is converted to a string when written.If multiple pieces of content are specified, how they are written depends on the file I/O mode. In "w" or WRITE mode : The written contents are concatenated as they are. , In "wtsv" or WRITE_TSV mode : The written contents are concatenated with tab separators. , In "wcsv" or WRITE_CSV mode : The written contents are concatenated with comma separators. , Note that this function inserted a line break in VCSSL 2.1 and earlier, but does not insert one in VCSSL 2.2 and later. The behavior with a line break is provided by the writeln function.

macro writeln(int fileID, ...)

Writes content to a file and then inserts a line break. The content may be of any type, and it is converted to a string when written.If multiple pieces of content are specified, how they are written depends on the file I/O mode. In "w" or WRITE mode : The written contents are concatenated as they are. , In "wtsv" or WRITE_TSV mode : The written contents are concatenated with tab separators. , In "wcsv" or WRITE_CSV mode : The written contents are concatenated with comma separators. , The line break code is automatically chosen appropriately for the execution environment.If you want to use a specific line break code such as LF or CR,use the write function instead of this function,and write the content with LF or CR appended to it.

string[ ] read(int fileID)

Reads the entire contents of a file.The return value is a string array, and how the read contents are stored in it depends on the file I/O mode. In "r" or READ mode : The entire contents of the file are returned as a string array with one element. , In "rtsv" or READ_TSV mode : The contents of the file are returned in a string array separated by whitespace and line breaks. Tab characters and half-width spaces are treated as the same. , In "rcsv" or READ_CSV mode : The contents of the file are returned in a string array separated by commas and line breaks. , In CSV and TSV reading, enclosures and delimiters are not interpreted, and the contents are simply split at the positions where separator characters exist. Also, in TSV, tab characters and half-width spaces are not distinguished.If you want to control this behavior more strictly, use the file.TextFile library.Note that this function read data line by line in VCSSL 2.1 and earlier, but was changed in VCSSL 2.2 and later to read the entire contents. The old line-by-line behavior is provided by the readln function.

string[ ] readln(int fileID)

Reads one line of content from a file.The return value is a string array, and how the read contents are stored in it depends on the file I/O mode. In "r" or READ mode : The line contents are returned as a string array with one element. , In "rtsv" or READ_TSV mode : The line contents are returned in a string array separated by whitespace. Tab characters and half-width spaces are treated as the same. , In "rcsv" or READ_CSV mode : The line contents are returned in a string array separated by commas. , In CSV and TSV reading, enclosures and delimiters are not interpreted, and the contents are simply split at the positions where separator characters exist. Also, in TSV, tab characters and half-width spaces are not distinguished.If you want to control this behavior more strictly, use the file.TextFile library.

string load(int fileID)

Reads the entire contents of a file and returns them as a string.

string loadln(int fileID)

Reads an entire line from a file and returns it as a string.

int countln(int fileID)

Counts the number of lines in a file.

macro eval(string expression)

Evaluates a string as an expression. Variables and functions can also be accessed within lexical scope, and assignments can be performed as well.The value of the expression is returned after being converted to a string array (if the value of the expression is non-array, the returned array has one element).A string array is the type with the greatest conversion flexibility, and can be assigned to arrays and non-arrays of any primitive type (assignment to a non-array is possible only when the number of elements is one).On the other hand, if you want to evaluate expressions repeatedly at high speed, especially when the return value is of int or float type, type conversion through strings can become a bottleneck.In such cases, you can avoid that bottleneck by assigning the result to a variable within the evaluated expression and discarding the return value instead of using it.

macro eval(string expression, literalType)

Evaluates a string as an expression. Unlike the eval function with one argument, this version lets you specify how numeric literals without explicit suffixes are interpreted.For example, the expression "1 / 2" is normally treated as division between int values, so the result is 0. If you want it to be treated as division between float values and obtain 0.5, specify a float value such as 0.0 as the second argument.Note that only the type of the second argument is meaningful, and its value is ignored (however, since some meaning may be added to it in the future, it is recommended to specify 0 or 0.0 unless you have a particular reason not to).

macro feval(string expression)

Evaluates a string as an expression, and returns the value as a non-array float.

macro feval(string expression, literalType)

Evaluates a string as an expression, and returns the value as a non-array float.

macro ieval(string expression)

Evaluates a string as an expression, and returns the value as a non-array int.

macro ieval(string expression, literalType)

Evaluates a string as an expression, and returns the value as a non-array int.

macro ceval(string expression)

Evaluates a string as an expression, and returns the value as a non-array complex.

macro ceval(string expression, literalType)

Evaluates a string as an expression, and returns the value as a non-array complex.

macro beval(string expression)

Evaluates a string as an expression, and returns the value as a non-array bool.

macro beval(string expression, literalType)

Evaluates a string as an expression, and returns the value as a non-array bool.

macro seval(string expression)

Evaluates a string as an expression, and returns the value as a non-array string.

macro seval(string expression, literalType)

Evaluates a string as an expression, and returns the value as a non-array string.

macro vfeval(string expression)

Evaluates a string as an expression, and returns the value as a non-array varfloat.

macro vfeval(string expression, literalType)

Evaluates a string as an expression, and returns the value as a non-array varfloat.

macro vieval(string expression)

Evaluates a string as an expression, and returns the value as a non-array varint.

macro vieval(string expression, literalType)

Evaluates a string as an expression, and returns the value as a non-array varint.

macro vceval(string expression)

Evaluates a string as an expression, and returns the value as a non-array varcomplex.

macro vceval(string expression, literalType)

Evaluates a string as an expression, and returns the value as a non-array varcomplex.

macro evaluable(string expression)

Determines whether the contents of an expression are syntactically correct.If the eval function fails in parsing, processing speed decreases, so if you want to evaluate an expression repeatedly at high speed, it is recommended to check its validity in advance with this function.

macro evaluable(string expression, literalType)

Determines whether the contents of an expression are syntactically correct.If the eval function fails in parsing, processing speed decreases, so if you want to evaluate an expression repeatedly at high speed, it is recommended to check its validity in advance with this function.

macro evaltr(string expression)

Evaluates a string as an expression, and returns internal processing information of the implementation. The contents are completely implementation-dependent.Note that the expressions that can be used are subject to implementation-dependent restrictions, and the returned contents do not necessarily correspond exactly to those of normal expression evaluation.In addition, this function generally cannot be used with expressions that have side effects. This function is mainly intended for development and debugging.

macro evaltr(string expression, literalType)

Evaluates a string as an expression, and returns internal processing information of the implementation. The contents are completely implementation-dependent.Note that the expressions that can be used are subject to implementation-dependent restrictions, and the returned contents do not necessarily correspond exactly to those of normal expression evaluation.In addition, this function generally cannot be used with expressions that have side effects. This function is mainly intended for development and debugging.

macro override(string functionName, string argumentType[ ], string functionCode)

Changes the implementation of a function at runtime.Since the eval function cannot declare local variables or execute multiple statements, use this function when you want to perform such processing by dynamic evaluation.Note that this function can only change the implementation of an existing function, and cannot declare a new function.

string lf()

Returns the environment-dependent line break code. In VCSSL 3 and later, the constant EOL can be used directly as the line break code.This function wastes the overhead of a function call. In new programs, using the constant EOL is recommended.This function is supported for compatibility.

string linefeed()

Returns the environment-dependent line break code. In VCSSL 3 and later, the constant EOL can be used directly as the line break code.This function wastes the overhead of a function call. In new programs, using the constant EOL is recommended.This function is supported for compatibility.

---

Event Handlers

void main( )

This is the so-called main function.It is called automatically after processing of the global scope in all modules(for example, initialization of global constants) has been completed.If main functions exist in multiple modules, only the one defined lastaccording to the module loading order is called (this differs from ordinary event handlers).

void main( string args[ ] )

This is the so-called main function.It is called automatically after processing of the global scope in all modules(for example, initialization of global constants) has been completed.If main functions exist in multiple modules, only the one defined lastaccording to the module loading order is called (this differs from ordinary event handlers).

Structs

- None -

Variables

Functions

Event Handlers