From 58e98cc43952385dd165885d04eb2260f3ddc38e Mon Sep 17 00:00:00 2001
From: Lars-Dominik Braun <lars@6xq.net>
Date: Sun, 9 Jul 2017 14:39:58 +0200
Subject: Add ELAN vim syntax file/pygments lexer and README

---
 elan.py | 135 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 135 insertions(+)
 create mode 100644 elan.py

(limited to 'elan.py')

diff --git a/elan.py b/elan.py
new file mode 100644
index 0000000..beeb9f8
--- /dev/null
+++ b/elan.py
@@ -0,0 +1,135 @@
+"""
+pygments lexer for Elementary Language (ELAN)
+
+- Rainer Hahn, Peter Stock: ELAN Handbuch. 1979.
+- Rainer Hahn, Dietmar Heinrichs, Peter Heyderhoff: EUMEL Benutzerhandbuch Version 1.7. 1984.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, include, words
+from pygments.token import *
+
+__all__ = ['ElanLexer']
+
+def uppercaseWords (l):
+    """
+    Match only uppercase words provided in l. For example FOR should not match
+    FORMAT.
+    """
+    return words (l, prefix=r'(?<![A-Z])', suffix=r'(?![A-Z])')
+
+class ElanLexer(RegexLexer):
+    name = 'ELAN'
+    aliases = ['elan']
+    filenames = ['*.elan']
+
+    tokens = {
+        'root': [
+            include('comment'),
+            # strings
+            (r'"', String.Double, 'string'),
+            # numbers. lookbehind, because identifiers may contain numbers too
+            (r'([-+]|(?<![a-z]))\d+', Number.Integer),
+            (r'[-+]?\d+\.\d+(E[+-]?\d+)?', Number.Float),
+            # keywords
+            (uppercaseWords ((
+                # not sure
+                'CONCR',
+                # if-then-else
+                'IF', 'THEN', 'ELSE', 'ELIF', 'ENDIF', 'END IF',
+                # found in the wild:
+                'FI',
+                # select statement
+                'SELECT', 'OF', 'CASE', 'OTHERWISE', 'ENDSELECT', 'END SELECT',
+                # loops
+                'FOR', 'FROM', 'DOWNTO', 'UPTO', 'WHILE', 'REPEAT', 'UNTIL',
+                'ENDREPEAT', 'END REPEAT',
+                # found in the wild:
+                'REP', 'PER', 'END REP',
+                # return statements
+                'LEAVE', 'WITH',
+                )), Keyword.Reserved),
+            (uppercaseWords ((
+                # type declaration
+                'TYPE',
+                # shorthand declaration
+                'LET',
+                )), Keyword.Declaration),
+            (uppercaseWords ((
+                # proper packet
+                'DEFINES',
+                )), Keyword.Namespace),
+            (uppercaseWords (('VAR', 'CONST', 'BOUND')), Name.Attribute),
+            (uppercaseWords (('BOOL', 'INT', 'REAL', 'TEXT', 'STRUCT', 'ROW',
+            'DATASPACE')), Keyword.Type),
+            # thruth values
+            (uppercaseWords (('TRUE', 'FALSE')), Name.Builtin),
+            # semi-builtin functions/operators, see Benutzerhandbuch pp. 329
+            # "Standartpakete"
+            (uppercaseWords ((
+                # boolean
+                'NOT', 'AND', 'OR', 'XOR',
+                # text
+                'CAT', 'LENGTH', 'TIMESOUT',
+                # math
+                'DECR', 'DIV', 'INCR', 'MOD', 'SUB',
+            )), Operator),
+            # and the same with symbols
+            (words ((
+                # assignments
+                ':=', '::',
+                # comparison
+                '=', '<>', '<=', '>=', '<', '>',
+                # math
+                '**', '*','+', '-', '/',
+                ), prefix=r'(?<![:=<>*+-/])', suffix=r'(?![:=<>*+-/])'),
+                Operator),
+            # packets, function and operators
+            # no space required between keyword and identifier
+            # XXX comments may be allowed between keyword and name
+            (r'((?:END\s*)?PACKET)([^A-Za-z]*)([a-z][a-z0-9 ]+)',
+                    bygroups (Keyword.Declaration, Text, Name.Namespace)),
+            (r'((?:END\s*)?PROC)([^A-Za-z]*)([a-z][a-z0-9 ]+)',
+                    bygroups (Keyword.Declaration, Text, Name.Function)),
+            (r'((?:END\s*)?OP)([^A-Za-z]*)([^a-z0-9 (;]+)',
+                    bygroups (Keyword.Declaration, Text, Name.Function)),
+            # Refinements
+            (r'\.(?![a-z])', Text, 'refinement'),
+            (r'.', Text),
+        ],
+        'comment': [
+            (r'\(\*', Comment, 'comment-inside1'),
+            (r'\{', Comment, 'comment-inside2'),
+            (r'#\(', Comment, 'comment-inside3'),
+        ],
+        'comment-inside1': [
+            # comment can be nested
+            include('comment'),
+            (r'\*\)', Comment, '#pop'),
+            (r'(.|\n)', Comment),
+        ],
+        'comment-inside2': [
+            # comment can be nested
+            include('comment'),
+            (r'\}', Comment, '#pop'),
+            (r'(.|\n)', Comment),
+        ],
+        'comment-inside3': [
+            # comment can be nested
+            include('comment'),
+            (r'#\)', Comment, '#pop'),
+            (r'(.|\n)', Comment),
+        ],
+        'string': [
+            # "" equals '\"', "12" is '\12'
+            (r'"[0-9]*"', String.Escape),
+            (r'"', String.Double, '#pop'),
+            (r'.', String.Double),
+        ],
+        'refinement': [
+            include('comment'),
+            (r'\s+', Text),
+            (r'([a-z][a-z0-9 ]*)(:\s+)', bygroups(Name.Label, Text), '#pop'),
+            (r'', Text, '#pop'),
+        ]
+    }
+
-- 
cgit v1.2.3