MivaScript Tags

Name Syntax / Description Type
MIVA 
<MIVA STANDARDOUTPUTLEVEL = "html, text, compresswhitespace"
      ERROROUTPUTLEVEL = "runtime | null string "
      ERRORMESSAGE = "text_of_error_message"
      MvTAGNAME_ERROR = "fatal | nonfatal, display | nodisplay">
      IDENT = "$Id: filename revision number date time author $">
Enables you to configure the level of output, error reporting, and error handling. 		Closed
MvADD 
<MvADD NAME = "string: {  expression } | literal"
       VIEW = "string: {  expression } | literal">
Adds a record to the end of the database that has alias db_alias and positions the record pointer at that record. If NAME is omitted, the record is added to the primary database. 		Closed
MvASSEMBLY 
<MvASSEMBLY>
... assembly code here ... 
</MvASSEMBLY>
New in 5.18. MvASSEMBLY allows MivaScript assembly code to be interleaved with traditional MivaScript. The content of the MvASSEMBLY tag is passed unmodified to the MivaScript assembler. 		Closed
MvASSIGN 
<MvASSIGN NAME = "string: {  expression } | literal"
          VALUE = "{ expression } | literal"
          INDEX = "numberic: { expression } | literal"
          MEMBER = "string: {  expression } | literal">
Assigns NAME variable a VALUE given by expression or literal. The vaiable can also be an array or member of a structure. 		Closed
MvASSIGNARRAY 
<MvASSIGNARRAY NAME = "string: {  expression } | literal }"
               VALUE = "{ expression } | literal }">
               <MvDIMENSION INDEX = "1">
               <MvDIMENSION INDEX = "2">
               <MvMEMBER NAME = "code"> 
</MvASSIGNARRAY>
Defines a multi-dimension array or structure using <MvDIMENSION> and/or <MvMEMBER>. 		Closed
MvASYNCHRONOUS 
<MvASYNCHRONOUS>
 Code executed here. 
</MvASYNCHRONOUS>
Code within a <MvASYNCHRONOUS> and </MvASYNCHRONOUS> block will start to execute in a separate asynchronous task, and the task will exit when the </MvASYNCHRONOUS> block is reached. All output, even via <MvEVAL>, is discarded from the asynchronous task. 		Closed
MvCALL 
<MvCALL ACTION = "string: {  expression } | literal"
        METHOD = "GET|POST|HEAD|XML|RAW|OPTIONS|PUT|DELETE|TRACE|CONNECT|PATCH|LINK|UNLINK"
        CONTENT-TYPE = "string: {  expression } | literal"
        FIELDS = "{ expression } | variable list"
        FILES = "{ expression } | literal"
        CERTFILE = "{ expression } | literal"
        CERTTYPE = "{ expression } | literal"
        CERTPASS = "{ expression } | literal"
        CERTVALUE = "{ expression } | literal"
        TIMEOUT = "{ expression } | literal"
        HEADERS = "{ expression } | literal"
        FLAGS = "noparse">

        <MvCALLSTOP>
        <MvCALLCONTINUE>

</MvCALL>
Uses the HTTP/1.1 protocol to emulate a browser and contact a remote or local host. HTML, XML, and other pages can be requested from or posted to the remote URI. Page data is returned one tag at a time inside the <MvCALL> loop. 		Closed
MvCALLCONTINUE 
<MvCALLCONTINUE>
Returns program flow to the top of the <MvCALL> loop, performing the operations would normally occur at the bottom of the loop i.e. reading the next line. 		Closed
MvCALLSTOP 
<MvCALLSTOP>
<MvCALL> can be explicitly halted using the <MvCALLSTOP> tag to exit the loop. Execution jumps to the code following the closing </MvCALL> tag. 		Closed
MvCAPTURE 
<MvCAPTURE VARIABLE = "{ expression } | variable name"
           STANDARDOUTPUTLEVEL = "html, text, compresswhitespace"> 
