Differences

This shows you the differences between two versions of the page.

--- prpl:prpl_notation_styles [2016/10/17 13:55] – acnot set swap planetfall
+++ prpl:prpl_notation_styles [Unknown date] (current) – removed - external edit (Unknown date) 127.0.0.1
@@ Line 1: / Line 1: @@
-PRPL is typically referred to as a "Reverse Polish  Notation" language (hence the "RPL" in it's name. It is an extension of CRPL used in CW3, with additional facilities beyond that.
-There are 3 distinct ways to write PRPL code.
-  * Stack Notation (traditional)
-  * Warp Notation (developed for CW3)
-  * Accessor Notation (new for PRPL)
-==== Stack Notation ====
-Every PRPL operand takes zero or more arguments from a "stack", pushes zero or more operands onto the "stack, or does both. In order to diagram the number of arguments consumed or produced, the following notation is included in every description following:
-  * The term is defined by two dashes: %% -- %%
-  * Preceding the term are the arguments consumed from the stack.
-  * Following the term are the arguments pushed onto the stack.
-For instance, the instruction to add two numbers are:
-<code>4 5 add</code>
-Stack notation to represent this will be:
-<code> 4 5 -- 9</code>
-In general, if we do not know the exact values of the arguments, an indicator of the argument would be given. Thus if we know the add command takes two input arguments and produces one output argument, then we notate it like this
-<code> n1 n2 -- n3 </code>
-**Note:** Unless explicitly noted otherwise, all instructions are destructive stack operations in that they will remove as many arguments as is required for their execution from the stack and replace those with the output from their execution. In the example above, the original two items on the stack have been replaced by their sum.
-Likewise, note that the most recent item pushed on to the stack will also be the first item to be removed. This is referred to as LIFO (**L**ast **I**n, **F**irst **O**ut) processing.
-The following convention is followed to represent items on the stack notation
-|< 80% 15% >|
-|b	|**Boolean** ; nominally a 1 or a zero, representing True or False|
-|i	|**Integer** ; an integer. The PRPL run-time will, if possible, convert the argumant to an integer.|
-|n	|**Term** ; a generic argument. Any term that will be accepted by the instruction. If possible, the PRPL run-time will attempt conversion between types.|
-|f	|**Float** ; a floating point value. If possible, the PRPL run-time will attempt conversion between types.|
-|x, y	|**Coordinate** ; an integer that represents a valid X- or Y-coordinate on the map.|
-|L	|**List** ; a list is capable of storing multiple values in an orderly system.|
-|s	|**String** ; a string of one or more text characters. If possible, numeric values will be converted at run-time.|
-==== Warp Notation ====
-An extra and optional operator to PRPL allows for a reversed order that you write some things in PRPL.  It doesn't change a thing about the stack, or how PRPL works.  It only gives you a syntax alternative that can make things easier to read in some cases.
-This operator is the  "warp" operator since it warps things around. In more technical terms,  it allows for prefix notation.   Take the following example:
-<code>3 4 add </code>
-This means to push 3 to the stack, push 4 to the stack, then to call "add".  Add pops two items from the stack, adds them together, then pushes the result back.  So stack notation for "add" is:
-<code>n1 n2 -- n3</code>
-This means two items on the stack before the operation, and one item on the stack afterwards.
-This is all PRPL (or RPL, or forth...) standard stuff and the primary principle of the language.  This remains unchanged and untouched.
-Take a second example:
-<code>
-CurrentCoords GetCreeper 1 gt if
-   "Creeper Greater than 1" Trace
-endif
-</code>
-This looks at the current coordinates, gets the creeper there, checks if it is greater than 1.  If so, trace the string "Creeper Greater than 1" to the trace log.  Because of the way the stack works, you have to push two coordinates to the stack first (CurrentCoords does that), then call GetCreeper.  That takes two items from the stack, uses them as coordinates, then pushes the value of the creeper at that map location back to the stack.  The number 1 is then pushed to the stack, and the "gt" call takes two items from the stack and does a "greater than" comparison between them.  The result is either 0 (false) or 1 (true) and that is pushed back to the stack.  Finally, the "if" statement pops the result of the "gt" call from the stack and then either allows execution to pass to the next statement, or jumps to the "endif".
-Again, PRPL 101.
-Now, introducing the Warp operator.
-<code>3 4 add</code>
-can become
-<code>add (3 4)</code>
-The open parenthesis "(" means to warp the previous command to the closing parenthesis ")" during compilation.  There is no run time penalty for doing this since it is just a syntax trick.  The compiler literally 'warps' "add" from before the 3 to after the 4 when this example is compiled.
-This also means the same thing:
-<code>3 add(4)</code>
-Here, the "add" warps from before the 4 to after the 4, resulting in "3 4 add" which is the exact same thing as the first example.
-Take the second example.  It now can become:
-<code>
-if ( GetCreeper(CurrentCoords)  gt (1) )
-   Trace ("Creeper Greater than 1")
-endif
-</code>
-Notice that spaces before or after a warp operator ( which are parentheses) don't matter.  You can put spaces, or you can bump the warp operator up right next to something else.
-Note also that this syntax is totally optional and can be intermixed with standard RPL notation as seems appropriate.  For instance, assignments still look better without warping.
-<code>
-->x</code>
-This means to assign 7 to the variable "x". Or "seven goes into x".
-So does this:
-<code>->x(7)</code>
-Like any language, you can write some really obfuscated code if you try ([[http://www.ioccc.org/years.html]]).
-For instance take this clean piece of code:
-<code>
-CurrentCoords GetCreeper 1 gt if
-   CurrentCoords -10 SetCreeper
-endif
-</code>
-Here it is in bizarro form:
-<code>
-endif(SetCreeper(-10(CurrentCoords(if(gt(1(GetCreeper(CurrentCoords))))))))</code>
-Here's the same code with just one oddball warp:
-<code>
-endif ( if (GetCreeper(CurrentCoords) gt (1))
-      SetCreeper(CurrentCoords -10)
-)
-</code>
-==== Accessor  Notation ====
-// Direct copy from forum post introducing Accessor notation //
-Previously let's say you had created an emitter and wanted to set some properties on the emitter.
-<code PRPL>
-CreateUnit("EMITTER" 100 100) ->myEmitter
-SetEmitterParticleType(<-myEmitter 1)
-SetEmitterProductionInterval(<-myEmitter 5)
-SetEmitterMaxParticles(<-myEmitter 500)
-</code>
-That's cool, and it works just fine.  AcNot just allows it to be a little tighter. It works similar to warp notation in that it is really just a preprocessor sweep over the PRPL code.  So the following will now produce the exact same opcodes as the above example.
-<code PRPL>
-CreateUnit("EMITTER" 100 100) ->myEmitter
-->myEmitter.EmitterParticleType
-->myEmitter.EmitterProductionInterval
-->myEmitter.EmitterMaxParticles
-</code>
-AcNot can also be used for reading a 'property'
-Old way
-<code PRPL>
-GetEmitterParticleType(<-myEmitter) ->var
-</code>
-New way
-<code PRPL>
-<-myEmitter.EmitterParticleType ->var
-</code>
-The way this works is the compiler just rearranges the PRPL source (roughly speaking) so that AcNot syntax produces the old syntax.  This is the same thing that happens for Warp notation.  All those parentheses get removed and your source gets rearranged into classic RPL form before compilation.
-So for an AcNot read operation this happens:
-<-var.Property
-becomes
-<-var GetProperty
-For an AcNot write operation this happens:
-->var.Property
-<-var swap SetProperty
-This syntax only works (is only useful) on single argument 'properties' that have Get and Set API methods.  That of course means that this syntax is totally optional and the Get/Set methods can be called directly if preferred.

Knuckle Cracker Wiki

User Tools

Site Tools

Differences

Page Tools