newObjects (fromerly known as ZmeY soft) ASP Compiler 1.0
Home Products Docs & Libs
pixel.gif (49 bytes)
Home
Products by category
ALP site
ISAPI filters
ActiveX
Forums (discussions)
Buy direct (RegNet)
Articles and samples
Documentation online
Links
ACOMTools

Read more ...
Click here
ALP is implemented as an Asynchronous Pluggable Protocol. It acts like a WEB server but without need of network. It executes WEB applications such as ASP pages and CGI applications. ALP makes Internet Explorer to be server and client. With ALP you can write stand-alone desktop applications, CD-ROM autoruns, use ASP for pure desktop software and still keep your code ready to run on WEB servers too.
Write desktop software in ASP and CGI!
download it


ASP Wire

Site navigation
Products
Compilers and pre-processors



Active Local Pages

One common environment for desktop and WEB programming. Active Local Pages - WEB applications running on the desktop. Using the ALP WEB techniques are available for desktop programming - ASP and CGI are no longer server side only!


Highlights of the day
Active Label ActiveX
Barcode ActiveX? Much more - the design and printing inside your WEB application
SQLite3 COM
SQLite3 COM ActiveX embeds the SQLite3 database engine and interface to it. Supports paremeterized views and triggers.
Active Local Pages 1.2
Write desktop apps in ASP and CGI. Create wutorun CDs using WEB technologies - yes it is possible!
ActiveX Pack1 family
Desktop Windows, CE/CE.NET and PocketPC! About 50 powerful components for all the Windows platforms.
AXGate 1.1 (new)
Script dafely any ActiveX in Pocket IE. Build applications in HTML and use local resources and components in them.
IE ScriptBar
Create complex toolbars for Microsoft Internet Explorer easier than you may have expected.

Licensing types legend
(M) Single machine license
(U) Unlimited per-company license
(D) Unlimited development license
(S) Special type of licensing

DevASP

Quick contact
General
zmeyinc@newobjects.com
Support
support@newobjects.com
Sales
sales@newobjects.com

Jan

Active visitors
303
Suggested links
Suggest this page to the other visitors. Click the button below to place this page in the list above .

 ASP Compiler 1.0   
Price: (M) $99 Discount for resalers Agreement
Information Download Buy
ASP Compiler 1.1 beta
About ASP Compiler 1.0
Version history
License agreement
Demo limitations
Pricing
Screenshots
ASPC 1.0 (zip ~580k)
ASPC 1.1 beta (zip ~1M)
Buy 1 license (RegNet)
Buy 5 pack (RegNet)
More payment options
Pricing

ASP Compiler 1.1 beta

Download it: ASPC 1.1 beta (zip)

From a tool compiling ASP pages to COM DLLs ASP Compiler evolves to a new level. Now it becomes a flexible programming environment which could be extended by the developers to perform complex tasks such as:

  • Generating and regenerating frequently sites from a DB and other sources.
  • Automatic and semi-automatic code generation for ASP, HTML etc.
  • Collecting information from sets of HTML/ASP pages.
  • Creating projects, index, contents files and other files for another tools (such as Windows HTML help)
  • Generation/regeneration of ASP/HTML sites that need maximum performance - by moving part of the code in the ASPC and exposing as much page as possible as static HTML or at least simple ASP.
  • Almost unlimited WEB oriented custom tasks the developer may want to implement as extensions to ASP Compiler.
  • HTML Template mechanism available without ASP Compiler through its parser component. Can be used by the ASP pages to fill template HTML pages.

The new feature is called Compile Time Scripting (CTS). As the name claims this means it is scripts executed at compile time. They could be embedded as parts of the compiled pages or/and attached to the files in the ASP Compiler's project. The CTS can be compared to the ASP itself - e.g. embedded scripts look like this:

<SCRIPT RUNAT=Compiler Language=VBScript>
  Node("Class") = "Text"
  Node("Content") = "Hello World!"
</SCRIPT>

But they look also a bit similar to the DHTML scripts. In two words CTS is executed in way very similar to the ASP but while ASP code is executed on the server CTS code is executed during the page compilation. And they "see" the page in form similar to the DHTML object model - while the ASP code generates just output - the CTS manages the page as a tree of nodes that represent its elements. The object model is much more simple than the the DHTML and the CTS itself may request itself from the compiler the details it really needs to know about the page and ignore the rest of the page unchanged and non-parsed.

As a result the compiler supports extensions in two major forms:

  • Scripts that extend the ASP Compiler and perform advanced processing tasks during the file compilation (the term used in the documentation is file attached scripts). They may include configuration dialog and help and are configured in the ASPC's project to extend the processing of certain file(s).
  • Scripts in the processed pages (term in the documentation embedded scripts). Therefore the compiled pages are "active" - they may contain code that runs during the compilation.

This features are designed for HTML and ASP pages. They are used together with the HTML and the ASP code in the page and also they have access to the project settings, compiler variables and to each other. And all of them could be combined with compilation to COM DLL!

What this means for the programmer?

The CTS is a flexible feature that may help to improve variety of tasks. CTS could be used to automate frequently performed programming tasks or just to generate part of the pages (which changes rarely) off-line and thus reduce the server overhead. A large WEB site could be separated in several ASPC projects and CTS may take care to construct/reconstruct the pages. All the repeated tasks could be moved to CTS scripts step-by-step.

One of the most important features of the CTS is the opportunity to begin with embedded draft script and step-by-step improve it and move it outside the pages, then make it available for any project and finally document it and add user-friendly configuration. Thus the programmer has the appropriate way to think-and-implement - from the initial phase when he/she still wanders how to automate the task/implement the feature to the final phase - packing the CTS in reusable form available for the other developers. Thus the embedded scripts could be written initially between the <SCRIPT RUNAT=Compiler> ... </SCRIPT> tags, than moved in external file <SCRIPT RUNAT=Compiler SRC=file.vbs> and used in several files in the project, than move them to the ASPC library and use them from thifferent projects and so on.

The beta ships with many examples. Take a look at them to see different tricks - from "Hello World" to automatic generation of an ASP page.

HTML Template? ASP Compiler uses internally an universal parser component. Its HTML related capabilities could be used outside ASP Compiler to prepare ASP pages that include no HTML code, but use HTML templates obtained from external files or DB. The parser is capable to help even if the HTML page is not designed as a template initially! With the parser the ASP page is able to load a HTML file and replace/modify its content in a way similar to the DHTML. Thus, for example, you can set ID attribute and assign name to certain HTML element, then load the file and pass it to the parser, get the named element, modify it and send to the browser the modified page. In contrast of DHTML the ASP page tells the parser exactly what it is interested of. And the object model of the page contains only the explicitly requested elements - the rest will remain unchanged. Therefore templates can be prepared or adopted for seconds from existing pages. The same technique is also applicable if information from a HTML page is to be extracted (such as keywords in the <META name="keywords" ...> HTML element).

Already interested?

Download the beta. We strongly recommend the examples. The documentation is under construction and the example will be better as a first step.



Copyright newObjects (ZmeY soft) 2001-2005