</MvCAPTURE>
Captures the browser output until the end </MvCAPTURE> tag, and save it into a variable. 		Closed
MvCLOSE 
<MvCLOSE NAME = "string: {  expression } | literal">
Closes the database alias opend using <MvOPEN>. If name omitted, primary database alias (the one most recently opened with <MvCREATE> or <MvOPEN>) is closed. All open databases are automatically closed when a MivaScript program finishes executing. 		Closed
MvCLOSEVIEW 
<MvCLOSEVIEW NAME = "string: {  expression } | literal"
             VALUE = "{ expression } | literal">
Closes the specified SQL view opened with <MvOPENVIEW> 		Closed
MvCOMMENT 
<MvCOMMENT> 
</MvCOMMENT>
Used to annotate your program and inserts comments or code ignored by the compiler. They are also useful when you are developing and debugging your program. 		Closed
MvCOMMERCE 
<MvCOMMERCE ACTION = "string: {  expression } | literal"
            METAMETHOD = "string: { expression } | literal"
            FIELDS = "{ expression } | variable list">

            <MvCOMMERCESTOP>
            <MvCOMMERCECONTINUE> 
</MvCOMMERCE>
Provides communications between a Miva Script application and an external commerce library. It will loop until it no longer receives data, or until it is explicitly halted with the <MvCOMMERCESTOP> tag. 		Closed
MvCOMMERCECONTINUE 
<MvCOMMERCECONTINUE>
Returns program flow to the top of the <MvCOMMERCE> loop, performing the operations would normally occur at the bottom of the loop i.e. reading the next line. 		Closed
MvCOMMERCESTOP 
<MvCOMMERCESTOP>
<MvCOMMERCE> can be explicitly halted using the <MvCOMMERCESTOP> tag to exit the loop. Execution jumps to the code following the closing </MvCOMMERCE> tag. 		Closed
MvCOMMIT 
<MvCOMMIT NAME = "string: {  expression } | literal">
When altering multiple related database records, it's important that all transactions proceed. <MvCOMMIT> manual commits to writing database records. 		Closed
MvCREATE 
<MvCREATE NAME = "string: {  expression } | literal"
          DATABASE = "string: {  expression } | literal"
          FIELDS = "{ expression } | variable list"
          TYPE = "xbase3 | user defined">
Creates a new database with the structure specified by fields. Field types are CHAR, NUMBER, DATE, BOOL, and MEMO. 		Closed
MvDBCOMMAND 
<MvDBCOMMAND NAME = "string: {  expression } | literal"
             COMMAND = "string: {  expression } | command-name"
             PARAMETER = "optional-parameter">
Used to issue commands to a database that has already been opened or created via the MvOPEN or MvCREATE tags. All database interfaces take these commands. 		Closed
MvDELETE 
<MvDELETE NAME = "string: {  expression } | literal"
          VIEW = "string: {  expression } | literal">
Marks the current database record for deletion. Records marked for deletion accumulate until they are actually deleted from the database with <MvPACK> or unmarked using <MvUNDELETE>. 		Closed
MvDIMENSION 
<MvDIMENSION INDEX = "numberic: { expression } | literal">
Assigns an index position for a mulidimensional array. See <MvASSIGNARRAY> 		Closed
MvDO 
<MvDO FILE = "string: {  expression } | literal"
      NAME = "string: {  expression } | literal"
      VALUE = "{ function_name( paramiters ) }">
Used to call an function declared with <MvFUNCTION> in an external file or call an external file directly executing the script starting at the beginning. 		Closed
MvELSE 
<MvELSE>
Used in an <MvIf> statement to provide an alternate execution branch when the condition return false. 		Closed
MvELSEIF 
<MvELSEIF EXPR = "{ expression } | variable name">
Used in an <MvIf> statement to provide an alternate execution branch when the initial condition return false. Used in place of nested <MvIf> tags. 		Closed
MvEVAL 
<MvEVAL EXPR = "{ expression }">
Evaluates an expression and displays the results in the brower. 		Closed
MvEXIT 
<MvEXIT>
Causes the script in which the exit tag resides to terminate. 		Closed
MvEXPORT 
<MvEXPORT FILE = "string: {  expression } | literal"
          FIELDS = "{ expression } | variable list"
          DELIMITER = "string: {  expression } | literal">
