User:Mlforcada/intermediatelanguagefortransfer - Revision history

Mlforcada at 17:46, 6 June 2019

2019-06-06T17:46:31Z

Mlforcada at 17:38, 6 June 2019

2019-06-06T17:38:43Z

Mlforcada at 17:24, 6 June 2019

2019-06-06T17:24:42Z

Mlforcada at 17:11, 6 June 2019

2019-06-06T17:11:22Z

Show changes

Mlforcada: Created page with "The first 2 characters of the file are the length of the longest pattern and the number of rules. {| class="wikitable" border="1" |- ! Code ! Name ! Action |- | R [int] | rul..."

2019-06-06T16:50:02Z

Created page with "The first 2 characters of the file are the length of the longest pattern and the number of rules. {| class="wikitable" border="1" |- ! Code ! Name ! Action |- | R [int] | rul..."

New page

The first 2 characters of the file are the length of the longest pattern and the number of rules.

{| class="wikitable" border="1"
|-
! Code
! Name
! Action
|-
| R [int]
| rule
| marks the start of a new rule composed of the next [int] characters
|-
| s [int]
| string
| pushes the next [int] characters onto the stack as a literal string
|-
| j [int]
| jump
| increments the instruction pointer by [int]
|-
| ? [int]
| jump if not
| pops a bool off the stack, increments instruction pointer by [int] if its false
|-
| & [int]
| and
| pops [int] bools of the stack and pushes whether all of them are true
|-
| <code>| [int]</code>
| or
| pops [int] bools of the stack and pushes whether any of them are true
|-
| !
| not
| logically negates top of stack
|-
| = / =#
| equal
| push whether the first two strings popped are the same (=# ignores case)
|-
| ( / (#
| begins with
| push whether the first string popped occurs at the beginning of the second (<code>(#</code> ignores case )
|-
| ) / )#
| ends with
| push whether the first string popped occurs at the end of the second (<code>(#</code> ignores case )
|-
| [ / [#
| begins with list
| push whether the second string popped begins with any member of the list named by the first string popped ([# ignores case)
|-
| ] / ]#
| ends with list
| push whether the second string popped ends with any member of the list named by the first string popped (]# ignores case)
|-
| c / c#
| contains
| push whether the first string popped appears anywhere in the second (c# ignores case)
|-
| n / n#
| in
| push whether the second string popped is a member of the list named by the first (n# ignores case)
|-
| >
| begin let
| indicates that the next clip or var statement should not be evaluated
|-
| * / *#
| end let clip
| pops a value and an unevaluated clip and sets the clip to the value (*# copies the case of the value to the clip)
|-
| 4 / 4#
| end let var
| pops a value and a variable name and sets the variable to the value (4# copies the case of the value to the variable)
|-
| < [int]
| out
| pops [int] chunks off the stack and appends them to the output queue in the order that they were pushed (in recursive mode, the output queue is later passed back to the rule applier)
|-
| . [int]
| clip
| if preceded by >, pushes [int] onto the stack, otherwise pops a string off the stack and retrieves that property of the position indicated by [int]
|-
| $
| var
| if preceded by >, do nothing, otherwise pops a string off the stack and pushes the value of the variable with that name
|-
| G
| get case
| pops a string off the stack, pushes "AA", "Aa", or "aa" depending on its case
|-
| A
| copy case
| pops a string off the stack, copies its cases onto the next string on the stack
|-
| + [int]
| concat
| pops [int] strings off the stack, concatenates them, and pushes the result
|-
| { [int]
| chunk
| pops [int] items off the stack and puts them into a chunk (there are currently problems with this command)
|-
| p
| pseudolemma
| pop a chunk off the stack and push its pseudolemma
|-
| (space)
| space
| push a blank containing a single space onto the stack
|-
| _ [int]
| blank
| push the superblank after position [int] onto the stack
|}

@@ Line 3: / Line 3: @@
 The first 2 characters of the file are the length of the longest pattern and the number of rules.
 Trying to generate a complete transfer machine.
-Apparently the stack can hold Booleans, integers, strings (also tags?), superblanks (not strings) and chunks.
+Apparently the stack can hold Booleans, integers, strings (also tags?), superblanks (not strings) and chunks. Types should be more carefully discussed.
-It can also hold strings that represent global variables of different types such as lists (this needs to be carefully specified)
+It can also hold strings that represent global variables of different types such as lists (this needs to be carefully specified).
+Heavily inspired by other stack languages such as FORTH.
 {| class="wikitable" border="1"
@@ Line 28: / Line 29: @@
 |-
 | "[string]"
-| pushes the next [int] characters onto the stack as a literal; it can be the name of a var, clip [...]
+| pushes the next [int] characters onto the stack as a literal; it can be the name of a var, clip [...] . Stored as a single byte opcode, length, and number of bytes.
 |-
 | [int]
-| pushes the integer onto the stack
+| pushes the integer onto the stack, stored as as a single-byte opcode followed by a fixed number of bytes
 |-
 | False
@@ Line 40: / Line 41: @@
 |-
 | jump [int]
-| increments the instruction pointer by [int]
+| increments the instruction pointer by [int] (stored as a single byte opcode and a fixed number of bytes for the instruction pointer)
 |-
 | jumponfalse

@@ Line 3: / Line 3: @@
 The first 2 characters of the file are the length of the longest pattern and the number of rules.
 Trying to generate a complete transfer machine.
-Apparently the stack can hold Booleans, integers, strings, superblanks (not strings) and chunks.
+Apparently the stack can hold Booleans, integers, strings (also tags?), superblanks (not strings) and chunks.
 It can also hold strings that represent global variables of different types such as lists (this needs to be carefully specified)
@@ Line 22: / Line 22: @@
 | over
 | push on top of the stack a copy of the element just below the top of the stack
-|
+|-
+|-
+| swap
+| swap the two topmost elements in the stack
+|-
 | "[string]"
 | pushes the next [int] characters onto the stack as a literal; it can be the name of a var, clip [...]
@@ Line 92: / Line 96: @@
 | push whether the second string popped is a member of the list named by the first string
 |-
+| fetch
-| fetchstring
 | replaces var or clip name on top of the stack with the value contained in the clip or var named.
 |-
-|
+| store
+| stores the value of the string below the top of the stack onto the var or clip named by the top of the stack, and pops both values
-| >
-| begin let
-| indicates that the next clip or var statement should not be evaluated
 |-
+| printchunk
-| * / *#
+| pops one chunk off the stack and appends it to the output queue (in recursive mode, the output queue is later passed back to the rule applier)
-| end let clip
-| pops a value and an unevaluated clip and sets the clip to the value (*# copies the case of the value to the clip)
 |-
-| 4 / 4#
+| printlf
+| prints one lexical form off the stack and appends it to the output queue (...)
-| end let var
+|-
-| pops a value and a variable name and sets the variable to the value (4# copies the case of the value to the variable)
+| property
-|-
+| pops one string off the stack and then an integer n off the stack, and stores the name of the n-th property [???]
-| < [int]
-| out
-| pops [int] chunks off the stack and appends them to the output queue in the order that they were pushed (in recursive mode, the output queue is later passed back to the rule applier)
-|-
-| . [int]
-| clip
-| if preceded by >, pushes [int] onto the stack, otherwise pops a string off the stack and retrieves that property of the position indicated by [int]
-|-
-| $
-| var
-| if preceded by >, do nothing, otherwise pops a string off the stack and pushes the value of the variable with that name
 |-
 | getcase
@@ Line 129: / Line 120: @@
 | pops two strings off the stack, concatenates them, and pushes the result
 |-
+| newchunk
-| { [int]
+| push an empty chunk onto the stack
-| chunk
+|-
-| pops [int] items off the stack and puts them into a chunk (there are currently problems with this command)
+| newlf
+| push an empty lexical form onto the stack
+|-
+| lemma
+| adds the string on top of the stack as pseudolemma to the chunk below it, or as lemma to the lexical form below it
+|-
+| addtag
+| appends the string (tag?) on the top of the stack as a tag to the chunk or lexical form below it
+|-
+| addlf
+| appends the lexical form on the top of the stack to the chunk below it...??
 |-
+| [...]
+| [do we need more lexical form construction items]
+|-
 | pseudolemma
 | pop a chunk off the stack and push its pseudolemma

@@ Line 1: / Line 1: @@
 The first 2 characters of the file are the length of the longest pattern and the number of rules.
+Trying to generate a complete transfer machine.
+Apparently the stack can hold Booleans, integers, strings, superblanks (not strings) and chunks.
+It can also hold strings that represent global variables of different types such as lists (this needs to be carefully specified)
 {| class="wikitable" border="1"
@@ Line 15: / Line 20: @@
 | duplicate the top of the stack
 |-
-| string
+| over
+| push on top of the stack a copy of the element just below the top of the stack
-| pushes the next [int] characters onto the stack as a literal string
+|
+| "[string]"
+| pushes the next [int] characters onto the stack as a literal; it can be the name of a var, clip [...]
+|-
+| [int]
+| pushes the integer onto the stack
+|-
+| False
+| pushes False onto the stack
+|-
+| True
+| pushes True onto the stack
 |-
 | jump [int]
@@ Line 57: / Line 74: @@
 | pop two strings off the stack and push a Boolean whether the first string popped is a substring of the second (regardless of case)
 |-
+| hasprefix
-| begins with list
-| push whether the second string popped begins with any member of the list named by the first string popped ([# ignores case)
+| push whether a prefix of the second string popped is in the list named by the first string popped
 |-
+| hasprefixfold
-| ] / ]#
+| push whether a prefix of the second string popped is in the list named by the first string popped (regardless of case)
-| ends with list
+|-
-| push whether the second string popped ends with any member of the list named by the first string popped (]# ignores case)
+| hassuffix
+| push whether a suffix of the second string popped is in the list named by the first string popped
+|-
+| hassuffixfold
+| push whether a suffix of the second string popped is in the list named by the first string popped (regardless of case)
 |-
-| n / n#
 | in
-| push whether the second string popped is a member of the list named by the first (n# ignores case)
+| push whether the second string popped is a member of the list named by the first string
+|-
+| infold
+| push whether the second string popped is a member of the list named by the first string
+|-
+| fetchstring
+| replaces var or clip name on top of the stack with the value contained in the clip or var named.
 |-
+|
 | >
 | begin let