Basic syntax highlighting

2024-04-30 21:13:23 -05:00
parent 9fb5187aa7
commit badbd7e142
4 changed files with 133 additions and 16 deletions
@@ -0,0 +1,108 @@
+export default {
+    name: 'forge',
+
+    startState: function () {
+        // asm is "have we seen the asm keyword." The first time we see braces after that keyword (ignoring
+        // strings, because string literals in an asm arg block is legal) we start highlighting it as asm.
+        // The current state is just the current state, null means normal.
+        return {current: null, asm: false}
+    },
+
+    token: function (stream, state) {
+        if (stream.eatSpace()) return null
+
+        if (state.current === null) {
+            let word
+            if (word = stream.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*/)) {
+                // This is either a keyword or an identifier.
+                // All the keywords are valid names, so, check that:
+                if (word[0].match(/^fn|var|new|static|asm|return|if|while|repeat|global|const$/)) {
+                    if (word[0] === 'asm') {
+                        state.asm = true
+                    } // This is the start of an asm control structure
+                    return 'keyword'
+                } else {
+                    return 'variable'
+                }
+            } else if (stream.match(/^-?((0b[01]+)|(0x[0-9a-fA-F]+)|(0o[0-7]+)|0|([1-9][0-9]*?))/)) {
+                // All the number formats. Unary minus is just an operator
+                return 'number'
+            } else if (stream.match(/^"/)) {
+                // Open quote to start a string
+                state.current = 'string'
+                return 'string'
+            } else if (stream.match(/^{/)) {
+                // Open brace
+                if (state.asm) {
+                    // This is the start of the _actual_ asm block, kick us into asm mode and gooooo
+                    state.current = 'asm'
+                    state.asm = false // clear the flag
+                    return 'quote'
+                } else {
+                    // A normal open brace, just highlight it. If we do indentation stuff it goes here.
+                    return 'strong'
+                }
+            } else if (stream.match(/^[};]/)) {
+                // Close brace and semicolon get bolded.
+                return 'strong'
+            } else if (stream.match(/^\/\/.*/)) {
+                // Normal line comment
+                return 'comment'
+            } else if (stream.match(/^\/\*/)) {
+                // Start of a block comment, switch our mode
+                state.current = 'comment'
+                return 'comment'
+            } else if (stream.match(/^&&|\|\||==|!=|>=|<=|[-+*/%&|^><=]/)) {
+                // These operators have to be after the comment check
+                return 'operator'
+            } else {
+                // Dunno what this is, so just return content
+                stream.next()
+                return 'content'
+            }
+        } else if (state.current === 'comment') {
+            // We're in a block comment
+            if (stream.match(/^\*\//)) {
+                // End of a block comment, clear the state
+                state.current = null
+            } else {
+                // Have to move forward
+                stream.next()
+            }
+            return 'comment' // No matter whether we clear the state or not, it's still currently a comment
+        } else if (state.current === 'string') {
+            // We're in a string
+            if (stream.match(/^"/)) {
+                // We're no longer in a string
+                state.current = null
+            } else {
+                // If the next char is a backslash...
+                stream.eat(/^\\/)
+                stream.next() // Advance past the _next_ char, skip whatever the escape is.
+            }
+            return 'string'
+        } else if (state.current === 'asm') {
+            // We're in an asm block
+            if (stream.match(/^}/)) {
+                // asm blocks end on close-brace, whether quoted or not! Forge is unaware of any brace rules in
+                // the assembler. This is a reality in the compiler as well, not just this highlighter.
+                state.current = null
+            } else {
+                // If it's not a brace move forward anyway
+                stream.next()
+            }
+            return 'quote'
+        }
+    },
+
+    indent: function (state, textAfter, cx) {
+        return 0
+        //const closing = dedentPartial.test(textAfter);
+        //return state.basecol + cx.unit * (state.indentDepth - (closing ? 1 : 0));
+    },
+
+    languageData: {
+        //indentOnInput: /^\s*(?:end|until|else|\)|\})$/,
+        //commentTokens: {line: '//', block: {open: '/*', close: '*/'}}
+    }
+}