Appends a single line of data to an external output file in the data folder, at the end of the output file, on a new line. It does not automatically loop. See <MvWHILE>. 		Closed
MvFILTER 
<MvFILTER NAME = "string: {  expression } | literal"
          FILTER_TYPE = "expression | variable"
          FILTER = "{ expression }">
Makes all records in the database with that do not match the FILTER condition invisible to <MvFIND>, <MvSKIP>, and other database navigation tags. These tags will then find only the records that match both their own search condition and the filter condition. 		Closed
MvFIND 
<MvFIND NAME = "string: {  expression } | literal"
        VALUE = "{ expression } | literal"
        EXACT
        VIEW = "string: {  expression } | literal">
Performs a case-sensitive search for value in the index of the database and moves the record pointer to the first matching record in the database. 		Closed
MvFOR 
<MvFOR INDEX = "{ expression } | variable name" 
       COUNT = "{ expression }">
       FIRST = "{ expression }" 
       NEXT = "{ expression }">
       LAST = "{ expression }" 
       EXPR = "{ expression }">

       <MvFORSTOP>
       <MvFORCONTINUE> 
</MvFOR>
Loops through the code between <MvFOR> and </MvFOR> the number of time specified between first and last, incrimenting the index. Optionally you can exit the loop using <MvFORSTOP>. 		Closed
MvFORCONTINUE 
<MvFORCONTINUE>
An <MvFOR> loop can be explicitly halted using the <MvFORSTOP> tag to exit the loop. Execution jumps to the code following the closing </MvFOR> tag. 		Closed
MvFOREACH 
<MvFOREACH ITERATOR = "{ expression } | variable name" 
           ARRAY = "{ expression } | array name" 
           INDEX = "{ expression } | variable name" 
           FIRST = "{ expression }" 
           NEXT = "{ expression }" 
           LAST = "{ expression }"
           COUNT = "{ expression }">

           <MvFOREACHSTOP>
           <MvFOREACHCONTINUE> 
</MvFOREACH>
<MvFOREACH> Is designed to make dealing with arrays of items more convenient. Each item in the array is represented in the loop as an iterator variable, simplifying the syntax. Optionally you can exit the loop using <MvFOREACHSTOP> 		Closed
MvFOREACHCONTINUE 
<MvFOREACHCONTINUE>
Returns program flow to the top of the <MvFOREACH> loop, performing the operations would normally occur at the bottom of the loop i.e. reading the next iterator. 		Closed
MvFOREACHSTOP 
<MvFOREACHSTOP>
An <MvFOREACH> loop can be explicitly halted using the <MvFOREACHSTOP> tag to exit the loop. Execution jumps to the code following the closing </MvFOREACH> tag. 		Closed
MvFORSTOP 
<MvFORSTOP>
Returns program flow to the top of the <MvFOR> loop, performing the operations would normally occur at the bottom of the loop i.e. incrimenting the index. 		Closed
MvFUNCRETURN 
<MvFUNCRETURN VALUE = "{ expression } | literal">
An alias for MvFUNCTIONRETURN, exits a function and optionally returns a value. 		Closed
MvFUNCTION 
<MvFUNCTION NAME = "string_literal"
            PARAMETERS = "variable_list"
            STANDARDOUTPUTLEVEL = "html, text, compresswhitespace">

            <MvFUNCTIONRETURN VALUE = "{ expression } | literal"> 
</MvFUNCTION>
A function is a sub-section of code executed by a call to the function name. MivaScript contains many built in functions like toupper(string). This tag lets you create your own user defined functions. 		Closed
MvFUNCTIONRETURN 
<MvFUNCTIONRETURN VALUE = "{ expression } | literal">
or
<MvFUNCRETURN VALUE = "{ expression } | literal"> (depreciated)
Exits a user defined function and optionally returns a value. 		Closed
MvGO 
<MvGO NAME = "string: {  expression } | literal"
      ROW = "numeric: { expression } | top | bottom"
      VIEW = "string: {  expression } | literal">
