Code Manifestation -- Strings as Code

Code Manifestation — Strings as Code

Sheerpower allows strings to contain code. This makes it easy to design and implement your own business-specific scripting languages. The following example uses the eval() function:

a = 45 b = 10 c$ = 'a*b + pi' declare dynamic d d = eval(c$) print d

The contents of c$ are compiled into Sheerpower bytecode at runtime and then evaluated. The result is stored in d. Because the eval() function can return any data type depending on the string that was passed into it, d must be declared as a dynamic variable.

Note: If the eval() fails, the exception is EXPRINVALID and _integer contains the low-level exception value. For example, a division by zero with constant operands eval("5/0") raises EXPRINVALID with _integer set to 3001, the same value a direct division-by-zero exception would carry. Check _integer to recover the specific underlying cause.

when exception in result = eval("5/0") use if _integer = 3001 then print "division by zero" else print "invalid expression: "; extext$ end if end when

In special cases where greater runtime flexibility is required, Sheerpower supports code manifestation, allowing entire blocks of code to be compiled and executed dynamically at runtime using the execute statement:

suffix$ = '_temp' code$ = 'for i' + suffix$ + ' = 1 to 10' + "\" + 'print i' + suffix$ + '\' + 'next i' + suffix$ execute code$ execute 'print i_temp'

Note: Use of execute can make your code harder to maintain because the actual code does not exist until runtime. It should be used only in special situations where dynamic code generation is the best or cleanest solution.

When EXECUTE Code Does Not Compile

The code given to execute is compiled when the statement runs. If it does not compile, the report prints at once — the same error block a program's mistake gets, with the execute text as its source line — and execute raises Expression or statement invalid, which a when block catches (_string$ says the code given to EXECUTE did not compile). None of the failed code runs, and the program goes on:

code$ = 'prnt "hello"' when exception in execute code$ use print 'caught: '; extext$ end when print 'the program goes on'

Output:

| ?? Unrecognized statement | | prnt "hello" | ^ | Help>> a statement that starts with a name is an assignment, so = was expected here, | found 'hello' -- if the name was meant as a keyword, check its spelling caught: Expression or statement invalid the program goes on

Every compile error counts, including the ones found only once the whole snippet is compiled: a name that is used but never given a value, or a next with no for.

Why It Matters

This runtime compilation capability means Sheerpower can act as both a host language and a code generator. Developers can build domain-specific scripting engines, dynamic rule processors, or business logic layers that evolve without redeployment. It combines the performance of compiled code with the adaptability of scripting — a powerful advantage for systems that need to respond to changing business logic or external data sources in real time.

Note: Each new string passed to eval() or execute is compiled into code that stays in memory.

Sheerpower caches that code by the string itself. The same string compiles once, and every later call reuses it. The match must be exact, though — two strings that differ in any way, even an extra space, each compile separately.

So a loop that builds a different string every iteration misses the cache each time and piles up compiled code. When the strings do not change, create them once before the loop. They will compile only once, no matter how many iterations run.

Sheerpower Code Manifestation Takeaways

eval() compiles and evaluates expressions stored in strings.
Use declare dynamic when the result type is not known in advance.
execute compiles and runs entire blocks of code at runtime.
Code that does not compile is reported at once and raises Expression or statement invalid; none of it runs.
Dynamic code can enable powerful DSLs (domain-specific languages) and rule engines.
Use sparingly — runtime-generated code is harder to debug and maintain.

Manifested code is:

Harder to search or grep
Harder to refactor routine or variable names safely
Harder to statically analyze
Harder to debug because line numbers do not map to source files

Hide Description

a$ b$ x y

Enter or modify the code below, and then click on RUN

Looking for the full power of Sheerpower?
Check out the Sheerpower website. Free to download. Free to use.