We recommend using the ALP Shell extensions to edit the settings. Edit them manually only if it is actually needed - for example to add another script language.

Full sample section that describes handling of the .asp files:

        { asp: (CG.newObjects.ScriptGen)
   	   (int)Timeout=60
            (int)RequireAsynch=1
            (int)CheckThatFileExists=2
            (int)IsScriptEngine=1
            (string)ScriptLanguage=ASP
            (string)DefaultLanguage=VBScript
            (int)ViewSource=0
            (int)EnableParentPaths=1
            (int)MaxSize=100000
            (int)ExtendedCreateObject=0
            { Processor:
            	{ Procent: (HTMLEmbedSearcher.newObjects.ASPProcents)
            		; No options required
            	} Procent;
            	{ Comment: (HTMLEmbedSearcher.newObjects.HTMLComment)
            		; No options required
            	} Comment;
                  { SCRIPT: (HTMLEmbedSearcher.newObjects.HTMLTagSearch)
                    (string)TagName=SCRIPT
                    (int)HasClosing=1
                    (int)NestingAllowed=0
                    (int)ContentID=101
                    (int)CopyContent=1
                    (int)DisableOtherParsers=1
                    (string)RequiredAttribute=RUNAT
                    (string)RequiredAttributeValue=SERVER
                  } SCRIPT;
                  { OBJECT: (HTMLEmbedSearcher.newObjects.HTMLTagSearch)
                    (string)TagName=OBJECT
                    (int)HasClosing=1
                    (int)NestingAllowed=0
                    (int)ContentID=102
                    (int)CopyContent=1
                    (int)DisableOtherParsers=1
                    (string)RequiredAttribute=RUNAT
                    (string)RequiredAttributeValue=SERVER
                  } OBJECT;
            } Processor;
            { COMMAP:
                (string)Alias_Name={xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
                ; .....
            } COMMAP;
            { JScript:
            	(string)Assignment=Response.Write(%s);
            	(string)Output=Response.Write("%s");
                  (string)OutputLine=Response.Write("%s\n");
            	(string)escapeChar=\
            	(string)escapeWith=\\
            	(string)escapeChar="
            	(string)escapeWith=\"
            } JScript;
            { VBScript:
            	(string)Assignment=Response.Write %s
            	(string)Output=Response.Write "%s"
                  (string)OutputLine=Response.Write "%s" & chr(13)
            	(string)escapeChar="
            	(string)escapeWith=""
            } VBScript;
        } asp;

Common content generator parameters

(int)Timeout - see ALP common content generator configuration parameters.

(int)RequireAsync - see ALP common content generator configuration parameters. For ScriptGen is recommended to use values 1 or 2. Synchronous execution is permitted but not recommended.

(int)CheckThatFileExists - see ALP common content generator configuration parameters. For ScriptGen value of 1 is recommended but the component serves custom error if the parameter is not set or is set to 0 and the file does not exist.

(int)IsScriptEngine - see ALP common content generator configuration parameters. Recommended value is 1. the value of 0 will cause ALP engine to treat ASP files as executables and execution will not be allowed unless the Execute flag is not set for the directory.

Global ScriptGen specific parameters

(string)ScriptLanguage - Script language to use. A name of the script language can be used such as JScript, VBScript that means the file extension controlled by this section will be treated as raw scripts written in that language. Special value ASP means that files will be processed as ASP-like scripts, in that case script language is determined by the DefaultLanguage value or by the  @Language directive if found in the first line of the file. See also Raw ScriptGen scripts and ScriptGen ASP-like scripts.

(string)DefaultLanguage - Ignored for raw scripts. In case of ASP-like scripts it is the default script language assumed if no @Language directive is found in the beginning of the file.

(int)ViewSource - ASP-like scripts only. Accepts values:
0 - Brief error description is displayed. Good setting for the retail version of the application
1 - No execution occurs. Instead resulting source is displayed. Useful in the development phase.
2 - On error displays the entire resulting source with error line colored in red. Recommended setting for the development phase.

(int)EnableParentPaths - If set to 0 denies usage of ".." symbols in paths passed for mapping to the Server.MapPath method. If non-zero parent paths are allowed.

(int)MaxSize - ASP-like scripts only. Specifies the maximum resulting source size. If not present in the configuration 1 Megabyte is the default value. ScriptGen uses buffers to generate an executable script from the asp files and preserves them during execution if ViewSource has value of 2 (show error line in red color).

(int)ExtendedCreateObject - Default is 0. If set to 1 it extends the functionality of the Server.CreateObject and the <OBJECT RUNAT=SERVER ...> tag. If it is 1 you not only ProgID or ClassID, but also path to a composite object definition file, path to a DLL padded with CLSID of a class to create from it (bypassing the registry). 

Subsections. ASP-like scripts only.

Parser

ScriptGen dll implements additional components used to parse the ASP-like files. They are implemented as root parsing driver and parser components. Section Processor defines what parsing driver to use and tells to the driver what parser components to load. It is possible to use external components that are able for example to do advanced processing of other tags and syntax schemes. It is recommended to copy this section "as is" if you are building custom configuration. Possible changes and additional help will be found in the documentation of the additional parsers. One sample change: By removing the section for the HTMLEmbedSearcher.newObjects.HTMLComment parser ASP-like includes will not be available.

The HTMLEmbedSearcher.newObjects.HTMLTagSearch component can be used for more complex tag parsing. By default it is configured for two ASP tags: SCRIPT and OBJECT. The parameters in the sections have the following meanings:

(string)TagName - The name of the HTML tag to search for. For example SCRIPT or OBJECT

(int)HasClosing - If set to 1 the tag is expected to have corresponding closing tag - for example </SCRIPT>.

(int)NestingAllowed - If set to 1 allows nesting - i.e. other tags of the same type can be found between the "opening" and "closing" tag.

(int)ContentID - A number used by the ASP module internally. It must be 101 for SCRIPT RUNAT=Server tags and 102 for OBJECT RUNAT=Server tags.

(int)CopyContent - Must be 1 in ALP.

(int)DisableOtherParsers - No other tags can be found inside this element if set to 1.

(string)RequiredAttribute - Required attribute. If such an attribute does not exist in the tag it will be skipped.

(string)RequiredAttributeValue - If set to "." means the value of the required attribute can be any. If the value is set to something else the required attribute is accepted only if its value matches the string (case insensitive).

Languages

For every language available for the ASP-like scripts additional section must present. Section name must be the name of the script language. Parameters allowed there are:

(string)Assignment - Defines how the <%= %> tags are translated. %s parameter in the string is replaced with the content of the <%= %> tag

(string)Output - Defines how the raw content (that is out of the <% %> tags) is translated. Every text line (or part of line) is translated to the text specified here by replacing the %s parameter with the line.

(string)OutputLine - Defines how the raw content (that is out of the <% %> tags) is translated when the current chunk is at the end of the line. Every text line (or part of line) is translated to the text specified here by replacing the %s parameter with the line. (this options was added by ALP fix - it is available from version 1.0.4.1)

(string)escapeChar , (string)escapeWith -pairs (order is important). These pairs specify what symbols to escape when generating the Assignment and Output as defined in the previous paragraphs. Character found as value of the escapeChar parameter is replaced with the string found in the corresponding escapeWith parameter.

COM Map

COMMAP section contains aliases for COM objects. It may contain as many records as needed:

(string)Alias_Name={Class ID}

The record name is the alias and its value is the components Class ID. This allows your application to use custom names instead of ProgID-s of the objects in it. This concerns the Server.CreateObject method and the <OBJECT RUNAT=Server> tags.

When used with ALPFrame in autorun scenario this allows usage of names instead of raw Class IDs. For example if you need to create SFMain object from newObjects ActiveX Pack1, in case of pure autorun application where the component is not installed on the PC but configured with the ALPFrame you will need to use this syntax:

Set o = Server.CreateObject("{F86AC6C2-5578-4AE8-808A-DC5DAA78082A}")

Using the aliases in this section you can specify in the COMMAP section:

(string)SFMain={F86AC6C2-5578-4AE8-808A-DC5DAA78082A}

and then in the application you can use:

Set o = Server.CreateObject("SFMain")

Even in other scenarios (non-autorun) where ALP engine is installed and any additional components you need are installed too - using aliases may be desired.

Application and Session settings are controlled by the ALP engine and not by the ScriptGen component - see details in the ALP configuration.