Operating on an open database or query, this tag moves to the physical record in the database in NAME, regardless of how the database is indexed. If NAME is omitted, the record pointer for the primary database is moved. 		Closed
MvHIDE 
<MvHIDE FIELDS = "{ expression } | variable list">
For each field listed, outputs separate html <input> tags. e.g. <input type="hidden" name="v1" value="{ value of v1 }"> 		Closed
MvIF 
<MvIF EXPR = "{ expression }">

<MvELSEIF EXPR="{ expression }">

<MvELSE> 
</MvIF>
Conditional statements are used to perform different actions based on different conditions, giving your program the ability to follow or not follow a "branch" of program code. 		Closed
MvIFDEF 
<MvIFDEF NAME = "string: {  expression } | literal">
Compiler directive. <MvIFDEF> and <MvIFNDEF>, provide compile-time inclusion or exclusion of code. 		Closed
MvIFNDEF 
<MvIFNDEF NAME = "string: {  expression } | literal">
Compiler directive. <MvIFDEF> and <MvIFNDEF>, provide compile-time inclusion or exclusion of code. 		Closed
MvIMPORT 
<MvIMPORT FILE = "string: {  expression } | literal"
          FIELDS = "{ expression } | variable list"
          DELIMITER = "string: {  expression } | literal"
          FILTER_TYPE = "{ expression } | variable name"
          FILTER = "{expression} | variable name">

          <MvIMPORTSTOP>
          <MvIMPORTCONTINUE> 
</MvIMPORT>
Imports records from a text file one line at a time where each line ends with a line feed (lf). The tag loops through the file stopping at the end of file (eof), unless terminated using <MvIMPORTSTOP>. 		Closed
MvIMPORTCONTINUE 
<MvIMPORTCONTINUE>
Returns program flow to the top of the <MvIMPORT> loop, performing the operations would normally occur at the bottom of the loop i.e. reading the next record. 		Closed
MvIMPORTSTOP 
<MvIMPORTSTOP>
An <MvIMPORT> loop can be explicitly halted using the <MvIMPORTSTOP>. Execution jumps to the code following the closing </MvIMPORT> tag. 		Closed
MvINCLUDE 
<MvINCLUDE FILE = "string: literal" INTERPRET="ON|OFF">
Compiler directive. At compile time, <MvINCLUDE> will include the named file which can include other files. This allows you to separate your code into functional groups or libraries files. 		Closed
MvLOCALIZED 
<MvLOCALIZED NAME = "string: {  expression } | literal"
             ID = "string: {  expression } | literal"
             STANDARDOUTPUTLEVEL = "keyword">
             
<MvLOCALIZED-TOKEN 
             NAME = "string: {  expression } | literal"
             VALUE = "{ expression } | literal">
                   
<MvLOCALIZED-TEXT 
             LANGUAGE = "string: {  expression } | literal language_id"> 
</MvLOCALIZED>
The localized tags allow you to design Miva Script programs that can display in various languages. In this way your programs can become truly international. <MvLOCALIZED> Starts the localization process. The tag can create a variable for output. 		Closed
MvLOCALIZED-TEXT 
<MvLOCALIZED-TEXT
    LANGUAGE = "string: {  expression } | literal language_id"> 
</MvLOCALIZED-TEXT>
Defines the text for the language specified by the LANGUAGE attribute. HTML is allowed, but MivaScript tags are not allowed between the opening and closing tags. 		Closed
MvLOCALIZED-TOKEN 
<MvLOCALIZED-TOKEN NAME = "string: {  expression } | literal"
                   VALUE = "{ expression } | literal">
Creates a "token" (or representation) which can then be displayed in localized text. Must be inside <MvLocalized> and must precede any <MvLocalized-Text> blocks that use the token. 		Closed
MvLOCKFILE 
<MvLOCKFILE FILE = "string: {  expression } | literal"> 
</MvLOCKFILE>
Indicates to other processes that the current process has requested an exclusive lock on FILE. A lock request is in effect until the corresponding </MvLOCKFILE> 		Closed
MvMAKEINDEX 
<MvMAKEINDEX NAME = "string: {  expression } | literal"
        INDEXFILE = "string: {  expression } | literal"
        EXPR_TYPE = "expression | variable"
        EXPR = "{ expression } | { variable_name }"
        FLAGS = "ascending | descending, unique | nonunique, string">
Creates the physical index file in INDEXFILE for the database alias in NAME. If NAME is omitted, the index is created for the primary database. 		Closed
MvMEMBER 
<MvMEMBER NAME = "string: {  expression } | literal">
Assigns a structure recordname for a mulidimensional array or structure. See <MvASSIGNARRAY> 		Closed
MvOPEN 
<MvOPEN NAME = "string: {  expression } | literal"
        DATABASE = "string: {  expression } | literal"
        USERNAME = "string: {  expression } | literal"
        PASSWORD = "string: {  expression } | literal"
        INDEXES = "{ expression } | filename list"
        TYPE = "xbase3 | MySQL">
Opens the DATABASE filename as alias NAME makes it the primary database. The record pointer is positioned at the first record. The same database file can be open more than once simultaneously with different alias NAMEs. 		Closed
MvOPENVIEW 
<MvOPENVIEW NAME = "string: {  expression } | literal"
            VIEW = "string: {  expression } | literal"
            QUERY = "string: {  expression } | literal"
            FIELDS = "{ expression } | variable list">
Opens an SQL VIEW on the NAMEed database based on the results of the query string. <MvSKIP> and <MvGO> are used to navigate the view. 		Closed
MvPACK 
<MvPACK NAME = "string: {  expression } | literal">
<MvDELETE> marks the current database record for deletion. Records marked for deletion accumulate until they are actually deleted from the database with <MvPACK> or unmarked using <MvUNDELETE>. 		Closed
MvPOP 
<MvPOP MAILHOST = "string: {  expression } | literal"
       LOGIN = "string: {  expression } | literal"
       PASSWORD = "{ expression } | literal"
       DIRECTORY = "string: {  expression } | literal">

       <MvPOPDELETE>
       <MvPOPSTOP>
       <MvPOPCONTINUE> 
</MvPOP>
Logs into the POP3 mail server named host, using the login_name and password login information, and retrieves all incoming mail messages in a loop, one message at a time. Use <MvPOPDELETE> to delete the message and <MvPOPSTOP> to terminate the loop. 		Closed
MvPOPCONTINUE 
<MvPOPCONTINUE>
Returns program flow to the top of the <MvPOP> loop, performing the operations would normally occur at the bottom of the loop i.e. reading the next email. 		Closed
MvPOPDELETE 
<MvPOPDELETE>
If an <MvPOPDELETE> is executed, inside a <MvPOP> loop, the current email message is deleted from the server. 		Closed
MvPOPSTOP 
<MvPOPSTOP>
An <MvPOP> loop can be explicitly halted using the <MvPOPSTOP>. Execution jumps to the code following the closing </MvPOP> tag. 		Closed
MvPRIMARY 
<MvPRIMARY NAME = "string: {  expression } | literal"
           INDEX = "string: {  expression } | literal">
If a database tag does not explicitly name an alias, the primary alias is implied. An database alias can be explicetly made the primary alias using <MvPRIMARY>. 		Closed
MvQUERY 
<MvQUERY NAME = "string: {  expression } | literal"
         QUERY = "string: {  expression } | literal"
         FIELDS = "{ expression } | variable list">
Runs an SQL query that does not return any results, such as an create, update, delete, or insert. 		Closed
MvREFERENCE 
<MvREFERENCE NAME = "string: {  expression } | literal"
             INDEX="numeric: {  expression } | literal" 
             MEMBER="string: {  expression } | literal" 
             VARIABLE = "{ expression } | variable name">
Creates a reference from one variable to another, such that changes to one will appear to be made to the other. It can be also used to refer to a variable named created with an expression, like the miva_variable_value() function. 		Closed
MvREFERENCEARRAY 
<MvREFERENCEARRAY NAME = "string: {  expression } | literal" 
    VARIABLE = "string: {  expression } | literal">
    <MvDIMENSION INDEX = "numberic: { expression } | literal">
    <MvMEMBER NAME= "string: {  expression } | literal"> 
</MvREFERENCEARRAY>
Creates a reference from one array to another, such that changes to one will appear to be made to the other 		Closed
MvREINDEX 
<MvREINDEX NAME = "string: {  expression } | literal">
Recreates all open index files for NAMEed database alias or the primary database if NAME is omitted. 		Closed
MvREVEALSTRUCTURE 
<MvREVEALSTRUCTURE NAME = "string: {  expression } | literal"
                   DATABASE = "string: {  expression } | literal"
                   VIEW = "string: {  expression } | literal"
                   VARIABLE = "{ expression } | variable name">
Returns information on the structure of database tables. 		Closed
MvROLLBACK 
<MvROLLBACK NAME = "string: {  expression } | literal">
When altering multiple related database records, it's important that all transactions proceed. <MvROLLBACK> manual removes all marks and does not commit to writing database records. 		Closed
MvSETINDEX 
<MvSETINDEX NAME = "string: {  expression } | literal"
            INDEXES = "{ expression } | filename list">
Opens the index files specified in INDEXES for an already open database with NAME alias. If the NAME attribute is omitted, the index files are opened for the primary database. 		Closed
MvSKIP 
<MvSKIP NAME = "string: {  expression } | literal"
        ROWS = "numberic: { expression } | literal"
        VIEW = "string: {  expression } | literal">
Moves the record pointer of the database with NAME alias a specific number of records (ROWS) forward or backward relative to its current position. If NAME is omitted, the record pointer for the primary database is moved. 		Closed
MvSMTP 
<MvSMTP FROM = "string: { expression } | string: { expression }"
        TO = "string: { expression } | literal"
        CC = "string: { expression } | literal"
        SUBJECT = "string: { expression } | literal"
        FLAGS = "string: { expression } | literal"
        MAILHOST = "string: { expression } | literal"
        PORT = "string: { number } | literal number"
        USERNAME = "string: { expression } | literal"
        PASSWORD = "string: { expression } | literal"> 
</MvSMTP>
Sends email TO an email address FROM an email address using the SMTP protocol and optionally a copy CC to one or more email addresses. You may specify a SUBJECT. MAILHOST must contain the domain name or IP address of the SMTP server. 		Closed
MvTRANSACT 
<MvTRANSACT NAME = "string: {  expression } | literal">
The <MvTRANSACTION> tag will suspend the default auto-commit settings for a database until a <MvCOMMIT> or <MvROLLBACK> tag is executed. 		Closed
MvUNDELETE 
<MvUNDELETE NAME = "string: {  expression } | literal"
            VIEW = "string: {  expression } | literal">
Marks for deletion the current record in the database that has alias db_alias. Records marked for deletion accumulate until they are actually deleted from the database with <MvPACK>. 		Closed
MvUPDATE 
<MvUPDATE NAME = "string: {  expression } | literal"
          VIEW = "string: {  expression } | literal">
Updates the current database record of NAME db_alias, with the contents of the database fields. 		Closed
MvWHILE 
<MvWHILE EXPR = "{ expression } | variable name">

         <MvWHILESTOP>
         <MvWHILECONTINUE> 
</MvWHILE>
Loops through the code between <MvWHILE> and </MvWHILE> until the condition in EXPR is false. Optionally you can exit the loop using <MvWHILESTOP>. 		Closed
MvWHILECONTINUE 
<MvWHILECONTINUE>
Returns program flow to the top of the <MvWHILE> loop, performing the operations would normally occur at the bottom of the loop i.e. testing the expression. 		Closed
MvWHILESTOP 
<MvWHILESTOP>
An <MvWHILE> loop can be explicitly halted using the <MvCALLSTOP> tag to exit the loop. Execution jumps to the code following the closing </MvWHILE> tag. 		Closed
+ Add a note
User Annotations: mivascript-tags