changed mkfile attrs

CMakeLists.txt

@@ -110,6 +110,8 @@ set(SOURCE_FILES
         user/serial.h
         user/routes.c
         user/routes.h
+        user/uart_asyncdrv.c-
+        user/uart_asyncdrv.h-
         user/cgi_main.c
         user/cgi_main.h
         user/cgi_sockets.c
@@ -117,14 +119,29 @@ set(SOURCE_FILES
         user/cgi_sockets.h
         user/ansi_parser_callbacks.c
         user/ansi_parser_callbacks.h
-        user/user_main.h
         user/wifimgr.c
         user/wifimgr.h
         user/persist.c
         user/persist.h
         include/helpers.h
         user/syscfg.c
-        user/syscfg.h)
+        user/syscfg.h
+        user/ascii.h
+        user/sgr.h
+        user/apars_utf8.c
+        user/apars_utf8.h
+        user/apars_logging.h
+        user/version.h
+        user/apars_csi.c
+        user/apars_csi.h
+        user/apars_short.c
+        user/apars_short.h
+        user/apars_string.c
+        user/apars_string.h
+        user/apars_osc.c
+        user/apars_osc.h
+        user/apars_dcs.c
+        user/apars_dcs.h user/uart_buffer.c user/uart_buffer.h)
 
 include_directories(include)
 include_directories(user)
@@ -145,6 +162,7 @@ add_definitions(
         -DFLAG_GZIP=2
         -DADMIN_PASSWORD="asdf"
         -DGIT_HASH="blabla"
+        -DDEBUG_HEAP=1
         -DESPFS_HEATSHRINK)
 
 add_executable(esp_vt100_firmware ${SOURCE_FILES})

Makefile

@@ -65,8 +65,14 @@ LIBS += esphttpd
 # compiler flags using during compilation of source files
 CFLAGS		= -Os -ggdb -std=gnu99 -Werror -Wpointer-arith -Wundef -Wall -Wl,-EL -fno-inline-functions \
 		-nostdlib -mlongcalls -mtext-section-literals  -D__ets__ -DICACHE_FLASH \
-		-Wno-address -Wno-unused -DHTTPD_MAX_BACKLOG_SIZE=8192 -DADMIN_PASSWORD=$(ADMIN_PASSWORD) \
+		-Wno-address -Wno-unused
-		-DGIT_HASH='"$(shell git rev-parse --short HEAD)"'
+
+CFLAGS += -DGIT_HASH='"$(shell git rev-parse --short HEAD)"'
+CFLAGS += -DADMIN_PASSWORD=$(ADMIN_PASSWORD)
+
+ifdef GLOBAL_CFLAGS
+CFLAGS += $(GLOBAL_CFLAGS)
+endif
 
 # linker flags used to generate the main object file
 LDFLAGS		= -nostdlib -Wl,--no-check-sections -u call_user_start -Wl,-static

esphttpdconfig.mk

@@ -40,3 +40,15 @@ ESP_SPI_FLASH_SIZE_K = 1024
 
 # Admin password, used to store settings to flash as defaults
 ADMIN_PASSWORD = "19738426"
+
+GLOBAL_CFLAGS = \
+    -DDEBUG_ROUTER=0 \
+    -DDEBUG_CAPTDNS=0 \
+    -DDEBUG_HTTP=1 \
+    -DDEBUG_ESPFS=0 \
+    -DDEBUG_WS=0 \
+    -DDEBUG_ANSI=1 \
+    -DDEBUG_ANSI_NOIMPL=1 \
+    -DHTTPD_MAX_BACKLOG_SIZE=8192 \
+    -DDEBUG_INPUT=0 \
+    -DDEBUG_HEAP=1

html_orig/_debug_replacements.php

@@ -16,14 +16,10 @@ return [
 	'labels_seq' => 'TESPTerm local debug
1
2
3

5',
 
 	'screenData' => '






HELLOx

N
RE3
',//'\u000b\u0001\u001b\u0001\u0001\u0001\u0001\u0001\f\u0005\u0001\u0010\u0003HELLOx\u0002\u000b\u0001\u0001N\u0001RE\u00023\u0001', //,
-	/*'{
-		 "w": 26, "h": 10,
-		 "x": 10, "y": 5,
-		 "cv": 1, "fg": 10, "bg": 2,
-		 "screen": ""
-	}',//"70 t259"*/
 
 	'parser_tout_ms' => 10,
+	'display_tout_ms' => 20,
+	'fn_alt_mode' => '1',
 
 	'opmode' => '2',
 	'sta_enable' => '0',

html_orig/css/app.css

@@ -1152,9 +1152,6 @@ body.term #botnav {
   position: absolute;
   top: -9999px; }
 
-.nb {
-  font-weight: normal !important; }
-
 .theme-0 .fg0 {
   color: #111213; }
 .theme-0 .bg0 {
@@ -1548,6 +1545,24 @@ body.term #botnav {
 .bold {
   font-weight: bold !important; }
 
+.faint span {
+  opacity: 0.6; }
+
+.italic {
+  font-style: italic; }
+
+.under {
+  text-decoration: underline; }
+
+.strike {
+  text-decoration: line-through; }
+
+.underline.strike {
+  text-decoration: underline line-through; }
+
+.blink-hide .blink {
+  color: transparent; }
+
 .Row.color-preview {
   font-family: monospace;
   font-size: 16pt;

html_orig/js/app.js

@@ -701,6 +701,307 @@
 	// Set Chibi's global namespace here ($)
 	w.$ = chibi;
 }());
+//     keymaster.js
+//     (c) 2011-2013 Thomas Fuchs
+//     keymaster.js may be freely distributed under the MIT license.
+
+;(function(global){
+  var k,
+    _handlers = {},
+    _mods = { 16: false, 18: false, 17: false, 91: false },
+    _scope = 'all',
+    // modifier keys
+    _MODIFIERS = {
+      '⇧': 16, shift: 16,
+      '⌥': 18, alt: 18, option: 18,
+      '⌃': 17, ctrl: 17, control: 17,
+      '⌘': 91, command: 91
+    },
+    // special keys
+    _MAP = {
+      backspace: 8, tab: 9, clear: 12,
+      enter: 13, 'return': 13,
+      esc: 27, escape: 27, space: 32,
+      left: 37, up: 38,
+      right: 39, down: 40,
+      del: 46, 'delete': 46,
+      home: 36, end: 35,
+      pageup: 33, pagedown: 34,
+      ',': 188, '.': 190, '/': 191,
+      '`': 192, '-': 189, '=': 187,
+      ';': 186, '\'': 222,
+      '[': 219, ']': 221, '\\': 220,
+      // added:
+      insert: 45,
+      np_0: 96, np_1: 97, np_2: 98, np_3: 99, np_4: 100, np_5: 101,
+	  np_6: 102, np_7: 103, np_8: 104, np_9: 105, np_mul: 106,
+	  np_add: 107, np_sub: 109, np_point: 110, np_div: 111, numlock: 144,
+    },
+    code = function(x){
+      return _MAP[x] || x.toUpperCase().charCodeAt(0);
+    },
+    _downKeys = [];
+
+  for(k=1;k<20;k++) _MAP['f'+k] = 111+k;
+
+  // IE doesn't support Array#indexOf, so have a simple replacement
+  function index(array, item){
+    var i = array.length;
+    while(i--) if(array[i]===item) return i;
+    return -1;
+  }
+
+  // for comparing mods before unassignment
+  function compareArray(a1, a2) {
+    if (a1.length != a2.length) return false;
+    for (var i = 0; i < a1.length; i++) {
+        if (a1[i] !== a2[i]) return false;
+    }
+    return true;
+  }
+
+  var modifierMap = {
+      16:'shiftKey',
+      18:'altKey',
+      17:'ctrlKey',
+      91:'metaKey'
+  };
+  function updateModifierKey(event) {
+      for(k in _mods) _mods[k] = event[modifierMap[k]];
+  };
+
+  // handle keydown event
+  function dispatch(event) {
+    var key, handler, k, i, modifiersMatch, scope;
+    key = event.keyCode;
+
+    if (index(_downKeys, key) == -1) {
+        _downKeys.push(key);
+    }
+
+    // if a modifier key, set the key.<modifierkeyname> property to true and return
+    if(key == 93 || key == 224) key = 91; // right command on webkit, command on Gecko
+    if(key in _mods) {
+      _mods[key] = true;
+      // 'assignKey' from inside this closure is exported to window.key
+      for(k in _MODIFIERS) if(_MODIFIERS[k] == key) assignKey[k] = true;
+      return;
+    }
+    updateModifierKey(event);
+
+    // see if we need to ignore the keypress (filter() can can be overridden)
+    // by default ignore key presses if a select, textarea, or input is focused
+    if(!assignKey.filter.call(this, event)) return;
+
+    // abort if no potentially matching shortcuts found
+    if (!(key in _handlers)) return;
+
+    scope = getScope();
+
+    // for each potential shortcut
+    for (i = 0; i < _handlers[key].length; i++) {
+      handler = _handlers[key][i];
+
+      // see if it's in the current scope
+      if(handler.scope == scope || handler.scope == 'all'){
+        // check if modifiers match if any
+        modifiersMatch = handler.mods.length > 0;
+        for(k in _mods)
+          if((!_mods[k] && index(handler.mods, +k) > -1) ||
+            (_mods[k] && index(handler.mods, +k) == -1)) modifiersMatch = false;
+        // call the handler and stop the event if neccessary
+        if((handler.mods.length == 0 && !_mods[16] && !_mods[18] && !_mods[17] && !_mods[91]) || modifiersMatch){
+          if(handler.method(event, handler)===false){
+            if(event.preventDefault) event.preventDefault();
+              else event.returnValue = false;
+            if(event.stopPropagation) event.stopPropagation();
+            if(event.cancelBubble) event.cancelBubble = true;
+          }
+        }
+      }
+    }
+  };
+
+  // unset modifier keys on keyup
+  function clearModifier(event){
+    var key = event.keyCode, k,
+        i = index(_downKeys, key);
+
+    // remove key from _downKeys
+    if (i >= 0) {
+        _downKeys.splice(i, 1);
+    }
+
+    if(key == 93 || key == 224) key = 91;
+    if(key in _mods) {
+      _mods[key] = false;
+      for(k in _MODIFIERS) if(_MODIFIERS[k] == key) assignKey[k] = false;
+    }
+  };
+
+  function resetModifiers() {
+    for(k in _mods) _mods[k] = false;
+    for(k in _MODIFIERS) assignKey[k] = false;
+  };
+
+  // parse and assign shortcut
+  function assignKey(key, scope, method){
+    var keys, mods;
+    keys = getKeys(key);
+    if (method === undefined) {
+      method = scope;
+      scope = 'all';
+    }
+
+    // for each shortcut
+    for (var i = 0; i < keys.length; i++) {
+      // set modifier keys if any
+      mods = [];
+      key = keys[i].split('+');
+      if (key.length > 1){
+        mods = getMods(key);
+        key = [key[key.length-1]];
+      }
+      // convert to keycode and...
+      key = key[0]
+      key = code(key);
+      // ...store handler
+      if (!(key in _handlers)) _handlers[key] = [];
+      _handlers[key].push({ shortcut: keys[i], scope: scope, method: method, key: keys[i], mods: mods });
+    }
+  };
+
+  // unbind all handlers for given key in current scope
+  function unbindKey(key, scope) {
+    var multipleKeys, keys,
+      mods = [],
+      i, j, obj;
+
+    multipleKeys = getKeys(key);
+
+    for (j = 0; j < multipleKeys.length; j++) {
+      keys = multipleKeys[j].split('+');
+
+      if (keys.length > 1) {
+        mods = getMods(keys);
+      }
+
+      key = keys[keys.length - 1];
+      key = code(key);
+
+      if (scope === undefined) {
+        scope = getScope();
+      }
+      if (!_handlers[key]) {
+        return;
+      }
+      for (i = 0; i < _handlers[key].length; i++) {
+        obj = _handlers[key][i];
+        // only clear handlers if correct scope and mods match
+        if (obj.scope === scope && compareArray(obj.mods, mods)) {
+          _handlers[key][i] = {};
+        }
+      }
+    }
+  };
+
+  // Returns true if the key with code 'keyCode' is currently down
+  // Converts strings into key codes.
+  function isPressed(keyCode) {
+      if (typeof(keyCode)=='string') {
+        keyCode = code(keyCode);
+      }
+      return index(_downKeys, keyCode) != -1;
+  }
+
+  function getPressedKeyCodes() {
+      return _downKeys.slice(0);
+  }
+
+  function filter(event){
+    var tagName = (event.target || event.srcElement).tagName;
+    // ignore keypressed in any elements that support keyboard data input
+    return !(tagName == 'INPUT' || tagName == 'SELECT' || tagName == 'TEXTAREA');
+  }
+
+  // initialize key.<modifier> to false
+  for(k in _MODIFIERS) assignKey[k] = false;
+
+  // set current scope (default 'all')
+  function setScope(scope){ _scope = scope || 'all' };
+  function getScope(){ return _scope || 'all' };
+
+  // delete all handlers for a given scope
+  function deleteScope(scope){
+    var key, handlers, i;
+
+    for (key in _handlers) {
+      handlers = _handlers[key];
+      for (i = 0; i < handlers.length; ) {
+        if (handlers[i].scope === scope) handlers.splice(i, 1);
+        else i++;
+      }
+    }
+  };
+
+  // abstract key logic for assign and unassign
+  function getKeys(key) {
+    var keys;
+    key = key.replace(/\s/g, '');
+    keys = key.split(',');
+    if ((keys[keys.length - 1]) == '') {
+      keys[keys.length - 2] += ',';
+    }
+    return keys;
+  }
+
+  // abstract mods logic for assign and unassign
+  function getMods(key) {
+    var mods = key.slice(0, key.length - 1);
+    for (var mi = 0; mi < mods.length; mi++)
+    mods[mi] = _MODIFIERS[mods[mi]];
+    return mods;
+  }
+
+  // cross-browser events
+  function addEvent(object, event, method) {
+    if (object.addEventListener)
+      object.addEventListener(event, method, false);
+    else if(object.attachEvent)
+      object.attachEvent('on'+event, function(){ method(window.event) });
+  };
+
+  // set the handlers globally on document
+  addEvent(document, 'keydown', function(event) { dispatch(event) }); // Passing _scope to a callback to ensure it remains the same by execution. Fixes #48
+  addEvent(document, 'keyup', clearModifier);
+
+  // reset modifiers to false whenever the window is (re)focused.
+  addEvent(window, 'focus', resetModifiers);
+
+  // store previously defined key
+  var previousKey = global.key;
+
+  // restore previously defined key and return reference to our key object
+  function noConflict() {
+    var k = global.key;
+    global.key = previousKey;
+    return k;
+  }
+
+  // set window.key and window.key.set/get/deleteScope, and the default filter
+  global.key = assignKey;
+  global.key.setScope = setScope;
+  global.key.getScope = getScope;
+  global.key.deleteScope = deleteScope;
+  global.key.filter = filter;
+  global.key.isPressed = isPressed;
+  global.key.getPressedKeyCodes = getPressedKeyCodes;
+  global.key.noConflict = noConflict;
+  global.key.unbind = unbindKey;
+
+  if(typeof module !== 'undefined') module.exports = assignKey;
+
+})(this);
 /** Make a node */
 function mk(e) {return document.createElement(e)}
 
@@ -1022,6 +1323,70 @@ $.ready(function() {
 		}, 1);
 	}
 });
+
+
+/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+if (!String.fromCodePoint) {
+	(function() {
+		var defineProperty = (function() {
+			// IE 8 only supports `Object.defineProperty` on DOM elements
+			try {
+				var object = {};
+				var $defineProperty = Object.defineProperty;
+				var result = $defineProperty(object, object, object) && $defineProperty;
+			} catch(error) {}
+			return result;
+		}());
+		var stringFromCharCode = String.fromCharCode;
+		var floor = Math.floor;
+		var fromCodePoint = function() {
+			var MAX_SIZE = 0x4000;
+			var codeUnits = [];
+			var highSurrogate;
+			var lowSurrogate;
+			var index = -1;
+			var length = arguments.length;
+			if (!length) {
+				return '';
+			}
+			var result = '';
+			while (++index < length) {
+				var codePoint = Number(arguments[index]);
+				if (
+					!isFinite(codePoint) ||       // `NaN`, `+Infinity`, or `-Infinity`
+					codePoint < 0 ||              // not a valid Unicode code point
+					codePoint > 0x10FFFF ||       // not a valid Unicode code point
+					floor(codePoint) != codePoint // not an integer
+				) {
+					throw RangeError('Invalid code point: ' + codePoint);
+				}
+				if (codePoint <= 0xFFFF) { // BMP code point
+					codeUnits.push(codePoint);
+				} else { // Astral code point; split in surrogate halves
+					// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+					codePoint -= 0x10000;
+					highSurrogate = (codePoint >> 10) + 0xD800;
+					lowSurrogate = (codePoint % 0x400) + 0xDC00;
+					codeUnits.push(highSurrogate, lowSurrogate);
+				}
+				if (index + 1 == length || codeUnits.length > MAX_SIZE) {
+					result += stringFromCharCode.apply(null, codeUnits);
+					codeUnits.length = 0;
+				}
+			}
+			return result;
+		};
+		if (defineProperty) {
+			defineProperty(String, 'fromCodePoint', {
+				'value': fromCodePoint,
+				'configurable': true,
+				'writable': true
+			});
+		} else {
+			String.fromCodePoint = fromCodePoint;
+		}
+	}());
+}
 // Generated from PHP locale file
 var _tr = {
     "wifi.connected_ip_is": "Connected, IP is ",
@@ -1200,29 +1565,29 @@ var Screen = (function () {
 		y: 0,
 		fg: 7,           // colors 0-15
 		bg: 0,
-		bold: false,
+		attrs: 0,
 		suppress: false, // do not turn on in blink interval (for safe moving)
-		hidden: false    // do not show
+		hidden: false,    // do not show
+		hanging: false,   // xenl
 	};
 
 	var screen = [];
 	var blinkIval;
 
-	/** Clear screen */
+	var frakturExceptions = {
-	function _clear() {
+		'C': '\u212d',
-		for (var i = W*H-1; i>=0; i--) {
+		'H': '\u210c',
-			var cell = screen[i];
+		'I': '\u2111',
-			cell.t = ' ';
+		'R': '\u211c',
-			cell.bg = cursor.bg;
+		'Z': '\u2128',
-			cell.fg = cursor.fg;
+	};
-			cell.bold = false;
-			_draw(cell);
-		}
-	}
 
-	/** Set text and color at XY */
+	// for BEL
-	function _cellAt(y, x) {
+	var audioCtx = null;
-		return screen[y*W+x];
+	try {
+		audioCtx = new (window.AudioContext || window.audioContext || window.webkitAudioContext)();
+	} catch (er) {
+		console.error("Browser does not support AudioContext, can't beep.", er);
 	}
 
 	/** Get cell under cursor */
@@ -1230,13 +1595,6 @@ var Screen = (function () {
 		return screen[cursor.y*W + cursor.x];
 	}
 
-	/** Enable or disable cursor visibility */
-	function _cursorEnable(enable) {
-		cursor.hidden = !enable;
-		cursor.a &= enable;
-		_draw(_curCell());
-	}
-
 	/** Safely move cursor */
 	function cursorSet(y, x) {
 		// Hide and prevent from showing up during the move
@@ -1251,17 +1609,49 @@ var Screen = (function () {
 
 	/** Update cell on display. inv = invert (for cursor) */
 	function _draw(cell, inv) {
+		if (!cell) return;
 		if (typeof inv == 'undefined') {
 			inv = cursor.a && cursor.x == cell.x && cursor.y == cell.y;
 		}
 
-		var e = cell.e, fg, bg;
+		var elem = cell.e, fg, bg, cn, t;
 		// Colors
 		fg = inv ? cell.bg : cell.fg;
 		bg = inv ? cell.fg : cell.bg;
 		// Update
-		e.innerText = (cell.t + ' ')[0];
+		elem.textContent = t = (cell.t + ' ')[0];
-		e.className = 'fg' + fg + ' bg' + bg + (cell.bold ? ' bold' : '');
+
+		cn = 'fg' + fg + ' bg' + bg;
+		if (cell.attrs & (1<<0)) cn += ' bold';
+		if (cell.attrs & (1<<2)) cn += ' italic';
+		if (cell.attrs & (1<<3)) cn += ' under';
+		if (cell.attrs & (1<<4)) cn += ' blink';
+		if (cell.attrs & (1<<5)) {
+			cn += ' fraktur';
+			// perform substitution
+			if (t >= 'a' && t <= 'z') {
+				t = String.fromCodePoint(0x1d51e - 97 + t.charCodeAt(0));
+			}
+			else if (t >= 'A' && t <= 'Z') {
+				// this set is incomplete, some exceptions are needed
+				if (frakturExceptions.hasOwnProperty(t)) {
+					t = frakturExceptions[t];
+				} else {
+					t = String.fromCodePoint(0x1d504 - 65 + t.charCodeAt(0));
+				}
+			}
+			elem.textContent = t;
+		}
+		if (cell.attrs & (1<<6)) cn += ' strike';
+
+		if (cell.attrs & (1<<1)) {
+			cn += ' faint';
+			// faint requires special html - otherwise it would also dim the background.
+			// we use opacity on the text...
+			elem.innerHTML = '<span>' + e(elem.textContent) + '</span>';
+		}
+
+		elem.className = cn;
 	}
 
 	/** Show entire screen */
@@ -1303,8 +1693,9 @@ var Screen = (function () {
 
 			cell = {
 				t: ' ',
-				fg: cursor.fg,
+				fg: 7,
-				bg: cursor.bg,
+				bg: 0, // the colors will be replaced immediately as we receive data (user won't see this)
+				attrs: 0,
 				e: e,
 				x: i % W,
 				y: Math.floor(i / W),
@@ -1320,7 +1711,8 @@ var Screen = (function () {
 		clearInterval(blinkIval);
 		blinkIval = setInterval(function () {
 			cursor.a = !cursor.a;
-			if (cursor.hidden) {
+			// TODO try to invent a new way to indicate "hanging" - this is copied from gtkterm
+			if (cursor.hidden || cursor.hanging) {
 				cursor.a = false;
 			}
 
@@ -1328,6 +1720,15 @@ var Screen = (function () {
 				_draw(_curCell(), cursor.a);
 			}
 		}, 500);
+
+		// blink attribute
+		setInterval(function () {
+			$('#screen').removeClass('blink-hide');
+			setTimeout(function() {
+				$('#screen').addClass('blink-hide');
+			}, 800); // 200 ms ON
+		}, 1000);
+
 		inited = true;
 	}
 
@@ -1336,11 +1737,18 @@ var Screen = (function () {
 		return (s.charCodeAt(i++) - 1) + (s.charCodeAt(i) - 1) * 127;
 	}
 
-	var SEQ_SET_COLOR = 1;
+	/** Decode three-byte number */
+	function parse3B(s, i) {
+		return (s.charCodeAt(i) - 1) + (s.charCodeAt(i+1) - 1) * 127 + (s.charCodeAt(i+2) - 1) * 127 * 127;
+	}
+
+	var SEQ_SET_COLOR_ATTR = 1;
 	var SEQ_REPEAT = 2;
+	var SEQ_SET_COLOR = 3;
+	var SEQ_SET_ATTR = 4;
 
 	function _load_content(str) {
-		var i = 0, ci = 0, j, jc, num, num2, t = ' ', fg, bg, bold, cell;
+		var i = 0, ci = 0, j, jc, num, num2, t = ' ', fg, bg, attrs, cell;
 
 		if (!inited) _init();
 
@@ -1360,27 +1768,39 @@ var Screen = (function () {
 
 		// Attributes
 		num = parse2B(str, i); i += 2; // fg bg bold hidden
-		cursor.fg = num & 0x0F;
+		cursor.hidden = !(num & 0x0001);
-		cursor.bg = (num & 0xF0) >> 4;
+		cursor.hanging = !!(num & 0x0002);
-		cursor.bold = !!(num & 0x100);
+		// console.log("Attributes word ",num.toString(16)+'h');
-		cursor.hidden = !(num & 0x200);
-		// console.log("FG ",cursor.fg, ", BG ", cursor.bg,", BOLD ", cursor.bold, ", HIDE ", cursor.hidden);
 
-		fg = cursor.fg;
+		Input.setAlts(
-		bg = cursor.bg;
+			!!(num & 0x0004), // cu
-		bold = cursor.bold;
+			!!(num & 0x0008), // np
+			!!(num & 0x0010) // fn
+		);
+
+		fg = 7;
+		bg = 0;
+		attrs = 0;
 
 		// Here come the content
 		while(i < str.length && ci<W*H) {
 
 			j = str[i++];
 			jc = j.charCodeAt(0);
-			if (jc == SEQ_SET_COLOR) {
+			if (jc == SEQ_SET_COLOR_ATTR) {
+				num = parse3B(str, i); i += 3;
+				fg = num & 0x0F;
+				bg = (num & 0xF0) >> 4;
+				attrs = (num & 0xFF00)>>8;
+			}
+			else if (jc == SEQ_SET_COLOR) {
 				num = parse2B(str, i); i += 2;
 				fg = num & 0x0F;
 				bg = (num & 0xF0) >> 4;
-				bold = !!(num & 0x100);
+			}
-				// console.log("Switch to ",fg,bg,bold);
+			else if (jc == SEQ_SET_ATTR) {
+				num = parse2B(str, i); i += 2;
+				attrs = num & 0xFF;
 			}
 			else if (jc == SEQ_REPEAT) {
 				num = parse2B(str, i); i += 2;
@@ -1390,7 +1810,7 @@ var Screen = (function () {
 					cell.fg = fg;
 					cell.bg = bg;
 					cell.t = t;
-					cell.bold = bold;
+					cell.attrs = attrs;
 				}
 			}
 			else {
@@ -1399,12 +1819,17 @@ var Screen = (function () {
 				t = cell.t = j;
 				cell.fg = fg;
 				cell.bg = bg;
-				cell.bold = bold;
+				cell.attrs = attrs;
 				// console.log("Symbol ", j);
 			}
 		}
 
 		_drawAll();
+
+		if (!cursor.hidden || cursor.hanging) {
+			// hide cursor asap
+			_draw(_curCell(), false);
+		}
 	}
 
 	function _load_labels(str) {
@@ -1413,11 +1838,39 @@ var Screen = (function () {
 		qsa('#buttons button').forEach(function(x, i) {
 			var s = pieces[i+1].trim();
 			// if empty string, use the "dim" effect and put nbsp instead to stretch the btn vertically
-			x.innerHTML = s.length >0 ? e(s) : "&nbsp;";
+			x.innerHTML = s.length > 0 ? e(s) : "&nbsp;";
 			x.style.opacity = s.length > 0 ? 1 : 0.2;
 		});
 	}
 
+	function _beep()
+	{
+		var osc, gain;
+		if (!audioCtx) return;
+
+		// Main beep
+		osc = audioCtx.createOscillator();
+		gain = audioCtx.createGain();
+		osc.connect(gain);
+		gain.connect(audioCtx.destination);
+		gain.gain.value = 0.5;
+		osc.frequency.value = 750;
+		osc.type = 'sine';
+		osc.start();
+		osc.stop(audioCtx.currentTime+0.05);
+
+		// Surrogate beep (making it sound like 'oops')
+		osc = audioCtx.createOscillator();
+		gain = audioCtx.createGain();
+		osc.connect(gain);
+		gain.connect(audioCtx.destination);
+		gain.gain.value = 0.2;
+		osc.frequency.value = 400;
+		osc.type = 'sine';
+		osc.start(audioCtx.currentTime+0.05);
+		osc.stop(audioCtx.currentTime+0.08);
+	}
+
 	/** Load screen content from a binary sequence (new) */
 	function load(str) {
 		var content = str.substr(1);
@@ -1428,6 +1881,9 @@ var Screen = (function () {
 			case 'T':
 				_load_labels(content);
 				break;
+			case 'B':
+				_beep();
+				break;
 			default:
 				console.warn("Bad data message type, ignoring.");
 		}
@@ -1450,12 +1906,14 @@ var Conn = (function() {
 		console.warn("SOCKET CLOSED, code "+evt.code+". Reconnecting...");
 		setTimeout(function() {
 			init();
-		}, 1000);
+		}, 200);
+		// this happens when the buffer gets fucked up via invalid unicode.
+		// we basically use polling instead of socket then
 	}
 
 	function onMessage(evt) {
 		try {
-			console.log("RX: ", evt.data);
+			//console.log("RX: ", evt.data);
 			// Assume all our messages are screen updates
 			Screen.load(evt.data);
 		} catch(e) {
@@ -1465,6 +1923,7 @@ var Conn = (function() {
 
 	function doSend(message) {
 		console.log("TX: ", message);
+
 		if (!ws) return; // for dry testing
 		if (ws.readyState != 1) {
 			console.error("Socket not ready");
@@ -1503,6 +1962,12 @@ var Conn = (function() {
 
 /** User input */
 var Input = (function() {
+	var opts = {
+		np_alt: false,
+		cu_alt: false,
+		fn_alt: false,
+	};
+
 	function sendStrMsg(str) {
 		Conn.send("STR:"+str);
 	}
@@ -1515,31 +1980,128 @@ var Input = (function() {
 		Conn.send("BTN:"+n);
 	}
 
+	function fa(alt, normal) {
+		return opts.fn_alt ? alt : normal;
+	}
+
+	function ca(alt, normal) {
+		return opts.cu_alt ? alt : normal;
+	}
+
+	function na(alt, normal) {
+		return opts.np_alt ? alt : normal;
+	}
+
+	function _bindFnKeys() {
+		var keymap = {
+			'tab': '\x09',
+			'backspace': '\x08',
+			'enter': '\x0d',
+			'ctrl+enter': '\x0a',
+			'esc': '\x1b',
+			'up': ca('\x1bOA', '\x1b[A'),
+			'down': ca('\x1bOB', '\x1b[B'),
+			'right': ca('\x1bOC', '\x1b[C'),
+			'left': ca('\x1bOD', '\x1b[D'),
+			'home': ca('\x1bOH', fa('\x1b[H', '\x1b[1~')),
+			'insert': '\x1b[2~',
+			'delete': '\x1b[3~',
+			'end': ca('\x1bOF', fa('\x1b[F', '\x1b[4~')),
+			'pageup': '\x1b[5~',
+			'pagedown': '\x1b[6~',
+			'f1': fa('\x1bOP', '\x1b[11~'),
+			'f2': fa('\x1bOQ', '\x1b[12~'),
+			'f3': fa('\x1bOR', '\x1b[13~'),
+			'f4': fa('\x1bOS', '\x1b[14~'),
+			'f5': '\x1b[15~', // note the disconnect
+			'f6': '\x1b[17~',
+			'f7': '\x1b[18~',
+			'f8': '\x1b[19~',
+			'f9': '\x1b[20~',
+			'f10': '\x1b[21~', // note the disconnect
+			'f11': '\x1b[23~',
+			'f12': '\x1b[24~',
+			'shift+f1': fa('\x1bO1;2P', '\x1b[25~'),
+			'shift+f2': fa('\x1bO1;2Q', '\x1b[26~'), // note the disconnect
+			'shift+f3': fa('\x1bO1;2R', '\x1b[28~'),
+			'shift+f4': fa('\x1bO1;2S', '\x1b[29~'), // note the disconnect
+			'shift+f5': fa('\x1b[15;2~', '\x1b[31~'),
+			'shift+f6': fa('\x1b[17;2~', '\x1b[32~'),
+			'shift+f7': fa('\x1b[18;2~', '\x1b[33~'),
+			'shift+f8': fa('\x1b[19;2~', '\x1b[34~'),
+			'shift+f9': fa('\x1b[20;2~', '\x1b[35~'), // 35-38 are not standard - but what is?
+			'shift+f10': fa('\x1b[21;2~', '\x1b[36~'),
+			'shift+f11': fa('\x1b[22;2~', '\x1b[37~'),
+			'shift+f12': fa('\x1b[23;2~', '\x1b[38~'),
+			'np_0': na('\x1bOp', '0'),
+			'np_1': na('\x1bOq', '1'),
+			'np_2': na('\x1bOr', '2'),
+			'np_3': na('\x1bOs', '3'),
+			'np_4': na('\x1bOt', '4'),
+			'np_5': na('\x1bOu', '5'),
+			'np_6': na('\x1bOv', '6'),
+			'np_7': na('\x1bOw', '7'),
+			'np_8': na('\x1bOx', '8'),
+			'np_9': na('\x1bOy', '9'),
+			'np_mul': na('\x1bOR', '*'),
+			'np_add': na('\x1bOl', '+'),
+			'np_sub': na('\x1bOS', '-'),
+			'np_point': na('\x1bOn', '.'),
+			'np_div': na('\x1bOQ', '/'),
+			// we don't implement numlock key (should change in numpad_alt mode, but it's even more useless than the rest)
+		};
+
+		for (var k in keymap) {
+			if (keymap.hasOwnProperty(k)) {
+				bind(k, keymap[k]);
+			}
+		}
+	}
+
+	function bind(combo, str) {
+		// mac fix - allow also cmd
+		if (combo.indexOf('ctrl+') !== -1) {
+			combo += ',' + combo.replace('ctrl', 'command');
+		}
+
+		// unbind possible old binding
+		key.unbind(combo);
+
+		key(combo, function (e) {
+			e.preventDefault();
+			sendStrMsg(str)
+		});
+	}
+
+	function _initKeys() {
+		// This takes care of text characters typed
+		window.addEventListener('keypress', function(evt) {
+			var str = '';
+			if (evt.key) str = evt.key;
+			else if (evt.which) str = String.fromCodePoint(evt.which);
+			if (str.length>0 && str.charCodeAt(0) >= 32) {
+//				console.log("Typed ", str);
+				sendStrMsg(str);
+			}
+		});
+
+		// ctrl-letter codes are sent as simple low ASCII codes
+		for (var i = 1; i<=26;i++) {
+			bind('ctrl+' + String.fromCharCode(96+i), String.fromCharCode(i));
+		}
+		bind('ctrl+]', '\x1b'); // alternate way to enter ESC
+		bind('ctrl+\\', '\x1c');
+		bind('ctrl+[', '\x1d');
+		bind('ctrl+^', '\x1e');
+		bind('ctrl+_', '\x1f');
+
+		_bindFnKeys();
+	}
+
 	function init() {
-		window.addEventListener('keypress', function(e) {
+		_initKeys();
-			var code = +e.which;
-			if (code >= 32 && code < 127) {
-				var ch = String.fromCharCode(code);
-				//console.log("Typed ", ch, "code", code, e);
-				sendStrMsg(ch);
-			}
-		});
-
-		window.addEventListener('keydown', function(e) {
-			var code = e.keyCode;
-			//console.log("Down ", code, e);
-			switch(code) {
-				case 8: sendStrMsg('\x08'); break;
-				case 10:
-				case 13: sendStrMsg('\x0d\x0a'); break;
-				case 27: sendStrMsg('\x1b'); break; // this allows to directly enter control sequences
-				case 37: sendStrMsg('\x1b[D'); break;
-				case 38: sendStrMsg('\x1b[A'); break;
-				case 39: sendStrMsg('\x1b[C'); break;
-				case 40: sendStrMsg('\x1b[B'); break;
-			}
-		});
 
+		// Button presses
 		qsa('#buttons button').forEach(function(s) {
 			s.addEventListener('click', function() {
 				sendBtnMsg(+this.dataset['n']);
@@ -1551,6 +2113,16 @@ var Input = (function() {
 		init: init,
 		onTap: sendPosMsg,
 		sendString: sendStrMsg,
+		setAlts: function(cu, np, fn) {
+			if (opts.cu_alt != cu || opts.np_alt != np || opts.fn_alt != fn) {
+				opts.cu_alt = cu;
+				opts.np_alt = np;
+				opts.fn_alt = fn;
+
+				// rebind keys - codes have changed
+				_bindFnKeys();
+			}
+		},
 	};
 })();
 

html_orig/jssrc/appcommon.js

@@ -123,3 +123,67 @@ $.ready(function() {
 		}, 1);
 	}
 });
+
+
+/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+if (!String.fromCodePoint) {
+	(function() {
+		var defineProperty = (function() {
+			// IE 8 only supports `Object.defineProperty` on DOM elements
+			try {
+				var object = {};
+				var $defineProperty = Object.defineProperty;
+				var result = $defineProperty(object, object, object) && $defineProperty;
+			} catch(error) {}
+			return result;
+		}());
+		var stringFromCharCode = String.fromCharCode;
+		var floor = Math.floor;
+		var fromCodePoint = function() {
+			var MAX_SIZE = 0x4000;
+			var codeUnits = [];
+			var highSurrogate;
+			var lowSurrogate;
+			var index = -1;
+			var length = arguments.length;
+			if (!length) {
+				return '';
+			}
+			var result = '';
+			while (++index < length) {
+				var codePoint = Number(arguments[index]);
+				if (
+					!isFinite(codePoint) ||       // `NaN`, `+Infinity`, or `-Infinity`
+					codePoint < 0 ||              // not a valid Unicode code point
+					codePoint > 0x10FFFF ||       // not a valid Unicode code point
+					floor(codePoint) != codePoint // not an integer
+				) {
+					throw RangeError('Invalid code point: ' + codePoint);
+				}
+				if (codePoint <= 0xFFFF) { // BMP code point
+					codeUnits.push(codePoint);
+				} else { // Astral code point; split in surrogate halves
+					// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+					codePoint -= 0x10000;
+					highSurrogate = (codePoint >> 10) + 0xD800;
+					lowSurrogate = (codePoint % 0x400) + 0xDC00;
+					codeUnits.push(highSurrogate, lowSurrogate);
+				}
+				if (index + 1 == length || codeUnits.length > MAX_SIZE) {
+					result += stringFromCharCode.apply(null, codeUnits);
+					codeUnits.length = 0;
+				}
+			}
+			return result;
+		};
+		if (defineProperty) {
+			defineProperty(String, 'fromCodePoint', {
+				'value': fromCodePoint,
+				'configurable': true,
+				'writable': true
+			});
+		} else {
+			String.fromCodePoint = fromCodePoint;
+		}
+	}());
+}

html_orig/jssrc/keymaster.js

@@ -0,0 +1,301 @@
+//     keymaster.js
+//     (c) 2011-2013 Thomas Fuchs
+//     keymaster.js may be freely distributed under the MIT license.
+
+;(function(global){
+  var k,
+    _handlers = {},
+    _mods = { 16: false, 18: false, 17: false, 91: false },
+    _scope = 'all',
+    // modifier keys
+    _MODIFIERS = {
+      '⇧': 16, shift: 16,
+      '⌥': 18, alt: 18, option: 18,
+      '⌃': 17, ctrl: 17, control: 17,
+      '⌘': 91, command: 91
+    },
+    // special keys
+    _MAP = {
+      backspace: 8, tab: 9, clear: 12,
+      enter: 13, 'return': 13,
+      esc: 27, escape: 27, space: 32,
+      left: 37, up: 38,
+      right: 39, down: 40,
+      del: 46, 'delete': 46,
+      home: 36, end: 35,
+      pageup: 33, pagedown: 34,
+      ',': 188, '.': 190, '/': 191,
+      '`': 192, '-': 189, '=': 187,
+      ';': 186, '\'': 222,
+      '[': 219, ']': 221, '\\': 220,
+      // added:
+      insert: 45,
+      np_0: 96, np_1: 97, np_2: 98, np_3: 99, np_4: 100, np_5: 101,
+	  np_6: 102, np_7: 103, np_8: 104, np_9: 105, np_mul: 106,
+	  np_add: 107, np_sub: 109, np_point: 110, np_div: 111, numlock: 144,
+    },
+    code = function(x){
+      return _MAP[x] || x.toUpperCase().charCodeAt(0);
+    },
+    _downKeys = [];
+
+  for(k=1;k<20;k++) _MAP['f'+k] = 111+k;
+
+  // IE doesn't support Array#indexOf, so have a simple replacement
+  function index(array, item){
+    var i = array.length;
+    while(i--) if(array[i]===item) return i;
+    return -1;
+  }
+
+  // for comparing mods before unassignment
+  function compareArray(a1, a2) {
+    if (a1.length != a2.length) return false;
+    for (var i = 0; i < a1.length; i++) {
+        if (a1[i] !== a2[i]) return false;
+    }
+    return true;
+  }
+
+  var modifierMap = {
+      16:'shiftKey',
+      18:'altKey',
+      17:'ctrlKey',
+      91:'metaKey'
+  };
+  function updateModifierKey(event) {
+      for(k in _mods) _mods[k] = event[modifierMap[k]];
+  };
+
+  // handle keydown event
+  function dispatch(event) {
+    var key, handler, k, i, modifiersMatch, scope;
+    key = event.keyCode;
+
+    if (index(_downKeys, key) == -1) {
+        _downKeys.push(key);
+    }
+
+    // if a modifier key, set the key.<modifierkeyname> property to true and return
+    if(key == 93 || key == 224) key = 91; // right command on webkit, command on Gecko
+    if(key in _mods) {
+      _mods[key] = true;
+      // 'assignKey' from inside this closure is exported to window.key
+      for(k in _MODIFIERS) if(_MODIFIERS[k] == key) assignKey[k] = true;
+      return;
+    }
+    updateModifierKey(event);
+
+    // see if we need to ignore the keypress (filter() can can be overridden)
+    // by default ignore key presses if a select, textarea, or input is focused
+    if(!assignKey.filter.call(this, event)) return;
+
+    // abort if no potentially matching shortcuts found
+    if (!(key in _handlers)) return;
+
+    scope = getScope();
+
+    // for each potential shortcut
+    for (i = 0; i < _handlers[key].length; i++) {
+      handler = _handlers[key][i];
+
+      // see if it's in the current scope
+      if(handler.scope == scope || handler.scope == 'all'){
+        // check if modifiers match if any
+        modifiersMatch = handler.mods.length > 0;
+        for(k in _mods)
+          if((!_mods[k] && index(handler.mods, +k) > -1) ||
+            (_mods[k] && index(handler.mods, +k) == -1)) modifiersMatch = false;
+        // call the handler and stop the event if neccessary
+        if((handler.mods.length == 0 && !_mods[16] && !_mods[18] && !_mods[17] && !_mods[91]) || modifiersMatch){
+          if(handler.method(event, handler)===false){
+            if(event.preventDefault) event.preventDefault();
+              else event.returnValue = false;
+            if(event.stopPropagation) event.stopPropagation();
+            if(event.cancelBubble) event.cancelBubble = true;
+          }
+        }
+      }
+    }
+  };
+
+  // unset modifier keys on keyup
+  function clearModifier(event){
+    var key = event.keyCode, k,
+        i = index(_downKeys, key);
+
+    // remove key from _downKeys
+    if (i >= 0) {
+        _downKeys.splice(i, 1);
+    }
+
+    if(key == 93 || key == 224) key = 91;
+    if(key in _mods) {
+      _mods[key] = false;
+      for(k in _MODIFIERS) if(_MODIFIERS[k] == key) assignKey[k] = false;
+    }
+  };
+
+  function resetModifiers() {
+    for(k in _mods) _mods[k] = false;
+    for(k in _MODIFIERS) assignKey[k] = false;
+  };
+
+  // parse and assign shortcut
+  function assignKey(key, scope, method){
+    var keys, mods;
+    keys = getKeys(key);
+    if (method === undefined) {
+      method = scope;
+      scope = 'all';
+    }
+
+    // for each shortcut
+    for (var i = 0; i < keys.length; i++) {
+      // set modifier keys if any
+      mods = [];
+      key = keys[i].split('+');
+      if (key.length > 1){
+        mods = getMods(key);
+        key = [key[key.length-1]];
+      }
+      // convert to keycode and...
+      key = key[0]
+      key = code(key);
+      // ...store handler
+      if (!(key in _handlers)) _handlers[key] = [];
+      _handlers[key].push({ shortcut: keys[i], scope: scope, method: method, key: keys[i], mods: mods });
+    }
+  };
+
+  // unbind all handlers for given key in current scope
+  function unbindKey(key, scope) {
+    var multipleKeys, keys,
+      mods = [],
+      i, j, obj;
+
+    multipleKeys = getKeys(key);
+
+    for (j = 0; j < multipleKeys.length; j++) {
+      keys = multipleKeys[j].split('+');
+
+      if (keys.length > 1) {
+        mods = getMods(keys);
+      }
+
+      key = keys[keys.length - 1];
+      key = code(key);
+
+      if (scope === undefined) {
+        scope = getScope();
+      }
+      if (!_handlers[key]) {
+        return;
+      }
+      for (i = 0; i < _handlers[key].length; i++) {
+        obj = _handlers[key][i];
+        // only clear handlers if correct scope and mods match
+        if (obj.scope === scope && compareArray(obj.mods, mods)) {
+          _handlers[key][i] = {};
+        }
+      }
+    }
+  };
+
+  // Returns true if the key with code 'keyCode' is currently down
+  // Converts strings into key codes.
+  function isPressed(keyCode) {
+      if (typeof(keyCode)=='string') {
+        keyCode = code(keyCode);
+      }
+      return index(_downKeys, keyCode) != -1;
+  }
+
+  function getPressedKeyCodes() {
+      return _downKeys.slice(0);
+  }
+
+  function filter(event){
+    var tagName = (event.target || event.srcElement).tagName;
+    // ignore keypressed in any elements that support keyboard data input
+    return !(tagName == 'INPUT' || tagName == 'SELECT' || tagName == 'TEXTAREA');
+  }
+
+  // initialize key.<modifier> to false
+  for(k in _MODIFIERS) assignKey[k] = false;
+
+  // set current scope (default 'all')
+  function setScope(scope){ _scope = scope || 'all' };
+  function getScope(){ return _scope || 'all' };
+
+  // delete all handlers for a given scope
+  function deleteScope(scope){
+    var key, handlers, i;
+
+    for (key in _handlers) {
+      handlers = _handlers[key];
+      for (i = 0; i < handlers.length; ) {
+        if (handlers[i].scope === scope) handlers.splice(i, 1);
+        else i++;
+      }
+    }
+  };
+
+  // abstract key logic for assign and unassign
+  function getKeys(key) {
+    var keys;
+    key = key.replace(/\s/g, '');
+    keys = key.split(',');
+    if ((keys[keys.length - 1]) == '') {
+      keys[keys.length - 2] += ',';
+    }
+    return keys;
+  }
+
+  // abstract mods logic for assign and unassign
+  function getMods(key) {
+    var mods = key.slice(0, key.length - 1);
+    for (var mi = 0; mi < mods.length; mi++)
+    mods[mi] = _MODIFIERS[mods[mi]];
+    return mods;
+  }
+
+  // cross-browser events
+  function addEvent(object, event, method) {
+    if (object.addEventListener)
+      object.addEventListener(event, method, false);
+    else if(object.attachEvent)
+      object.attachEvent('on'+event, function(){ method(window.event) });
+  };
+
+  // set the handlers globally on document
+  addEvent(document, 'keydown', function(event) { dispatch(event) }); // Passing _scope to a callback to ensure it remains the same by execution. Fixes #48
+  addEvent(document, 'keyup', clearModifier);
+
+  // reset modifiers to false whenever the window is (re)focused.
+  addEvent(window, 'focus', resetModifiers);
+
+  // store previously defined key
+  var previousKey = global.key;
+
+  // restore previously defined key and return reference to our key object
+  function noConflict() {
+    var k = global.key;
+    global.key = previousKey;
+    return k;
+  }
+
+  // set window.key and window.key.set/get/deleteScope, and the default filter
+  global.key = assignKey;
+  global.key.setScope = setScope;
+  global.key.getScope = getScope;
+  global.key.deleteScope = deleteScope;
+  global.key.filter = filter;
+  global.key.isPressed = isPressed;
+  global.key.getPressedKeyCodes = getPressedKeyCodes;
+  global.key.noConflict = noConflict;
+  global.key.unbind = unbindKey;
+
+  if(typeof module !== 'undefined') module.exports = assignKey;
+
+})(this);

html_orig/jssrc/term.js

@@ -8,29 +8,29 @@ var Screen = (function () {
 		y: 0,
 		fg: 7,           // colors 0-15
 		bg: 0,
-		bold: false,
+		attrs: 0,
 		suppress: false, // do not turn on in blink interval (for safe moving)
-		hidden: false    // do not show
+		hidden: false,    // do not show
+		hanging: false,   // xenl
 	};
 
 	var screen = [];
 	var blinkIval;
 
-	/** Clear screen */
+	var frakturExceptions = {
-	function _clear() {
+		'C': '\u212d',
-		for (var i = W*H-1; i>=0; i--) {
+		'H': '\u210c',
-			var cell = screen[i];
+		'I': '\u2111',
-			cell.t = ' ';
+		'R': '\u211c',
-			cell.bg = cursor.bg;
+		'Z': '\u2128',
-			cell.fg = cursor.fg;
+	};
-			cell.bold = false;
-			_draw(cell);
-		}
-	}
 
-	/** Set text and color at XY */
+	// for BEL
-	function _cellAt(y, x) {
+	var audioCtx = null;
-		return screen[y*W+x];
+	try {
+		audioCtx = new (window.AudioContext || window.audioContext || window.webkitAudioContext)();
+	} catch (er) {
+		console.error("Browser does not support AudioContext, can't beep.", er);
 	}
 
 	/** Get cell under cursor */
@@ -38,13 +38,6 @@ var Screen = (function () {
 		return screen[cursor.y*W + cursor.x];
 	}
 
-	/** Enable or disable cursor visibility */
-	function _cursorEnable(enable) {
-		cursor.hidden = !enable;
-		cursor.a &= enable;
-		_draw(_curCell());
-	}
-
 	/** Safely move cursor */
 	function cursorSet(y, x) {
 		// Hide and prevent from showing up during the move
@@ -59,17 +52,49 @@ var Screen = (function () {
 
 	/** Update cell on display. inv = invert (for cursor) */
 	function _draw(cell, inv) {
+		if (!cell) return;
 		if (typeof inv == 'undefined') {
 			inv = cursor.a && cursor.x == cell.x && cursor.y == cell.y;
 		}
 
-		var e = cell.e, fg, bg;
+		var elem = cell.e, fg, bg, cn, t;
 		// Colors
 		fg = inv ? cell.bg : cell.fg;
 		bg = inv ? cell.fg : cell.bg;
 		// Update
-		e.innerText = (cell.t + ' ')[0];
+		elem.textContent = t = (cell.t + ' ')[0];
-		e.className = 'fg' + fg + ' bg' + bg + (cell.bold ? ' bold' : '');
+
+		cn = 'fg' + fg + ' bg' + bg;
+		if (cell.attrs & (1<<0)) cn += ' bold';
+		if (cell.attrs & (1<<2)) cn += ' italic';
+		if (cell.attrs & (1<<3)) cn += ' under';
+		if (cell.attrs & (1<<4)) cn += ' blink';
+		if (cell.attrs & (1<<5)) {
+			cn += ' fraktur';
+			// perform substitution
+			if (t >= 'a' && t <= 'z') {
+				t = String.fromCodePoint(0x1d51e - 97 + t.charCodeAt(0));
+			}
+			else if (t >= 'A' && t <= 'Z') {
+				// this set is incomplete, some exceptions are needed
+				if (frakturExceptions.hasOwnProperty(t)) {
+					t = frakturExceptions[t];
+				} else {
+					t = String.fromCodePoint(0x1d504 - 65 + t.charCodeAt(0));
+				}
+			}
+			elem.textContent = t;
+		}
+		if (cell.attrs & (1<<6)) cn += ' strike';
+
+		if (cell.attrs & (1<<1)) {
+			cn += ' faint';
+			// faint requires special html - otherwise it would also dim the background.
+			// we use opacity on the text...
+			elem.innerHTML = '<span>' + e(elem.textContent) + '</span>';
+		}
+
+		elem.className = cn;
 	}
 
 	/** Show entire screen */
@@ -111,8 +136,9 @@ var Screen = (function () {
 
 			cell = {
 				t: ' ',
-				fg: cursor.fg,
+				fg: 7,
-				bg: cursor.bg,
+				bg: 0, // the colors will be replaced immediately as we receive data (user won't see this)
+				attrs: 0,
 				e: e,
 				x: i % W,
 				y: Math.floor(i / W),
@@ -128,7 +154,8 @@ var Screen = (function () {
 		clearInterval(blinkIval);
 		blinkIval = setInterval(function () {
 			cursor.a = !cursor.a;
-			if (cursor.hidden) {
+			// TODO try to invent a new way to indicate "hanging" - this is copied from gtkterm
+			if (cursor.hidden || cursor.hanging) {
 				cursor.a = false;
 			}
 
@@ -136,6 +163,15 @@ var Screen = (function () {
 				_draw(_curCell(), cursor.a);
 			}
 		}, 500);
+
+		// blink attribute
+		setInterval(function () {
+			$('#screen').removeClass('blink-hide');
+			setTimeout(function() {
+				$('#screen').addClass('blink-hide');
+			}, 800); // 200 ms ON
+		}, 1000);
+
 		inited = true;
 	}
 
@@ -144,11 +180,18 @@ var Screen = (function () {
 		return (s.charCodeAt(i++) - 1) + (s.charCodeAt(i) - 1) * 127;
 	}
 
-	var SEQ_SET_COLOR = 1;
+	/** Decode three-byte number */
+	function parse3B(s, i) {
+		return (s.charCodeAt(i) - 1) + (s.charCodeAt(i+1) - 1) * 127 + (s.charCodeAt(i+2) - 1) * 127 * 127;
+	}
+
+	var SEQ_SET_COLOR_ATTR = 1;
 	var SEQ_REPEAT = 2;
+	var SEQ_SET_COLOR = 3;
+	var SEQ_SET_ATTR = 4;
 
 	function _load_content(str) {
-		var i = 0, ci = 0, j, jc, num, num2, t = ' ', fg, bg, bold, cell;
+		var i = 0, ci = 0, j, jc, num, num2, t = ' ', fg, bg, attrs, cell;
 
 		if (!inited) _init();
 
@@ -168,27 +211,39 @@ var Screen = (function () {
 
 		// Attributes
 		num = parse2B(str, i); i += 2; // fg bg bold hidden
-		cursor.fg = num & 0x0F;
+		cursor.hidden = !(num & 0x0001);
-		cursor.bg = (num & 0xF0) >> 4;
+		cursor.hanging = !!(num & 0x0002);
-		cursor.bold = !!(num & 0x100);
+		// console.log("Attributes word ",num.toString(16)+'h');
-		cursor.hidden = !(num & 0x200);
-		// console.log("FG ",cursor.fg, ", BG ", cursor.bg,", BOLD ", cursor.bold, ", HIDE ", cursor.hidden);
 
-		fg = cursor.fg;
+		Input.setAlts(
-		bg = cursor.bg;
+			!!(num & 0x0004), // cu
-		bold = cursor.bold;
+			!!(num & 0x0008), // np
+			!!(num & 0x0010) // fn
+		);
+
+		fg = 7;
+		bg = 0;
+		attrs = 0;
 
 		// Here come the content
 		while(i < str.length && ci<W*H) {
 
 			j = str[i++];
 			jc = j.charCodeAt(0);
-			if (jc == SEQ_SET_COLOR) {
+			if (jc == SEQ_SET_COLOR_ATTR) {
+				num = parse3B(str, i); i += 3;
+				fg = num & 0x0F;
+				bg = (num & 0xF0) >> 4;
+				attrs = (num & 0xFF00)>>8;
+			}
+			else if (jc == SEQ_SET_COLOR) {
 				num = parse2B(str, i); i += 2;
 				fg = num & 0x0F;
 				bg = (num & 0xF0) >> 4;
-				bold = !!(num & 0x100);
+			}
-				// console.log("Switch to ",fg,bg,bold);
+			else if (jc == SEQ_SET_ATTR) {
+				num = parse2B(str, i); i += 2;
+				attrs = num & 0xFF;
 			}
 			else if (jc == SEQ_REPEAT) {
 				num = parse2B(str, i); i += 2;
@@ -198,7 +253,7 @@ var Screen = (function () {
 					cell.fg = fg;
 					cell.bg = bg;
 					cell.t = t;
-					cell.bold = bold;
+					cell.attrs = attrs;
 				}
 			}
 			else {
@@ -207,12 +262,17 @@ var Screen = (function () {
 				t = cell.t = j;
 				cell.fg = fg;
 				cell.bg = bg;
-				cell.bold = bold;
+				cell.attrs = attrs;
 				// console.log("Symbol ", j);
 			}
 		}
 
 		_drawAll();
+
+		if (!cursor.hidden || cursor.hanging) {
+			// hide cursor asap
+			_draw(_curCell(), false);
+		}
 	}
 
 	function _load_labels(str) {
@@ -221,11 +281,39 @@ var Screen = (function () {
 		qsa('#buttons button').forEach(function(x, i) {
 			var s = pieces[i+1].trim();
 			// if empty string, use the "dim" effect and put nbsp instead to stretch the btn vertically
-			x.innerHTML = s.length >0 ? e(s) : "&nbsp;";
+			x.innerHTML = s.length > 0 ? e(s) : "&nbsp;";
 			x.style.opacity = s.length > 0 ? 1 : 0.2;
 		});
 	}
 
+	function _beep()
+	{
+		var osc, gain;
+		if (!audioCtx) return;
+
+		// Main beep
+		osc = audioCtx.createOscillator();
+		gain = audioCtx.createGain();
+		osc.connect(gain);
+		gain.connect(audioCtx.destination);
+		gain.gain.value = 0.5;
+		osc.frequency.value = 750;
+		osc.type = 'sine';
+		osc.start();
+		osc.stop(audioCtx.currentTime+0.05);
+
+		// Surrogate beep (making it sound like 'oops')
+		osc = audioCtx.createOscillator();
+		gain = audioCtx.createGain();
+		osc.connect(gain);
+		gain.connect(audioCtx.destination);
+		gain.gain.value = 0.2;
+		osc.frequency.value = 400;
+		osc.type = 'sine';
+		osc.start(audioCtx.currentTime+0.05);
+		osc.stop(audioCtx.currentTime+0.08);
+	}
+
 	/** Load screen content from a binary sequence (new) */
 	function load(str) {
 		var content = str.substr(1);
@@ -236,6 +324,9 @@ var Screen = (function () {
 			case 'T':
 				_load_labels(content);
 				break;
+			case 'B':
+				_beep();
+				break;
 			default:
 				console.warn("Bad data message type, ignoring.");
 		}
@@ -258,12 +349,14 @@ var Conn = (function() {
 		console.warn("SOCKET CLOSED, code "+evt.code+". Reconnecting...");
 		setTimeout(function() {
 			init();
-		}, 1000);
+		}, 200);
+		// this happens when the buffer gets fucked up via invalid unicode.
+		// we basically use polling instead of socket then
 	}
 
 	function onMessage(evt) {
 		try {
-			console.log("RX: ", evt.data);
+			//console.log("RX: ", evt.data);
 			// Assume all our messages are screen updates
 			Screen.load(evt.data);
 		} catch(e) {
@@ -273,6 +366,7 @@ var Conn = (function() {
 
 	function doSend(message) {
 		console.log("TX: ", message);
+
 		if (!ws) return; // for dry testing
 		if (ws.readyState != 1) {
 			console.error("Socket not ready");
@@ -311,6 +405,12 @@ var Conn = (function() {
 
 /** User input */
 var Input = (function() {
+	var opts = {
+		np_alt: false,
+		cu_alt: false,
+		fn_alt: false,
+	};
+
 	function sendStrMsg(str) {
 		Conn.send("STR:"+str);
 	}
@@ -323,31 +423,128 @@ var Input = (function() {
 		Conn.send("BTN:"+n);
 	}
 
+	function fa(alt, normal) {
+		return opts.fn_alt ? alt : normal;
+	}
+
+	function ca(alt, normal) {
+		return opts.cu_alt ? alt : normal;
+	}
+
+	function na(alt, normal) {
+		return opts.np_alt ? alt : normal;
+	}
+
+	function _bindFnKeys() {
+		var keymap = {
+			'tab': '\x09',
+			'backspace': '\x08',
+			'enter': '\x0d',
+			'ctrl+enter': '\x0a',
+			'esc': '\x1b',
+			'up': ca('\x1bOA', '\x1b[A'),
+			'down': ca('\x1bOB', '\x1b[B'),
+			'right': ca('\x1bOC', '\x1b[C'),
+			'left': ca('\x1bOD', '\x1b[D'),
+			'home': ca('\x1bOH', fa('\x1b[H', '\x1b[1~')),
+			'insert': '\x1b[2~',
+			'delete': '\x1b[3~',
+			'end': ca('\x1bOF', fa('\x1b[F', '\x1b[4~')),
+			'pageup': '\x1b[5~',
+			'pagedown': '\x1b[6~',
+			'f1': fa('\x1bOP', '\x1b[11~'),
+			'f2': fa('\x1bOQ', '\x1b[12~'),
+			'f3': fa('\x1bOR', '\x1b[13~'),
+			'f4': fa('\x1bOS', '\x1b[14~'),
+			'f5': '\x1b[15~', // note the disconnect
+			'f6': '\x1b[17~',
+			'f7': '\x1b[18~',
+			'f8': '\x1b[19~',
+			'f9': '\x1b[20~',
+			'f10': '\x1b[21~', // note the disconnect
+			'f11': '\x1b[23~',
+			'f12': '\x1b[24~',
+			'shift+f1': fa('\x1bO1;2P', '\x1b[25~'),
+			'shift+f2': fa('\x1bO1;2Q', '\x1b[26~'), // note the disconnect
+			'shift+f3': fa('\x1bO1;2R', '\x1b[28~'),
+			'shift+f4': fa('\x1bO1;2S', '\x1b[29~'), // note the disconnect
+			'shift+f5': fa('\x1b[15;2~', '\x1b[31~'),
+			'shift+f6': fa('\x1b[17;2~', '\x1b[32~'),
+			'shift+f7': fa('\x1b[18;2~', '\x1b[33~'),
+			'shift+f8': fa('\x1b[19;2~', '\x1b[34~'),
+			'shift+f9': fa('\x1b[20;2~', '\x1b[35~'), // 35-38 are not standard - but what is?
+			'shift+f10': fa('\x1b[21;2~', '\x1b[36~'),
+			'shift+f11': fa('\x1b[22;2~', '\x1b[37~'),
+			'shift+f12': fa('\x1b[23;2~', '\x1b[38~'),
+			'np_0': na('\x1bOp', '0'),
+			'np_1': na('\x1bOq', '1'),
+			'np_2': na('\x1bOr', '2'),
+			'np_3': na('\x1bOs', '3'),
+			'np_4': na('\x1bOt', '4'),
+			'np_5': na('\x1bOu', '5'),
+			'np_6': na('\x1bOv', '6'),
+			'np_7': na('\x1bOw', '7'),
+			'np_8': na('\x1bOx', '8'),
+			'np_9': na('\x1bOy', '9'),
+			'np_mul': na('\x1bOR', '*'),
+			'np_add': na('\x1bOl', '+'),
+			'np_sub': na('\x1bOS', '-'),
+			'np_point': na('\x1bOn', '.'),
+			'np_div': na('\x1bOQ', '/'),
+			// we don't implement numlock key (should change in numpad_alt mode, but it's even more useless than the rest)
+		};
+
+		for (var k in keymap) {
+			if (keymap.hasOwnProperty(k)) {
+				bind(k, keymap[k]);
+			}
+		}
+	}
+
+	function bind(combo, str) {
+		// mac fix - allow also cmd
+		if (combo.indexOf('ctrl+') !== -1) {
+			combo += ',' + combo.replace('ctrl', 'command');
+		}
+
+		// unbind possible old binding
+		key.unbind(combo);
+
+		key(combo, function (e) {
+			e.preventDefault();
+			sendStrMsg(str)
+		});
+	}
+
+	function _initKeys() {
+		// This takes care of text characters typed
+		window.addEventListener('keypress', function(evt) {
+			var str = '';
+			if (evt.key) str = evt.key;
+			else if (evt.which) str = String.fromCodePoint(evt.which);
+			if (str.length>0 && str.charCodeAt(0) >= 32) {
+//				console.log("Typed ", str);
+				sendStrMsg(str);
+			}
+		});
+
+		// ctrl-letter codes are sent as simple low ASCII codes
+		for (var i = 1; i<=26;i++) {
+			bind('ctrl+' + String.fromCharCode(96+i), String.fromCharCode(i));
+		}
+		bind('ctrl+]', '\x1b'); // alternate way to enter ESC
+		bind('ctrl+\\', '\x1c');
+		bind('ctrl+[', '\x1d');
+		bind('ctrl+^', '\x1e');
+		bind('ctrl+_', '\x1f');
+
+		_bindFnKeys();
+	}
+
 	function init() {
-		window.addEventListener('keypress', function(e) {
+		_initKeys();
-			var code = +e.which;
-			if (code >= 32 && code < 127) {
-				var ch = String.fromCharCode(code);
-				//console.log("Typed ", ch, "code", code, e);
-				sendStrMsg(ch);
-			}
-		});
-
-		window.addEventListener('keydown', function(e) {
-			var code = e.keyCode;
-			//console.log("Down ", code, e);
-			switch(code) {
-				case 8: sendStrMsg('\x08'); break;
-				case 10:
-				case 13: sendStrMsg('\x0d\x0a'); break;
-				case 27: sendStrMsg('\x1b'); break; // this allows to directly enter control sequences
-				case 37: sendStrMsg('\x1b[D'); break;
-				case 38: sendStrMsg('\x1b[A'); break;
-				case 39: sendStrMsg('\x1b[C'); break;
-				case 40: sendStrMsg('\x1b[B'); break;
-			}
-		});
 
+		// Button presses
 		qsa('#buttons button').forEach(function(s) {
 			s.addEventListener('click', function() {
 				sendBtnMsg(+this.dataset['n']);
@@ -359,6 +556,16 @@ var Input = (function() {
 		init: init,
 		onTap: sendPosMsg,
 		sendString: sendStrMsg,
+		setAlts: function(cu, np, fn) {
+			if (opts.cu_alt != cu || opts.np_alt != np || opts.fn_alt != fn) {
+				opts.cu_alt = cu;
+				opts.np_alt = np;
+				opts.fn_alt = fn;
+
+				// rebind keys - codes have changed
+				_bindFnKeys();
+			}
+		},
 	};
 })();
 

html_orig/lang/en.php

@@ -42,6 +42,9 @@ return [
 	'term.buttons' => 'Button labels',
 	'term.theme' => 'Color scheme',
 	'term.parser_tout_ms' => 'Parser timeout',
+	'term.display_tout_ms' => 'Redraw delay',
+	'term.display_cooldown_ms' => 'Redraw cooldown',
+	'term.fn_alt_mode' => 'SS3 Fn keys',
 
 	// terminal color labels
 	'color.0' => 'Black',

html_orig/packjs.sh

@@ -3,6 +3,7 @@
 echo "Packing js..."
 
 cat jssrc/chibi.js \
+	jssrc/keymaster.js \
 	jssrc/utils.js \
 	jssrc/modal.js \
 	jssrc/notif.js \

html_orig/pages/cfg_term.php

@@ -110,6 +110,24 @@
 		<span class="mq-no-phone">&nbsp;ms</span>
 	</div>
 
+	<div class="Row">
+		<label for="display_tout_ms"><?= tr('term.display_tout_ms') ?><span class="mq-phone">&nbsp;(ms)</span></label>
+		<input type="number" step=1 min=0 name="display_tout_ms" id="display_tout_ms" value="%display_tout_ms%" required>
+		<span class="mq-no-phone">&nbsp;ms</span>
+	</div>
+
+	<div class="Row">
+		<label for="display_cooldown_ms"><?= tr('term.display_cooldown_ms') ?><span class="mq-phone">&nbsp;(ms)</span></label>
+		<input type="number" step=1 min=0 name="display_cooldown_ms" id="display_cooldown_ms" value="%display_cooldown_ms%" required>
+		<span class="mq-no-phone">&nbsp;ms</span>
+	</div>
+
+	<div class="Row checkbox" >
+		<label><?= tr('term.fn_alt_mode') ?></label><!--
+		--><span class="box" tabindex=0 role=checkbox></span>
+		<input type="hidden" id="fn_alt_mode" name="fn_alt_mode" value="%fn_alt_mode%">
+	</div>
+
 	<div class="Row buttons">
 		<a class="button icn-ok" href="#" onclick="qs('#form-1').submit()"><?= tr('apply') ?></a>
 	</div>

html_orig/sass/pages/_term.scss

@@ -86,11 +86,6 @@ body.term {
 	top: -9999px;
 }
 
-// "non-bold"
-.nb {
-	font-weight: normal !important;
-}
-
 // Tango
 .theme-0 {
 	$term-colors:
@@ -163,10 +158,36 @@ body.term {
 	}
 }
 
+// Attributes
 .bold {
 	font-weight: bold !important;
 }
 
+.faint span { // content of faint is wrapped in span
+	opacity: 0.6;
+}
+
+.italic {
+	font-style: italic;
+}
+
+.under {
+	text-decoration: underline;
+}
+
+.strike {
+	text-decoration: line-through;
+}
+
+.underline.strike {
+	text-decoration: underline line-through;
+}
+
+.blink-hide .blink {
+	color: transparent;
+}
+//
+
 .Row.color-preview {
 	font-family: monospace;
 	font-size: 16pt;

user/ansi_parser.c

@@ -2,53 +2,87 @@
 /* #line 1 "user/ansi_parser.rl" */
 #include <esp8266.h>
 #include "ansi_parser.h"
-#include "screen.h"
+#include "ansi_parser_callbacks.h"
+#include "ascii.h"
+#include "apars_logging.h"
 
 /* Ragel constants block */
 
-/* #line 10 "user/ansi_parser.c" */
+/* #line 12 "user/ansi_parser.c" */
 static const char _ansi_actions[] = {
 	0, 1, 0, 1, 1, 1, 2, 1, 
 	3, 1, 4, 1, 5, 1, 6, 1, 
 	7, 1, 8, 1, 9, 1, 10, 1, 
 	11, 1, 12, 1, 13, 1, 14, 2, 
-	2, 5, 2, 10, 11, 2, 10, 12
+	3, 6
-	
 };
 
 static const char _ansi_eof_actions[] = {
-	0, 13, 13, 13, 13, 13, 13, 13, 
+	0, 1, 1, 1, 1, 1, 1, 1, 
-	13, 13, 13, 13, 13, 13, 13, 13, 
+	1, 1, 0, 0, 0, 0, 0
-	13, 13, 13, 13, 13, 13, 13, 13, 
-	13, 13, 13, 13, 0, 0, 0, 0, 
-	0, 0, 0, 0
 };
 
 static const int ansi_start = 1;
-static const int ansi_first_final = 28;
+static const int ansi_first_final = 10;
 static const int ansi_error = 0;
 
-static const int ansi_en_CSI_body = 4;
+static const int ansi_en_CSI_body = 5;
-static const int ansi_en_OSC_body = 6;
+static const int ansi_en_STRCMD_body = 7;
-static const int ansi_en_TITLE_body = 26;
+static const int ansi_en_charsetcmd_body = 9;
 static const int ansi_en_main = 1;
 
 
-/* #line 9 "user/ansi_parser.rl" */
+/* #line 11 "user/ansi_parser.rl" */
 
 
+// Max nr of CSI parameters
+#define CSI_N_MAX 10
+#define STR_CHAR_MAX 64
+
 static volatile int cs = -1;
+static volatile bool inside_string = false;
 
-static ETSTimer resetTim;
+// public
+volatile u32 ansi_parser_char_cnt = 0;
 
-static void ICACHE_FLASH_ATTR
+void ICACHE_FLASH_ATTR
-resetParserCb(void *arg) {
+ansi_parser_reset(void) {
 	if (cs != ansi_start) {
 		cs = ansi_start;
-		warn("Parser timeout, state reset");
+		inside_string = false;
+		apars_reset_utf8buffer();
+		ansi_warn("Parser timeout, state reset");
 	}
 }
 
+#define HISTORY_LEN 10
+
+#if DEBUG_ANSI
+static char history[HISTORY_LEN + 1];
+#endif
+
+void ICACHE_FLASH_ATTR
+apars_show_context(void)
+{
+#if DEBUG_ANSI
+	char buf1[HISTORY_LEN*3+2];
+	char buf2[HISTORY_LEN*3+2];
+	char *b1 = buf1;
+	char *b2 = buf2;
+	char c;
+
+	for(int i=0;i<HISTORY_LEN;i++) {
+		c = history[i];
+		b1 += sprintf(b1, "%2X ", c);
+		if (c < 32 || c > 127) c = '.';
+		b2 += sprintf(b2, "%c  ", c);
+	}
+
+	ansi_dbg("Context: %s", buf2);
+	ansi_dbg("         %s", buf1);
+#endif
+}
+
 /**
  * \brief Linear ANSI chars stream parser
  *
@@ -63,44 +97,115 @@ resetParserCb(void *arg) {
  * \param len - length of the newdata buffer
  */
 void ICACHE_FLASH_ATTR
-ansi_parser(const char *newdata, size_t len)
+ansi_parser(char newchar)
 {
 	// The CSI code is built here
-	static char csi_leading;      //!< Leading char, 0 if none
+	static char leadchar;
-	static int  csi_ni;           //!< Number of the active digit
+	static int  arg_ni;
-	static int  csi_n[CSI_N_MAX]; //!< Param digits
+	static int  arg_cnt;
-	static char csi_char;         //!< CSI action char (end)
+	static int  arg[CSI_N_MAX];
-	static char osc_buffer[OSC_CHAR_MAX];
+	static char string_buffer[STR_CHAR_MAX];
-	static int  osc_bi;
+	static int  str_ni;
 
-	if (len == 0) len = strlen(newdata);
+	// This is used to detect timeout delay (time since last rx char)
-	
+	ansi_parser_char_cnt++;
-	// Load new data to Ragel vars
-	const char *p = newdata;
-	const char *eof = NULL;
-	const char *pe = newdata + len;
 
 	// Init Ragel on the first run
 	if (cs == -1) {
 		
-/* #line 87 "user/ansi_parser.c" */
+/* #line 117 "user/ansi_parser.c" */
 	{
 	cs = ansi_start;
 	}
 
-/* #line 57 "user/ansi_parser.rl" */
+/* #line 91 "user/ansi_parser.rl" */
+
+		#if DEBUG_ANSI
+			memset(history, 0, sizeof(history));
+		#endif
 	}
 
-	// schedule state reset
+	#if DEBUG_ANSI
-	if (termconf->parser_tout_ms > 0) {
+		for(int i=1; i<HISTORY_LEN; i++) {
-		os_timer_disarm(&resetTim);
+			history[i-1] = history[i];
-		os_timer_setfn(&resetTim, resetParserCb, NULL);
+		}
-		os_timer_arm(&resetTim, termconf->parser_tout_ms, 0);
+		history[HISTORY_LEN-1] = newchar;
+	#endif
+
+	// Handle simple characters immediately (bypass parser)
+	if (newchar < ' ') {
+		switch (newchar) {
+			case ESC:
+				if (!inside_string) {
+					// Reset state
+					cs = ansi_start;
+					// now the ESC will be processed by the parser
+				}
+				break; // proceed to parser
+
+				// Literally passed
+			case FF:
+			case VT:
+				newchar = LF; // translate to LF, like VT100 / xterm do
+			case CR:
+			case LF:
+			case BS:
+				apars_handle_plainchar(newchar);
+				return;
+
+			case TAB:
+				apars_handle_tab();
+				return;
+
+				// Select G0 or G1
+			case SI:
+				apars_handle_chs_switch(0);
+				return;
+
+			case SO:
+				apars_handle_chs_switch(1);
+				return;
+
+			case BEL:
+				// bel is also used to terminate OSC
+				if (!inside_string) {
+					apars_handle_bel();
+					return;
+				}
+				break;
+
+			case ENQ:
+				apars_handle_enq();
+				return;
+
+				// Cancel the active sequence
+			case CAN:
+			case SUB:
+				cs = ansi_start;
+				return;
+
+			default:
+				// Discard all others
+				return;
+		}
+	} else {
+		// >= ' '
+
+		// bypass the parser for simple characters (speed-up)
+		if (cs == ansi_start) {
+			apars_handle_plainchar(newchar);
+			return;
+		}
 	}
+	
+	// Load new data to Ragel vars
+	const char *p = &newchar;
+	const char *eof = NULL;
+	const char *pe = &newchar + 1;
 
 	// The parser
 	
-/* #line 104 "user/ansi_parser.c" */
+/* #line 209 "user/ansi_parser.c" */
 	{
 	const char *_acts;
 	unsigned int _nacts;
@@ -112,405 +217,296 @@ ansi_parser(const char *newdata, size_t len)
 _resume:
 	switch ( cs ) {
 case 1:
-	if ( (*p) == 27 )
-		goto tr1;
-	goto tr0;
-case 2:
 	switch( (*p) ) {
-		case 35: goto tr3;
+		case 7: goto tr1;
-		case 91: goto tr5;
+		case 27: goto tr2;
-		case 93: goto tr6;
-		case 107: goto tr7;
 	}
-	if ( (*p) < 65 ) {
+	goto tr0;
-		if ( 48 <= (*p) && (*p) <= 57 )
-			goto tr4;
-	} else if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto tr4;
-	} else
-		goto tr4;
-	goto tr2;
 case 0:
 	goto _out;
+case 2:
+	switch( (*p) ) {
+		case 32: goto tr3;
+		case 35: goto tr4;
+		case 37: goto tr5;
+		case 80: goto tr7;
+		case 88: goto tr7;
+		case 91: goto tr8;
+		case 107: goto tr7;
+	}
+	if ( (*p) < 64 ) {
+		if ( (*p) < 48 ) {
+			if ( 40 <= (*p) && (*p) <= 47 )
+				goto tr5;
+		} else if ( (*p) > 57 ) {
+			if ( 60 <= (*p) && (*p) <= 62 )
+				goto tr6;
+		} else
+			goto tr6;
+	} else if ( (*p) > 92 ) {
+		if ( (*p) < 97 ) {
+			if ( 93 <= (*p) && (*p) <= 95 )
+				goto tr7;
+		} else if ( (*p) > 122 ) {
+			if ( 124 <= (*p) && (*p) <= 126 )
+				goto tr6;
+		} else
+			goto tr6;
+	} else
+		goto tr6;
+	goto tr1;
 case 3:
-	if ( 48 <= (*p) && (*p) <= 57 )
+	if ( (*p) > 71 ) {
-		goto tr8;
+		if ( 76 <= (*p) && (*p) <= 78 )
-	goto tr2;
+			goto tr9;
-case 28:
+	} else if ( (*p) >= 70 )
-	if ( (*p) == 27 )
+		goto tr9;
-		goto tr1;
+	goto tr1;
+case 10:
+	switch( (*p) ) {
+		case 7: goto tr1;
+		case 27: goto tr2;
+	}
 	goto tr0;
 case 4:
+	if ( 48 <= (*p) && (*p) <= 57 )
+		goto tr10;
+	goto tr1;
+case 5:
 	switch( (*p) ) {
-		case 59: goto tr11;
+		case 59: goto tr13;
-		case 64: goto tr12;
+		case 64: goto tr14;
 	}
 	if ( (*p) < 60 ) {
 		if ( (*p) > 47 ) {
 			if ( 48 <= (*p) && (*p) <= 57 )
-				goto tr10;
+				goto tr12;
 		} else if ( (*p) >= 32 )
-			goto tr9;
+			goto tr11;
 	} else if ( (*p) > 63 ) {
 		if ( (*p) > 90 ) {
 			if ( 96 <= (*p) && (*p) <= 122 )
-				goto tr13;
+				goto tr15;
 		} else if ( (*p) >= 65 )
-			goto tr13;
+			goto tr15;
 	} else
-		goto tr9;
-	goto tr2;
-case 5:
-	if ( (*p) == 59 )
 		goto tr11;
-	if ( (*p) < 64 ) {
+	goto tr1;
-		if ( 48 <= (*p) && (*p) <= 57 )
-			goto tr10;
-	} else if ( (*p) > 90 ) {
-		if ( 96 <= (*p) && (*p) <= 122 )
-			goto tr13;
-	} else
-		goto tr13;
-	goto tr2;
-case 29:
-	goto tr2;
-case 30:
-	if ( (*p) == 59 )
-		goto tr11;
-	if ( (*p) < 64 ) {
-		if ( 48 <= (*p) && (*p) <= 57 )
-			goto tr10;
-	} else if ( (*p) > 90 ) {
-		if ( 96 <= (*p) && (*p) <= 122 )
-			goto tr13;
-	} else
-		goto tr13;
-	goto tr2;
 case 6:
-	switch( (*p) ) {
-		case 48: goto tr14;
-		case 66: goto tr15;
-		case 84: goto tr16;
-		case 87: goto tr17;
-	}
-	goto tr2;
-case 7:
 	if ( (*p) == 59 )
-		goto tr18;
+		goto tr13;
-	goto tr2;
+	if ( (*p) < 64 ) {
-case 8:
+		if ( 48 <= (*p) && (*p) <= 57 )
-	switch( (*p) ) {
+			goto tr12;
-		case 7: goto tr20;
+	} else if ( (*p) > 90 ) {
-		case 27: goto tr21;
+		if ( 96 <= (*p) && (*p) <= 122 )
-	}
+			goto tr15;
-	goto tr19;
+	} else
-case 31:
+		goto tr15;
-	switch( (*p) ) {
+	goto tr1;
-		case 7: goto tr20;
-		case 27: goto tr21;
-	}
-	goto tr19;
-case 9:
-	if ( (*p) == 92 )
-		goto tr22;
-	goto tr2;
-case 32:
-	goto tr2;
-case 10:
-	if ( (*p) == 84 )
-		goto tr23;
-	goto tr2;
 case 11:
-	if ( (*p) == 78 )
+	goto tr1;
-		goto tr24;
-	goto tr2;
 case 12:
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto tr25;
-	goto tr2;
-case 13:
-	if ( (*p) == 61 )
-		goto tr26;
-	goto tr2;
-case 14:
-	switch( (*p) ) {
-		case 7: goto tr28;
-		case 27: goto tr29;
-	}
-	goto tr27;
-case 33:
-	switch( (*p) ) {
-		case 7: goto tr28;
-		case 27: goto tr29;
-	}
-	goto tr27;
-case 15:
-	if ( (*p) == 92 )
-		goto tr30;
-	goto tr2;
-case 16:
-	if ( (*p) == 73 )
-		goto tr31;
-	goto tr2;
-case 17:
-	if ( (*p) == 84 )
-		goto tr32;
-	goto tr2;
-case 18:
-	if ( (*p) == 76 )
-		goto tr33;
-	goto tr2;
-case 19:
-	if ( (*p) == 69 )
-		goto tr34;
-	goto tr2;
-case 20:
-	if ( (*p) == 61 )
-		goto tr35;
-	goto tr2;
-case 21:
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto tr36;
-	goto tr2;
-case 22:
 	if ( (*p) == 59 )
-		goto tr37;
+		goto tr13;
-	if ( 48 <= (*p) && (*p) <= 57 )
+	if ( (*p) < 64 ) {
-		goto tr36;
+		if ( 48 <= (*p) && (*p) <= 57 )
-	goto tr2;
+			goto tr12;
-case 23:
+	} else if ( (*p) > 90 ) {
-	if ( 48 <= (*p) && (*p) <= 57 )
+		if ( 96 <= (*p) && (*p) <= 122 )
-		goto tr38;
+			goto tr15;
-	goto tr2;
+	} else
-case 24:
+		goto tr15;
+	goto tr1;
+case 7:
 	switch( (*p) ) {
-		case 7: goto tr39;
+		case 7: goto tr17;
-		case 27: goto tr40;
+		case 27: goto tr18;
 	}
-	if ( 48 <= (*p) && (*p) <= 57 )
+	goto tr16;
-		goto tr38;
+case 13:
-	goto tr2;
+	goto tr1;
-case 25:
+case 8:
 	if ( (*p) == 92 )
-		goto tr39;
+		goto tr17;
-	goto tr2;
+	goto tr1;
-case 26:
+case 9:
 	switch( (*p) ) {
-		case 7: goto tr42;
+		case 7: goto tr1;
-		case 27: goto tr43;
+		case 27: goto tr1;
 	}
-	goto tr41;
+	goto tr19;
-case 34:
+case 14:
-	switch( (*p) ) {
+	goto tr1;
-		case 7: goto tr42;
-		case 27: goto tr43;
-	}
-	goto tr41;
-case 27:
-	if ( (*p) == 92 )
-		goto tr44;
-	goto tr2;
-case 35:
-	goto tr2;
 	}
 
-	tr2: cs = 0; goto f0;
+	tr1: cs = 0; goto f0;
 	tr0: cs = 1; goto f1;
-	tr1: cs = 2; goto _again;
+	tr2: cs = 2; goto _again;
 	tr3: cs = 3; goto _again;
-	tr9: cs = 5; goto f7;
+	tr4: cs = 4; goto _again;
-	tr10: cs = 5; goto f8;
+	tr11: cs = 6; goto f8;
-	tr11: cs = 5; goto f9;
+	tr12: cs = 6; goto f9;
-	tr14: cs = 7; goto _again;
+	tr13: cs = 6; goto f10;
+	tr16: cs = 7; goto f13;
 	tr18: cs = 8; goto _again;
-	tr19: cs = 8; goto f12;
+	tr5: cs = 10; goto f2;
-	tr21: cs = 9; goto _again;
+	tr6: cs = 10; goto f3;
-	tr15: cs = 10; goto _again;
+	tr7: cs = 10; goto f4;
-	tr23: cs = 11; goto _again;
+	tr8: cs = 10; goto f5;
-	tr24: cs = 12; goto _again;
+	tr9: cs = 10; goto f6;
-	tr25: cs = 13; goto f8;
+	tr10: cs = 10; goto f7;
-	tr26: cs = 14; goto _again;
+	tr15: cs = 11; goto f12;
-	tr27: cs = 14; goto f12;
+	tr14: cs = 12; goto f11;
-	tr29: cs = 15; goto _again;
+	tr17: cs = 13; goto f14;
-	tr16: cs = 16; goto _again;
+	tr19: cs = 14; goto f15;
-	tr31: cs = 17; goto _again;
-	tr32: cs = 18; goto _again;
-	tr33: cs = 19; goto _again;
-	tr34: cs = 20; goto _again;
-	tr17: cs = 21; goto _again;
-	tr36: cs = 22; goto f8;
-	tr37: cs = 23; goto f9;
-	tr38: cs = 24; goto f8;
-	tr40: cs = 25; goto _again;
-	tr41: cs = 26; goto f12;
-	tr43: cs = 27; goto _again;
-	tr4: cs = 28; goto f2;
-	tr5: cs = 28; goto f3;
-	tr6: cs = 28; goto f4;
-	tr7: cs = 28; goto f5;
-	tr8: cs = 28; goto f6;
-	tr13: cs = 29; goto f11;
-	tr12: cs = 30; goto f10;
-	tr20: cs = 31; goto f13;
-	tr35: cs = 32; goto f5;
-	tr22: cs = 32; goto f14;
-	tr30: cs = 32; goto f16;
-	tr39: cs = 32; goto f17;
-	tr28: cs = 33; goto f15;
-	tr42: cs = 34; goto f13;
-	tr44: cs = 35; goto f14;
 
-	f1: _acts = _ansi_actions + 1; goto execFuncs;
+	f0: _acts = _ansi_actions + 1; goto execFuncs;
-	f3: _acts = _ansi_actions + 3; goto execFuncs;
+	f1: _acts = _ansi_actions + 3; goto execFuncs;
-	f7: _acts = _ansi_actions + 5; goto execFuncs;
+	f5: _acts = _ansi_actions + 5; goto execFuncs;
 	f8: _acts = _ansi_actions + 7; goto execFuncs;
 	f9: _acts = _ansi_actions + 9; goto execFuncs;
-	f11: _acts = _ansi_actions + 11; goto execFuncs;
+	f10: _acts = _ansi_actions + 11; goto execFuncs;
-	f0: _acts = _ansi_actions + 13; goto execFuncs;
+	f12: _acts = _ansi_actions + 13; goto execFuncs;
 	f4: _acts = _ansi_actions + 15; goto execFuncs;
-	f5: _acts = _ansi_actions + 17; goto execFuncs;
+	f13: _acts = _ansi_actions + 17; goto execFuncs;
-	f17: _acts = _ansi_actions + 19; goto execFuncs;
+	f14: _acts = _ansi_actions + 19; goto execFuncs;
-	f12: _acts = _ansi_actions + 21; goto execFuncs;
+	f7: _acts = _ansi_actions + 21; goto execFuncs;
-	f14: _acts = _ansi_actions + 23; goto execFuncs;
+	f3: _acts = _ansi_actions + 23; goto execFuncs;
-	f16: _acts = _ansi_actions + 25; goto execFuncs;
+	f6: _acts = _ansi_actions + 25; goto execFuncs;
-	f6: _acts = _ansi_actions + 27; goto execFuncs;
+	f2: _acts = _ansi_actions + 27; goto execFuncs;
-	f2: _acts = _ansi_actions + 29; goto execFuncs;
+	f15: _acts = _ansi_actions + 29; goto execFuncs;
-	f10: _acts = _ansi_actions + 31; goto execFuncs;
+	f11: _acts = _ansi_actions + 31; goto execFuncs;
-	f13: _acts = _ansi_actions + 34; goto execFuncs;
-	f15: _acts = _ansi_actions + 37; goto execFuncs;
 
 execFuncs:
 	_nacts = *_acts++;
 	while ( _nacts-- > 0 ) {
 		switch ( *_acts++ ) {
 	case 0:
-/* #line 76 "user/ansi_parser.rl" */
+/* #line 185 "user/ansi_parser.rl" */
 	{
-			apars_handle_plainchar((*p));
+			ansi_warn("Parser error.");
-		}
+			apars_show_context();
-	break;
+			inside_string = false; // no longer in string, for sure
-	case 1:
-/* #line 83 "user/ansi_parser.rl" */
-	{
-			// Reset the CSI builder
-			csi_leading = csi_char = 0;
-			csi_ni = 0;
-
-			// Zero out digits
-			for(int i = 0; i < CSI_N_MAX; i++) {
-				csi_n[i] = 0;
-			}
-
-			{cs = 4;goto _again;}
-		}
-	break;
-	case 2:
-/* #line 96 "user/ansi_parser.rl" */
-	{
-			csi_leading = (*p);
-		}
-	break;
-	case 3:
-/* #line 100 "user/ansi_parser.rl" */
-	{
-			// x10 + digit
-			if (csi_ni < CSI_N_MAX) {
-				csi_n[csi_ni] = csi_n[csi_ni]*10 + ((*p) - '0');
-			}
-		}
-	break;
-	case 4:
-/* #line 107 "user/ansi_parser.rl" */
-	{
-			csi_ni++;
-		}
-	break;
-	case 5:
-/* #line 111 "user/ansi_parser.rl" */
-	{
-			csi_char = (*p);
-
-			apars_handle_CSI(csi_leading, csi_n, csi_char);
-
 			{cs = 1;goto _again;}
 		}
 	break;
-	case 6:
+	case 1:
-/* #line 119 "user/ansi_parser.rl" */
+/* #line 194 "user/ansi_parser.rl" */
 	{
-			apars_handle_badseq();
+			if ((*p) != 0) {
+				apars_handle_plainchar((*p));
+			}
+		}
+	break;
+	case 2:
+/* #line 202 "user/ansi_parser.rl" */
+	{
+			// Reset the CSI builder
+			leadchar = NUL;
+			arg_ni = 0;
+			arg_cnt = 0;
+
+			// Zero out digits
+			for(int i = 0; i < CSI_N_MAX; i++) {
+				arg[i] = 0;
+			}
+
+			{cs = 5;goto _again;}
+		}
+	break;
+	case 3:
+/* #line 216 "user/ansi_parser.rl" */
+	{
+			leadchar = (*p);
+		}
+	break;
+	case 4:
+/* #line 220 "user/ansi_parser.rl" */
+	{
+			if (arg_cnt == 0) arg_cnt = 1;
+			// x10 + digit
+			if (arg_ni < CSI_N_MAX) {
+				arg[arg_ni] = arg[arg_ni]*10 + ((*p) - '0');
+			}
+		}
+	break;
+	case 5:
+/* #line 228 "user/ansi_parser.rl" */
+	{
+			if (arg_cnt == 0) arg_cnt = 1; // handle case when first arg is empty
+			arg_cnt++;
+			arg_ni++;
+		}
+	break;
+	case 6:
+/* #line 234 "user/ansi_parser.rl" */
+	{
+			apars_handle_csi(leadchar, arg, arg_cnt, (*p));
 			{cs = 1;goto _again;}
 		}
 	break;
 	case 7:
-/* #line 136 "user/ansi_parser.rl" */
+/* #line 245 "user/ansi_parser.rl" */
 	{
-			csi_ni = 0;
+			leadchar = (*p);
-
+			str_ni = 0;
-			// we reuse the CSI numeric buffer
+			string_buffer[0] = '\0';
-			for(int i = 0; i < CSI_N_MAX; i++) {
+			inside_string = true;
-				csi_n[i] = 0;
+			{cs = 7;goto _again;}
-			}
-
-			osc_bi = 0;
-			osc_buffer[0] = '\0';
-
-			{cs = 6;goto _again;}
 		}
 	break;
 	case 8:
-/* #line 151 "user/ansi_parser.rl" */
+/* #line 253 "user/ansi_parser.rl" */
 	{
-			osc_bi = 0;
+			string_buffer[str_ni++] = (*p);
-			osc_buffer[0] = '\0';
-			{cs = 26;goto _again;}
 		}
 	break;
 	case 9:
-/* #line 157 "user/ansi_parser.rl" */
+/* #line 257 "user/ansi_parser.rl" */
 	{
-			apars_handle_OSC_SetScreenSize(csi_n[0], csi_n[1]);
+			inside_string = false;
+			string_buffer[str_ni++] = '\0';
+			apars_handle_string_cmd(leadchar, string_buffer);
 			{cs = 1;goto _again;}
 		}
 	break;
 	case 10:
-/* #line 162 "user/ansi_parser.rl" */
+/* #line 270 "user/ansi_parser.rl" */
 	{
-			osc_buffer[osc_bi++] = (*p);
+			apars_handle_hash_cmd((*p));
+			{cs = 1;goto _again;}
 		}
 	break;
 	case 11:
-/* #line 166 "user/ansi_parser.rl" */
+/* #line 275 "user/ansi_parser.rl" */
 	{
-			osc_buffer[osc_bi++] = '\0';
+			apars_handle_short_cmd((*p));
-			apars_handle_OSC_SetTitle(osc_buffer);
 			{cs = 1;goto _again;}
 		}
 	break;
 	case 12:
-/* #line 172 "user/ansi_parser.rl" */
+/* #line 280 "user/ansi_parser.rl" */
 	{
-			osc_buffer[osc_bi++] = '\0';
+			apars_handle_space_cmd((*p));
-			apars_handle_OSC_SetButton(csi_n[0], osc_buffer);
 			{cs = 1;goto _again;}
 		}
 	break;
 	case 13:
-/* #line 204 "user/ansi_parser.rl" */
+/* #line 287 "user/ansi_parser.rl" */
 	{
-			apars_handle_hashCode((*p));
+			leadchar = (*p);
-			{cs = 1;goto _again;}
+			{cs = 9;goto _again;}
 		}
 	break;
 	case 14:
-/* #line 209 "user/ansi_parser.rl" */
+/* #line 292 "user/ansi_parser.rl" */
 	{
-			apars_handle_shortCode((*p));
+			apars_handle_chs_designate(leadchar, (*p));
 			{cs = 1;goto _again;}
 		}
 	break;
-/* #line 514 "user/ansi_parser.c" */
+/* #line 510 "user/ansi_parser.c" */
 		}
 	}
 	goto _again;
@@ -527,16 +523,18 @@ _again:
 	unsigned int __nacts = (unsigned int) *__acts++;
 	while ( __nacts-- > 0 ) {
 		switch ( *__acts++ ) {
-	case 6:
+	case 0:
-/* #line 119 "user/ansi_parser.rl" */
+/* #line 185 "user/ansi_parser.rl" */
 	{
-			apars_handle_badseq();
+			ansi_warn("Parser error.");
+			apars_show_context();
+			inside_string = false; // no longer in string, for sure
 			{cs = 1;	if ( p == pe )
 		goto _test_eof;
 goto _again;}
 		}
 	break;
-/* #line 540 "user/ansi_parser.c" */
+/* #line 538 "user/ansi_parser.c" */
 		}
 	}
 	}
@@ -544,8 +542,6 @@ goto _again;}
 	_out: {}
 	}
 
-/* #line 229 "user/ansi_parser.rl" */
+/* #line 315 "user/ansi_parser.rl" */
 
 }
-
-// 'ESC k blah OSC_end' is a shortcut for setting title (k is defined in GNU screen as Title Definition String)

user/ansi_parser.h

@@ -2,20 +2,10 @@
 #define ANSI_PARSER_H
 
 #include <stdlib.h>
-#include <screen.h>
 
-// Max nr of CSI parameters
+void ansi_parser_reset(void);
-#define CSI_N_MAX 3
-#define OSC_CHAR_MAX TERM_TITLE_LEN
 
-extern void apars_handle_badseq(void);
+extern volatile u32 ansi_parser_char_cnt;
-extern void apars_handle_plainchar(char c);
-extern void apars_handle_CSI(char leadchar, int *params, char keychar);
-extern void apars_handle_OSC_SetScreenSize(int rows, int cols);
-extern void apars_handle_OSC_SetButton(int num, const char *buffer);
-extern void apars_handle_OSC_SetTitle(const char *buffer);
-extern void apars_handle_shortCode(char c);
-extern void apars_handle_hashCode(char c);
 
 /**
  * \brief Linear ANSI chars stream parser
@@ -27,9 +17,11 @@ extern void apars_handle_hashCode(char c);
  * \attention -> but always check the Ragel output for 'p--' 
  *            or 'p -=', that means trouble.
  * 
- * \param newdata - array of new chars to process
+ * \param newchar - received char
- * \param len - length of the newdata buffer
  */
-void ansi_parser(const char *newdata, size_t len);
+void ansi_parser(char newchar);
+
+/** This shows a short error message and prints the history (if any) */
+void apars_show_context(void);
 
 #endif // ANSI_PARSER_H

user/ansi_parser.rl

@@ -1,6 +1,8 @@
 #include <esp8266.h>
 #include "ansi_parser.h"
-#include "screen.h"
+#include "ansi_parser_callbacks.h"
+#include "ascii.h"
+#include "apars_logging.h"
 
 /* Ragel constants block */
 %%{
@@ -8,18 +10,54 @@
 	write data;
 }%%
 
+// Max nr of CSI parameters
+#define CSI_N_MAX 10
+#define STR_CHAR_MAX 64
+
 static volatile int cs = -1;
+static volatile bool inside_string = false;
 
-static ETSTimer resetTim;
+// public
+volatile u32 ansi_parser_char_cnt = 0;
 
-static void ICACHE_FLASH_ATTR
+void ICACHE_FLASH_ATTR
-resetParserCb(void *arg) {
+ansi_parser_reset(void) {
 	if (cs != ansi_start) {
 		cs = ansi_start;
-		warn("Parser timeout, state reset");
+		inside_string = false;
+		apars_reset_utf8buffer();
+		ansi_warn("Parser timeout, state reset");
 	}
 }
 
+#define HISTORY_LEN 10
+
+#if DEBUG_ANSI
+static char history[HISTORY_LEN + 1];
+#endif
+
+void ICACHE_FLASH_ATTR
+apars_show_context(void)
+{
+#if DEBUG_ANSI
+	char buf1[HISTORY_LEN*3+2];
+	char buf2[HISTORY_LEN*3+2];
+	char *b1 = buf1;
+	char *b2 = buf2;
+	char c;
+
+	for(int i=0;i<HISTORY_LEN;i++) {
+		c = history[i];
+		b1 += sprintf(b1, "%2X ", c);
+		if (c < 32 || c > 127) c = '.';
+		b2 += sprintf(b2, "%c  ", c);
+	}
+
+	ansi_dbg("Context: %s", buf2);
+	ansi_dbg("         %s", buf1);
+#endif
+}
+
 /**
  * \brief Linear ANSI chars stream parser
  *
@@ -34,94 +72,167 @@ resetParserCb(void *arg) {
  * \param len - length of the newdata buffer
  */
 void ICACHE_FLASH_ATTR
-ansi_parser(const char *newdata, size_t len)
+ansi_parser(char newchar)
 {
 	// The CSI code is built here
-	static char csi_leading;      //!< Leading char, 0 if none
+	static char leadchar;
-	static int  csi_ni;           //!< Number of the active digit
+	static int  arg_ni;
-	static int  csi_n[CSI_N_MAX]; //!< Param digits
+	static int  arg_cnt;
-	static char csi_char;         //!< CSI action char (end)
+	static int  arg[CSI_N_MAX];
-	static char osc_buffer[OSC_CHAR_MAX];
+	static char string_buffer[STR_CHAR_MAX];
-	static int  osc_bi;
+	static int  str_ni;
 
-	if (len == 0) len = strlen(newdata);
+	// This is used to detect timeout delay (time since last rx char)
-	
+	ansi_parser_char_cnt++;
-	// Load new data to Ragel vars
-	const char *p = newdata;
-	const char *eof = NULL;
-	const char *pe = newdata + len;
 
 	// Init Ragel on the first run
 	if (cs == -1) {
 		%% write init;
+
+		#if DEBUG_ANSI
+			memset(history, 0, sizeof(history));
+		#endif
 	}
 
-	// schedule state reset
+	#if DEBUG_ANSI
-	if (termconf->parser_tout_ms > 0) {
+		for(int i=1; i<HISTORY_LEN; i++) {
-		os_timer_disarm(&resetTim);
+			history[i-1] = history[i];
-		os_timer_setfn(&resetTim, resetParserCb, NULL);
+		}
-		os_timer_arm(&resetTim, termconf->parser_tout_ms, 0);
+		history[HISTORY_LEN-1] = newchar;
+	#endif
+
+	// Handle simple characters immediately (bypass parser)
+	if (newchar < ' ') {
+		switch (newchar) {
+			case ESC:
+				if (!inside_string) {
+					// Reset state
+					cs = ansi_start;
+					// now the ESC will be processed by the parser
+				}
+				break; // proceed to parser
+
+				// Literally passed
+			case FF:
+			case VT:
+				newchar = LF; // translate to LF, like VT100 / xterm do
+			case CR:
+			case LF:
+			case BS:
+				apars_handle_plainchar(newchar);
+				return;
+
+			case TAB:
+				apars_handle_tab();
+				return;
+
+				// Select G0 or G1
+			case SI:
+				apars_handle_chs_switch(0);
+				return;
+
+			case SO:
+				apars_handle_chs_switch(1);
+				return;
+
+			case BEL:
+				// bel is also used to terminate OSC
+				if (!inside_string) {
+					apars_handle_bel();
+					return;
+				}
+				break;
+
+			case ENQ:
+				apars_handle_enq();
+				return;
+
+				// Cancel the active sequence
+			case CAN:
+			case SUB:
+				cs = ansi_start;
+				return;
+
+			default:
+				// Discard all others
+				return;
+		}
+	} else {
+		// >= ' '
+
+		// bypass the parser for simple characters (speed-up)
+		if (cs == ansi_start) {
+			apars_handle_plainchar(newchar);
+			return;
+		}
 	}
+	
+	// Load new data to Ragel vars
+	const char *p = &newchar;
+	const char *eof = NULL;
+	const char *pe = &newchar + 1;
 
 	// The parser
 	%%{
 #/*
 		ESC = 27;
-		NOESC = (any - ESC);
+		NOESC = (any - ESC - 7);
 		TOK_ST = ESC '\\'; # String terminator - used for OSC commands
-		OSC_END = ('\a' | ESC '\\');
+		STR_END = (7 | TOK_ST);
+
+		# --- Error handler ---
+
+		action errBadSeq {
+			ansi_warn("Parser error.");
+			apars_show_context();
+			inside_string = false; // no longer in string, for sure
+			fgoto main;
+		}
 
 		# --- Regular characters to be printed ---
 
 		action plain_char {
-			apars_handle_plainchar(fc);
+			if (fc != 0) {
+				apars_handle_plainchar(fc);
+			}
 		}
 
-		# --- CSI CSI commands (Select Graphic Rendition) ---
+		# --- CSI commands ---
-		# Text color & style
 
 		action CSI_start {
 			// Reset the CSI builder
-			csi_leading = csi_char = 0;
+			leadchar = NUL;
-			csi_ni = 0;
+			arg_ni = 0;
+			arg_cnt = 0;
 
 			// Zero out digits
 			for(int i = 0; i < CSI_N_MAX; i++) {
-				csi_n[i] = 0;
+				arg[i] = 0;
 			}
 
 			fgoto CSI_body;
 		}
 
 		action CSI_leading {
-			csi_leading = fc;
+			leadchar = fc;
 		}
 
 		action CSI_digit {
+			if (arg_cnt == 0) arg_cnt = 1;
 			// x10 + digit
-			if (csi_ni < CSI_N_MAX) {
+			if (arg_ni < CSI_N_MAX) {
-				csi_n[csi_ni] = csi_n[csi_ni]*10 + (fc - '0');
+				arg[arg_ni] = arg[arg_ni]*10 + (fc - '0');
 			}
 		}
 
 		action CSI_semi {
-			csi_ni++;
+			if (arg_cnt == 0) arg_cnt = 1; // handle case when first arg is empty
+			arg_cnt++;
+			arg_ni++;
 		}
 
 		action CSI_end {
-			csi_char = fc;
+			apars_handle_csi(leadchar, arg, arg_cnt, fc);
-
-			apars_handle_CSI(csi_leading, csi_n, csi_char);
-
-			fgoto main;
-		}
-
-		action errBadSeq {
-			apars_handle_badseq();
-			fgoto main;
-		}
-
-		action back2main {
 			fgoto main;
 		}
 
@@ -129,98 +240,73 @@ ansi_parser(const char *newdata, size_t len)
 			((digit @CSI_digit)* ';' @CSI_semi)*
 			(digit @CSI_digit)* (alpha|'`'|'@') @CSI_end $!errBadSeq;
 
+		# --- String commands ---
 
-		# --- OSC commands (Operating System Commands) ---
+		action StrCmd_start {
-		# Module parametrisation
+			leadchar = fc;
-
+			str_ni = 0;
-		action OSC_start {
+			string_buffer[0] = '\0';
-			csi_ni = 0;
+			inside_string = true;
-
+			fgoto STRCMD_body;
-			// we reuse the CSI numeric buffer
-			for(int i = 0; i < CSI_N_MAX; i++) {
-				csi_n[i] = 0;
-			}
-
-			osc_bi = 0;
-			osc_buffer[0] = '\0';
-
-			fgoto OSC_body;
 		}
 
-		# collecting title string; this can also be entered by ESC k
+		action StrCmd_char {
-		action SetTitle_start {
+			string_buffer[str_ni++] = fc;
-			osc_bi = 0;
-			osc_buffer[0] = '\0';
-			fgoto TITLE_body;
 		}
 
-		action OSC_resize {
+		action StrCmd_end {
-			apars_handle_OSC_SetScreenSize(csi_n[0], csi_n[1]);
+			inside_string = false;
+			string_buffer[str_ni++] = '\0';
+			apars_handle_string_cmd(leadchar, string_buffer);
 			fgoto main;
 		}
 
-		action OSC_text_char {
+		# According to the spec, ESC should be allowed inside the string sequence.
-			osc_buffer[osc_bi++] = fc;
+		# We disallow ESC for simplicity, as it's hardly ever used.
-		}
+		STRCMD_body := ((NOESC @StrCmd_char)* STR_END @StrCmd_end) $!errBadSeq;
 
-		action OSC_title {
+		# --- Single character ESC ---
-			osc_buffer[osc_bi++] = '\0';
-			apars_handle_OSC_SetTitle(osc_buffer);
-			fgoto main;
-		}
-
-		action OSC_button {
-			osc_buffer[osc_bi++] = '\0';
-			apars_handle_OSC_SetButton(csi_n[0], osc_buffer);
-			fgoto main;
-		}
-
-		# 0; is xterm title hack
-		OSC_body := (
-			("BTN" digit @CSI_digit '=' (NOESC @OSC_text_char)* OSC_END @OSC_button) |
-			("TITLE=" @SetTitle_start) |
-			("0;" (NOESC @OSC_text_char)* OSC_END @OSC_title) |
-			('W' (digit @CSI_digit)+ ';' @CSI_semi (digit @CSI_digit)+ OSC_END @OSC_resize)
-		) $!errBadSeq;
-
-		TITLE_body := (NOESC @OSC_text_char)* OSC_END @OSC_title $!errBadSeq;
-
-		action RESET_cmd {
-			// Reset screen
-			apars_handle_RESET_cmd();
-			fgoto main;
-		}
-
-		action CSI_SaveCursorAttrs {
-			apars_handle_saveCursorAttrs();
-			fgoto main;
-		}
-
-		action CSI_RestoreCursorAttrs {
-			apars_handle_restoreCursorAttrs();
-			fgoto main;
-		}
 
 		action HASH_code {
-			apars_handle_hashCode(fc);
+			apars_handle_hash_cmd(fc);
 			fgoto main;
 		}
 
 		action SHORT_code {
-			apars_handle_shortCode(fc);
+			apars_handle_short_cmd(fc);
 			fgoto main;
 		}
 
+		action SPACE_cmd {
+			apars_handle_space_cmd(fc);
+			fgoto main;
+		}
+
+		# --- Charset selection ---
+
+		action CharsetCmd_start {
+			leadchar = fc;
+			fgoto charsetcmd_body;
+		}
+
+		action CharsetCmd_end {
+			apars_handle_chs_designate(leadchar, fc);
+			fgoto main;
+		}
+
+		charsetcmd_body := (NOESC @CharsetCmd_end) $!errBadSeq;
+
 		# --- Main parser loop ---
 
 		main :=
 			(
 				(NOESC @plain_char)* ESC (
 					('[' @CSI_start) |
-					(']' @OSC_start) |
+					([_\]Pk\^X] @StrCmd_start) |
 					('#' digit @HASH_code) |
-					('k' @SetTitle_start) |
+					(([a-zA-Z0-9=<>~}|@\\] - [PXk]) @SHORT_code) |
-					([a-jl-zA-Z0-9] @SHORT_code)
+					([()*+-./%] @CharsetCmd_start) |
+					(' ' [FGLMN] @SPACE_cmd)
 				)
 			)+ $!errBadSeq;
 
@@ -228,5 +314,3 @@ ansi_parser(const char *newdata, size_t len)
 #*/
 	}%%
 }
-
-// 'ESC k blah OSC_end' is a shortcut for setting title (k is defined in GNU screen as Title Definition String)

user/ansi_parser_callbacks.c

@@ -5,345 +5,45 @@
  */
 
 #include <esp8266.h>
+#include <helpers.h>
 #include "ansi_parser_callbacks.h"
-#include "screen.h"
-#include "ansi_parser.h"
 #include "uart_driver.h"
-
+#include "cgi_sockets.h"
-// screen manpage - https://www.gnu.org/software/screen/manual/html_node/Control-Sequences.html
+#include "version.h"
-
+#include "uart_buffer.h"
-static char utf_collect[4];
-static int utf_i = 0;
-static int utf_j = 0;
 
 /**
- * Handle a received plain character
+ * Send a response to UART0
+ * @param str
  */
 void ICACHE_FLASH_ATTR
-apars_handle_plainchar(char c)
+apars_respond(const char *str)
 {
-	// collecting unicode glyphs...
+	UART_SendAsync(str, -1);
-	if (c & 0x80) {
+	//UART_WriteString(UART0, str, UART_TIMEOUT_US);
-		if (utf_i == 0) {
-			if ((c & 0xE0) == 0xC0) {
-				utf_i = 2;
-			}
-			else if ((c & 0xF0) == 0xE0) {
-				utf_i = 3;
-			}
-			else if ((c & 0xF8) == 0xF0) {
-				utf_i = 4;
-			}
-
-			utf_collect[0] = c;
-			utf_j = 1;
-		}
-		else {
-			utf_collect[utf_j++] = c;
-			if (utf_j >= utf_i) {
-				screen_putchar(utf_collect);
-				utf_i = 0;
-				utf_j = 0;
-				memset(utf_collect, 0, 4);
-			}
-		}
-	}
-	else {
-		utf_collect[0] = c;
-		utf_collect[1] = 0; // just to make sure it's closed...
-		screen_putchar(utf_collect);
-	}
 }
 
 /**
- * Bad sequence received, show warning
+ * Beep at the user.
  */
-void apars_handle_badseq(void)
+void ICACHE_FLASH_ATTR
+apars_handle_bel(void)
 {
-	warn("Invalid escape sequence discarded.");
+	send_beep();
 }
 
 /**
- * \brief Handle fully received CSI ANSI sequence
+ * Send to uart the answerback message
- * \param leadchar - private range leading character, 0 if none
- * \param params - array of CSI_N_MAX ints holding the numeric arguments
- * \param keychar - the char terminating the sequence
  */
 void ICACHE_FLASH_ATTR
-apars_handle_CSI(char leadchar, int *params, char keychar)
+apars_handle_enq(void)
 {
-	/*
+	// version encased in SOS and ST
-		Implemented codes (from Wikipedia)
+	apars_respond("\x1bXESPTerm " FIRMWARE_VERSION "\x1b\\");
-
-		CSI n A	CUU – Cursor Up
-		CSI n B	CUD – Cursor Down
-		CSI n C	CUF – Cursor Forward
-		CSI n D	CUB – Cursor Back
-		CSI n E	CNL – Cursor Next Line
-		CSI n F	CPL – Cursor Previous Line
-		CSI n G	CHA – Cursor Horizontal Absolute
-		CSI n ; m H	CUP – Cursor Position
-		CSI n J	ED – Erase Display
-		CSI n K	EL – Erase in Line
-		CSI n S	SU – Scroll Up
-		CSI n T	SD – Scroll Down
-		CSI n ; m f	HVP – Horizontal and Vertical Position
-		CSI n m	SGR – Select Graphic Rendition  (Implemented only some)
-		CSI 6n	DSR – Device Status Report
-		CSI s	SCP – Save Cursor Position
-		CSI u	RCP – Restore Cursor Position
-		CSI ?25l	DECTCEM	Hides the cursor
-		CSI ?25h	DECTCEM	Shows the cursor
-
-	    and some others
-	*/
-
-	int n1 = params[0];
-	int n2 = params[1];
-//	int n3 = params[2];
-
-	// defaults
-	switch (keychar) {
-		case 'A': // move
-		case 'B':
-		case 'C':
-		case 'D':
-		case 'E':
-		case 'F':
-		case 'G': // set X
-		case '`':
-		case 'S': // scrolling
-		case 'T':
-		case 'X': // clear in line
-		case 'd': // set Y
-		case 'L':
-		case 'M':
-		case '@':
-		case 'P':
-			if (n1 == 0) n1 = 1;
-			break;
-
-		case 'H':
-		case 'f':
-			if (n1 == 0) n1 = 1;
-			if (n2 == 0) n2 = 1;
-			break;
-
-		case 'J':
-		case 'K':
-			if (n1 > 2) n1 = 0;
-			break;
-	}
-
-	switch (keychar) {
-		// CUU CUD CUF CUB
-		case 'A': screen_cursor_move(-n1, 0, false); break;
-		case 'B': screen_cursor_move(n1, 0, false);  break;
-		case 'C': screen_cursor_move(0, n1, false);  break;
-		case 'D': screen_cursor_move(0, -n1, false); break;
-
-		case 'E': // CNL - Cursor Next Line
-			screen_cursor_move(n1, 0, false);
-			screen_cursor_set_x(0);
-			break;
-
-		case 'F': // CPL - Cursor Prev Line
-			screen_cursor_move(-n1, 0, false);
-			screen_cursor_set_x(0);
-			break;
-
-			// Set X
-		case 'G':
-		case '`': // alternate code
-			screen_cursor_set_x(n1 - 1);
-			break; // 1-based
-
-			// Set Y
-		case 'd':
-			screen_cursor_set_y(n1 - 1);
-			break; // 1-based
-
-			// clear in line
-		case 'X':
-			screen_clear_in_line(n1);
-			break; // 1-based
-
-			// SU, SD - scroll up/down
-		case 'S': screen_scroll_up(n1);	  break;
-		case 'T': screen_scroll_down(n1); break;
-
-			// CUP,HVP - set position
-		case 'H':
-		case 'f':
-			screen_cursor_set(n1-1, n2-1);
-			break; // 1-based
-
-		case 'J': // ED - clear screen
-			if (n1 == 0) {
-				screen_clear(CLEAR_FROM_CURSOR);
-			} else if (n1 == 1) {
-				screen_clear(CLEAR_TO_CURSOR);
-			} else {
-				screen_clear(CLEAR_ALL);
-				screen_cursor_set(0, 0);
-			}
-			break;
-
-		case 'K': // EL - clear line
-			if (n1 == 0) {
-				screen_clear_line(CLEAR_FROM_CURSOR);
-			} else if (n1 == 1) {
-				screen_clear_line(CLEAR_TO_CURSOR);
-			} else {
-				screen_clear_line(CLEAR_ALL);
-			}
-			break;
-
-			// SCP, RCP - save/restore position
-		case 's': screen_cursor_save(0); break;
-		case 'u': screen_cursor_restore(0); break;
-
-		case 'n': // queries
-			if (n1 == 6) {
-				// Query cursor position
-				char buf[20];
-				int x, y;
-				screen_cursor_get(&y, &x);
-				sprintf(buf, "\033[%d;%dR", y+1, x+1);
-				UART_WriteString(UART0, buf, UART_TIMEOUT_US);
-			}
-			else if (n1 == 5) {
-				// Query device status - reply "Device is OK"
-				UART_WriteString(UART0, "\033[0n", UART_TIMEOUT_US);
-			}
-			break;
-
-			// DECTCEM feature enable / disable
-
-		case 'h': // feature enable
-			if (leadchar == '?') {
-				if (n1 == 25) {
-					screen_cursor_enable(1);
-				} else if (n1 == 7) {
-					screen_wrap_enable(1);
-				}
-			}
-			break;
-
-		case 'l': // feature disable
-			if (leadchar == '?') {
-				if (n1 == 25) {
-					screen_cursor_enable(0);
-				} else if (n1 == 7) {
-					screen_wrap_enable(0);
-				}
-			}
-			break;
-
-		case 'm': // SGR - graphics rendition aka attributes
-			// iterate arguments
-			for (int i = 0; i < CSI_N_MAX; i++) {
-				int n = params[i];
-
-				if (i == 0 && n == 0) { // reset SGR
-					screen_reset_cursor(); // resets colors, inverse and bold.
-					break; // cannot combine reset with others - discard
-				}
-				else if (n >= 30 && n <= 37) screen_set_fg((Color) (n - 30)); // ANSI normal fg
-				else if (n >= 40 && n <= 47) screen_set_bg((Color) (n - 40)); // ANSI normal bg
-				else if (n == 39) screen_set_fg(termconf_scratch.default_fg); // default fg
-				else if (n == 49) screen_set_bg(termconf_scratch.default_bg); // default bg
-				else if (n == 7) screen_inverse(true); // inverse
-				else if (n == 27) screen_inverse(false); // positive
-				else if (n == 1) screen_set_bold(true); // bold
-				else if (n == 21 || n == 22) screen_set_bold(false); // bold off
-				else if (n >= 90 && n <= 97) screen_set_fg((Color) (n - 90 + 8)); // AIX bright fg
-				else if (n >= 100 && n <= 107) screen_set_bg((Color) (n - 100 + 8)); // AIX bright bg
-			}
-			break;
-
-		case 't': // SunView code to set screen size (from GNU Screen)
-			screen_resize(n1, n2);
-			break;
-
-		case 'L':
-			screen_insert_lines(n1);
-			break;
-
-		case 'M':
-			screen_delete_lines(n1);
-			break;
-
-		case '@':
-			screen_insert_characters(n1);
-			break;
-
-		case 'P':
-			screen_delete_characters(n1);
-			break;
-	}
-}
-
-/** codes in the format ESC # n */
-void ICACHE_FLASH_ATTR apars_handle_hashCode(char c)
-{
-	switch(c) {
-		case '8':
-			screen_fill_with_E();
-			break;
-	}
-}
-
-/** those are single-character escape codes (ESC x) */
-void ICACHE_FLASH_ATTR apars_handle_shortCode(char c)
-{
-	switch(c) {
-		case 'c': // screen reset
-			screen_reset();
-			break;
-		case '7': // save cursor + attrs
-			screen_cursor_save(true);
-			break;
-		case '8': // restore cursor + attrs
-			screen_cursor_restore(true);
-			break;
-		case 'E': // same as CR LF
-			screen_cursor_move(1, 0, false);
-			screen_cursor_set_x(0);
-			break;
-		case 'D': // move cursor down, scroll screen up if needed
-			screen_cursor_move(1, 0, true);
-			break;
-		case 'M': // move cursor up, scroll screen down if needed
-			screen_cursor_move(-1, 0, true);
-			break;
-	}
-}
-
-/**
- * Handle a screen resize request
- */
-void ICACHE_FLASH_ATTR
-apars_handle_OSC_SetScreenSize(int rows, int cols)
-{
-	info("OSC: Set screen size to %d x %d", rows, cols);
-
-	screen_resize(rows, cols);
-}
-
-
-void ICACHE_FLASH_ATTR
-apars_handle_OSC_SetButton(int num, const char *buffer)
-{
-	strncpy(termconf_scratch.btn[num-1], buffer, TERM_BTN_LEN);
-	info("OSC: Set BTN%d = %s", num, buffer);
-	screen_notifyChange(CHANGE_LABELS);
 }
 
 void ICACHE_FLASH_ATTR
-apars_handle_OSC_SetTitle(const char *buffer)
+apars_handle_tab(void)
 {
-	strncpy(termconf_scratch.title, buffer, TERM_TITLE_LEN);
+	screen_tab_forward(1);
-	info("OSC: Set TITLE = %s", buffer);
-	screen_notifyChange(CHANGE_LABELS);
 }

user/ansi_parser_callbacks.h

@@ -1,13 +1,19 @@
 #ifndef ANSI_PARSER_CALLBACKS_H
 #define ANSI_PARSER_CALLBACKS_H
 
-void apars_handle_badseq(void);
+#include "apars_csi.h"
-void apars_handle_plainchar(char c);
+#include "apars_dcs.h"
-void apars_handle_CSI(char leadchar, int *params, char keychar);
+#include "apars_osc.h"
-void apars_handle_OSC_SetScreenSize(int rows, int cols);
+#include "apars_string.h"
-void apars_handle_OSC_SetButton(int num, const char *buffer);
+#include "apars_short.h"
-void apars_handle_OSC_SetTitle(const char *buffer);
+#include "apars_utf8.h"
-void apars_handle_shortCode(char c);
+
-void apars_handle_hashCode(char c);
+void apars_respond(const char *str);
+
+void apars_handle_bel(void);
+void apars_handle_enq(void);
+void apars_handle_tab(void);
+
+extern void apars_show_context(void);
 
 #endif //ESP_VT100_FIRMWARE_ANSI_PARSER_CALLBACKS_H

user/apars_csi.c

@@ -0,0 +1,667 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+// Handle CSI sequences
+// CSI <symbol?> Pm <symbol?> <char>
+// (CSI = ESC [)
+//
+// Example of those are cursor manipulation sequences and SGR.
+//
+// For details, see:
+// http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Functions-using-CSI-_-ordered-by-the-final-character_s_
+//
+// Note:
+// not all sequences listed in the xterm manual are implemented, notably sequences with the trailing symbol,
+// graphic mode sequences, mouse reporting and complex multi-argument sequences that operate on regions.
+//
+// The screen size can be set using the xterm sequence: CSI Py ; Px t
+//
+
+#include <esp8266.h>
+#include "apars_csi.h"
+#include "screen.h"
+#include "apars_logging.h"
+#include "ansi_parser.h"
+#include "ascii.h"
+#include "ansi_parser_callbacks.h"
+#include "uart_driver.h"
+#include "sgr.h"
+#include "version.h"
+#include "syscfg.h"
+
+// TODO simplify file - split to subroutines
+
+static void warn_bad_csi()
+{
+	ansi_noimpl_r("Unknown CSI");
+	apars_show_context();
+}
+
+typedef struct {
+	char lead;
+	const int *n;
+	int count;
+	char aug; // augmenting
+	char key;
+} CSI_Data;
+
+static void do_csi_privattr(CSI_Data *opts);
+static void do_csi_sgr(CSI_Data *opts);
+static void do_csi_decreqtparm(CSI_Data *opts);
+
+/**
+ * Handle fully received CSI ANSI sequence
+ * @param leadchar - private range leading character, 0 if none
+ * @param params - array of CSI_N_MAX ints holding the numeric arguments
+ * @param keychar - the char terminating the sequence
+ */
+void ICACHE_FLASH_ATTR
+apars_handle_csi(char leadchar, const int *params, int count, char keychar)
+{
+	CSI_Data opts = {leadchar, params, count, NUL, keychar};
+	char buf[32];
+	bool yn = false; // for ? l h
+
+	int n1 = params[0];
+	int n2 = params[1];
+	int n3 = params[2];
+
+	// defaults - FIXME this may inadvertently affect some variants that should be left unchanged
+	switch (keychar) {
+		case 'A': // move
+		case 'a':
+		case 'e':
+		case 'B':
+		case 'C':
+		case 'D':
+		case 'b':
+		case 'E':
+		case 'F':
+		case 'G': // set X
+		case '`':
+		case 'S': // scrolling
+		case 'T':
+		case 'X': // clear in line
+		case 'd': // set Y
+		case 'L':
+		case 'M':
+		case '@':
+		case 'P':
+		case 'I':
+		case 'Z':
+			if (n1 == 0) n1 = 1;
+			break;
+
+		case 'H':
+		case 'f':
+			if (n1 == 0) n1 = 1;
+			if (n2 == 0) n2 = 1;
+			break;
+
+		case 'J':
+		case 'K':
+			if (n1 > 2) n1 = 0;
+			break;
+
+		default:
+			// leave as is
+			break;
+	}
+
+	switch (keychar) {
+		// CUU CUD CUF CUB
+		case 'A': // Up
+			screen_cursor_move(-n1, 0, false);
+			break;
+
+		case 'e':
+		case 'B': // Down
+			screen_cursor_move(n1, 0, false);
+			break;
+
+		case 'a': // some archaic form of "Go Right"
+		case 'C': // Right (forward)
+			screen_cursor_move(0, n1, false);
+			break;
+
+		case 'D': // Left (backward)
+			screen_cursor_move(0, -n1, false);
+			break;
+
+		case 'E': // CNL - Cursor Next Line
+			screen_cursor_move(n1, 0, false);
+			screen_cursor_set_x(0);
+			break;
+
+		case 'F': // CPL - Cursor Prev Line
+			screen_cursor_move(-n1, 0, false);
+			screen_cursor_set_x(0);
+			break;
+
+		case 'b':
+			// TODO repeat preceding graphic character n1 times
+			ansi_noimpl("Repeat char");
+			return;
+
+			// Set X
+		case 'G':
+		case '`': // alternate code
+			screen_cursor_set_x(n1 - 1);
+			break; // 1-based
+
+			// Set Y
+		case 'd':
+			screen_cursor_set_y(n1 - 1);
+			break; // 1-based
+
+			// Clear in line
+		case 'X':
+			screen_clear_in_line(n1);
+			break; // 1-based
+
+			// SU, SD - scroll up/down
+		case 'S':
+			if (leadchar == NUL && count <= 1) {
+				screen_scroll_up(n1);
+			}
+			else {
+				// other:
+				// CSI ? Pi; Pa; Pv S (sixel)
+				warn_bad_csi();
+			}
+			break;
+
+		case 'T':
+			if (leadchar == NUL && count <= 1) {
+				// CSI Ps T
+				screen_scroll_down(n1);
+			}
+			else {
+				// other:
+				// CSI Ps ; Ps ; Ps ; Ps ; Ps T
+				// CSI > Ps; Ps T
+				warn_bad_csi();
+			}
+			break;
+
+		case 't': // xterm window commands
+			if (leadchar == NUL && count <= 2) {
+				// CSI Ps ; Ps ; Ps t
+				switch (n1) {
+					case 8: // set size
+						screen_resize(n2, n3);
+						break;
+
+					case 18: // report size
+						printf(buf, "\033[8;%d;%dt", termconf_scratch.height, termconf_scratch.width);
+						apars_respond(buf);
+						break;
+
+					case 21: // Report title
+						apars_respond("\033]L");
+						apars_respond(termconf_scratch.title);
+						apars_respond("\033\\");
+						break;
+
+					case 24: // Set Height only
+						screen_resize(n2, termconf_scratch.width);
+						break;
+
+					default:
+						ansi_noimpl("CSI %d t", n1);
+						break;
+				}
+			}
+			else {
+				// other:
+				// CSI > Ps; Ps t
+				// CSI Ps SP t,
+				warn_bad_csi();
+			}
+			break;
+
+			// CUP,HVP - set position
+		case 'H':
+		case 'f':
+			screen_cursor_set(n1-1, n2-1);
+			break; // 1-based
+
+		case 'J': // Erase screen
+			if (leadchar == '?') {
+				// TODO selective erase
+				ansi_noimpl("Selective erase");
+			}
+
+			if (n1 == 0) {
+				screen_clear(CLEAR_FROM_CURSOR);
+			} else if (n1 == 1) {
+				screen_clear(CLEAR_TO_CURSOR);
+			} else {
+				screen_clear(CLEAR_ALL);
+				screen_cursor_set(0, 0);
+			}
+			break;
+
+		case 'K': // Erase lines
+			if (leadchar == '?') {
+				// TODO selective erase
+				ansi_noimpl("Selective erase");
+			}
+
+			if (n1 == 0) {
+				screen_clear_line(CLEAR_FROM_CURSOR);
+			} else if (n1 == 1) {
+				screen_clear_line(CLEAR_TO_CURSOR);
+			} else {
+				screen_clear_line(CLEAR_ALL);
+			}
+			break;
+
+			// SCP, RCP - save/restore position
+		case 's':
+			if (leadchar == NUL && count == 0) {
+				screen_cursor_save(0);
+			}
+			else if (leadchar == '?') {
+				// Save private attributes (CSI ? Pm h/l)
+				ansi_noimpl("Save private attrs");
+			}
+			else {
+				// other:
+				// CSI ? Pm s
+				// CSI Pl; Pr s
+				warn_bad_csi();
+			}
+			break;
+
+		case 'r':
+			if (leadchar == NUL && (count == 2 || count == 0)) {
+				screen_set_scrolling_region(n1-1, n2-1);
+			}
+			else if (leadchar == '?') {
+				// Restore private attributes (CSI ? Pm h/l)
+				ansi_noimpl("Restore private attrs");
+			}
+			else {
+				// other:
+				// CSI ? Pm r
+				// CSI Pt; Pl; Pb; Pr; Ps$ r
+				warn_bad_csi();
+			}
+			break;
+
+		case 'u':
+			if (leadchar == NUL && count == 0) {
+				screen_cursor_restore(0);
+			}
+			else {
+				warn_bad_csi();
+			}
+			break;
+
+		case 'h': // DEC feature enable
+		case 'l': // DEC feature disable
+			do_csi_privattr(&opts);
+			break;
+
+		case 'm': // SGR - set graphics rendition
+			do_csi_sgr(&opts);
+			break;
+
+		case 'L': // Insert lines (shove down)
+			screen_insert_lines(n1);
+			break;
+
+		case 'M': // Delete lines (pull up)
+			screen_delete_lines(n1);
+			break;
+
+		case '@': // Insert in line (shove right)
+			screen_insert_characters(n1);
+			break;
+
+		case 'P': // Delete in line (pull left)
+			screen_delete_characters(n1);
+			break;
+
+		case 'g': // Clear tabs
+			if (n1 == 3) {
+				screen_clear_all_tabs();
+			}
+			else if (n1 == 0) {
+				screen_clear_tab();
+			}
+			break;
+
+		case 'Z': // Tab backward
+			screen_tab_reverse(n1);
+			break;
+
+		case 'I': // Tab forward
+			screen_tab_forward(n1);
+			break;
+
+		case 'p':
+			if (leadchar == '!') { // RIS
+				/* On real VT there are differences between soft and hard reset, we treat both equally */
+				screen_reset();
+			}
+			else {
+				warn_bad_csi();
+			}
+			break;
+
+		case 'n': // Queries
+			if (leadchar == '>') {
+				// some xterm garbage - discard
+				// CSI > Ps n
+				ansi_noimpl("CSI > %d n", n1);
+				break;
+			}
+
+			if (leadchar == NUL) {
+				if (n1 == 6) {
+					// Query cursor position
+					int x, y;
+					screen_cursor_get(&y, &x);
+					sprintf(buf, "\033[%d;%dR", y + 1, x + 1);
+					apars_respond(buf);
+				}
+				else if (n1 == 5) {
+					// Query device status - reply "Device is OK"
+					apars_respond("\033[0n");
+				}
+				else {
+					warn_bad_csi();
+				}
+			}
+			else {
+				warn_bad_csi();
+			}
+			break;
+
+		case 'c': // CSI-c - report capabilities
+			if (leadchar == NUL) {
+				apars_respond("\033[?64;9c"); // pretend we're vt400 with national character sets
+			}
+			else if (leadchar == '>') {
+				// 41 - we're "VT400", 0 - ROM cartridge number
+				sprintf(buf, "\033[>41;%d;0c", FIRMWARE_VERSION_NUM);
+				apars_respond(buf);
+			}
+			else {
+				warn_bad_csi();
+			}
+			break;
+
+		case 'x': // DECREQTPARM -> DECREPTPARM
+			do_csi_decreqtparm(&opts);
+			break;
+
+		default:
+			warn_bad_csi();
+	}
+}
+
+/**
+ * CSI [?] Pm {h|l}
+ * @param opts
+ */
+static void ICACHE_FLASH_ATTR do_csi_privattr(CSI_Data *opts)
+{
+	bool yn = (opts->key == 'h');
+
+	if (opts->lead == '?') {
+		// --- DEC private attributes ---
+		for (int i = 0; i < opts->count; i++) {
+			int n = opts->n[i];
+			if (n == 1) {
+				screen_set_cursors_alt_mode(yn);
+			}
+			else if (n == 2) {
+				// should reset all Gx to USASCII and reset to VT100 (which we use always)
+				screen_set_charset(0, 'B');
+				screen_set_charset(1, 'B');
+			}
+			else if (n == 3) {
+				// 132 column mode - not implemented due to RAM demands
+				ansi_noimpl("80->132");
+			}
+			else if (n == 4) {
+				// Smooth scroll - not implemented
+			}
+			else if (n == 5) {
+				screen_set_reverse_video(yn);
+			}
+			else if (n == 6) {
+				screen_set_origin_mode(yn);
+			}
+			else if (n == 7) {
+				screen_wrap_enable(yn);
+			}
+			else if (n == 8) {
+				// Key auto-repeat
+				// We don't implement this currently, but it could be added
+				// - discard repeated keypress events between keydown and keyup.
+				ansi_noimpl("Auto-repeat toggle");
+			}
+			else if (n == 9 || (n >= 1000 && n <= 1006)) {
+				// TODO mouse
+				// 1000 - C11 mouse - Send Mouse X & Y on button press and release.
+				// 1001 - Hilite mouse tracking
+				// 1002 - Cell Motion Mouse Tracking
+				// 1003 - All Motion Mouse Tracking
+				// 1004 - Send FocusIn/FocusOut events
+				// 1005 - Enable UTF-8 Mouse Mode
+				// 1006 - SGR mouse mode
+				ansi_noimpl("Mouse tracking");
+			}
+			else if (n == 12) {
+				// TODO Cursor blink on/off
+				ansi_noimpl("Cursor blink toggle");
+			}
+			else if (n == 40) {
+				// allow/disallow 80->132 mode
+				// not implemented because of RAM demands
+				ansi_noimpl("80->132 enable");
+			}
+			else if (n == 45) {
+				// reverse wrap-around
+				ansi_noimpl("Reverse Wraparound");
+			}
+			else if (n == 69) {
+				// horizontal margins
+				ansi_noimpl("Left/right margin");
+			}
+			else if (n == 47 || n == 1047) {
+				// Switch to/from alternate screen
+				//  - not implemented fully due to RAM demands
+				screen_swap_state(yn);
+			}
+			else if (n == 1048) {
+				// same as DECSC - save/restore cursor with attributes
+				if (yn) {
+					screen_cursor_save(true);
+				}
+				else {
+					screen_cursor_restore(true);
+				}
+			}
+			else if (n == 1049) {
+				// save/restore cursor and screen and clear it
+				if (yn) {
+					screen_cursor_save(true);
+					screen_swap_state(true); // this should save the screen - can't because of RAM size
+					screen_clear(CLEAR_ALL);
+				}
+				else {
+					screen_clear(CLEAR_ALL);
+					screen_swap_state(false); // this should restore the screen - can't because of RAM size
+					screen_cursor_restore(true);
+				}
+			}
+			else if (n >= 1050 && n <= 1053) {
+				// TODO Different kinds of function key emulation ?
+				// (In practice this seems hardly ever used)
+
+				// Ps = 1 0 5 0  -> Set terminfo/termcap function-key mode.
+				// Ps = 1 0 5 1  -> Set Sun function-key mode.
+				// Ps = 1 0 5 2  -> Set HP function-key mode.
+				// Ps = 1 0 5 3  -> Set SCO function-key mode.
+				ansi_noimpl("FN key emul type");
+			}
+			else if (n == 2004) {
+				// Bracketed paste mode
+				// Discard, we don't implement this
+			}
+			else if (n == 25) {
+				screen_set_cursor_visible(yn);
+			}
+			else {
+				ansi_noimpl("CSI ? %d %c", n, opts->key);
+			}
+		}
+	}
+	else {
+		// --- DEC standard attributes ---
+		for (int i = 0; i < opts->count; i++) {
+			int n = opts->n[i];
+
+			if (n == 4) {
+				screen_set_insert_mode(yn);
+			}
+			else if (n == 20) {
+				screen_set_newline_mode(yn);
+			}
+			else {
+				ansi_noimpl("CSI %d %c", n, opts->key);
+			}
+		}
+	}
+}
+
+/**
+ * CSI [ Pm m
+ * @param opts
+ */
+static void ICACHE_FLASH_ATTR do_csi_sgr(CSI_Data *opts)
+{
+	int count = opts->count;
+
+	if (count == 0) {
+		count = 1; // this makes it work as 0 (reset)
+	}
+
+	if (opts->lead != NUL) {
+		// some xterm garbage - discard
+		// CSI > Ps; Ps m
+		return;
+	}
+
+	// iterate arguments
+	for (int i = 0; i < count; i++) {
+		int n = opts->n[i];
+
+		if (n == SGR_RESET) screen_reset_sgr();
+			// -- set color --
+		else if (n >= SGR_FG_START && n <= SGR_FG_END) screen_set_fg((Color) (n - SGR_FG_START)); // ANSI normal fg
+		else if (n >= SGR_BG_START && n <= SGR_BG_END) screen_set_bg((Color) (n - SGR_BG_START)); // ANSI normal bg
+		else if (n == SGR_FG_DEFAULT) screen_set_fg(termconf_scratch.default_fg); // default fg
+		else if (n == SGR_BG_DEFAULT) screen_set_bg(termconf_scratch.default_bg); // default bg
+			// -- set attr --
+		else if (n == SGR_BOLD) screen_set_sgr(ATTR_BOLD, 1);
+		else if (n == SGR_FAINT) screen_set_sgr(ATTR_FAINT, 1);
+		else if (n == SGR_ITALIC) screen_set_sgr(ATTR_ITALIC, 1);
+		else if (n == SGR_UNDERLINE) screen_set_sgr(ATTR_UNDERLINE, 1);
+		else if (n == SGR_BLINK || n == SGR_BLINK_FAST) screen_set_sgr(ATTR_BLINK, 1); // 6 - rapid blink, not supported
+		else if (n == SGR_STRIKE) screen_set_sgr(ATTR_STRIKE, 1);
+		else if (n == SGR_FRAKTUR) screen_set_sgr(ATTR_FRAKTUR, 1);
+		else if (n == SGR_INVERSE) screen_set_sgr_inverse(1);
+			// -- clear attr --
+		else if (n == SGR_OFF(SGR_BOLD)) screen_set_sgr(ATTR_BOLD, 0); // can also mean "Double Underline"
+		else if (n == SGR_OFF(SGR_FAINT)) screen_set_sgr(ATTR_FAINT | ATTR_BOLD, 0); // "normal"
+		else if (n == SGR_OFF(SGR_ITALIC)) screen_set_sgr(ATTR_ITALIC | ATTR_FRAKTUR, 0); // there is no dedicated OFF code for Fraktur
+		else if (n == SGR_OFF(SGR_UNDERLINE)) screen_set_sgr(ATTR_UNDERLINE, 0);
+		else if (n == SGR_OFF(SGR_BLINK)) screen_set_sgr(ATTR_BLINK, 0);
+		else if (n == SGR_OFF(SGR_STRIKE)) screen_set_sgr(ATTR_STRIKE, 0);
+		else if (n == SGR_OFF(SGR_INVERSE)) screen_set_sgr_inverse(0);
+			// -- AIX bright colors --
+		else if (n >= SGR_FG_BRT_START && n <= SGR_FG_BRT_END) screen_set_fg((Color) ((n - SGR_FG_BRT_START) + 8)); // AIX bright fg
+		else if (n >= SGR_BG_BRT_START && n <= SGR_BG_BRT_END) screen_set_bg((Color) ((n - SGR_BG_BRT_START) + 8)); // AIX bright bg
+		else {
+			ansi_noimpl("SGR %d", n);
+		}
+	}
+}
+
+
+// data tables for the DECREPTPARM command response
+
+struct DECREPTPARM_parity { int parity; const char * msg; };
+static const struct DECREPTPARM_parity DECREPTPARM_parity_arr[] = {
+	{PARITY_NONE, "1"},
+	{PARITY_ODD, "4"},
+	{PARITY_EVEN, "5"},
+	{-1, 0}
+};
+
+struct DECREPTPARM_baud { int baud; const char * msg; };
+static const struct DECREPTPARM_baud DECREPTPARM_baud_arr[] = {
+	{BIT_RATE_300, "48"},
+	{BIT_RATE_600, "56"},
+	{BIT_RATE_1200, "64"},
+	{BIT_RATE_2400, "88"},
+	{BIT_RATE_4800, "96"},
+	{BIT_RATE_9600  , "104"},
+	{BIT_RATE_19200 , "112"},
+	{BIT_RATE_38400 , "120"},
+	{BIT_RATE_57600 , "128"}, // this is the last in the spec, follow +8
+	{BIT_RATE_74880 , "136"},
+	{BIT_RATE_115200, "144"},
+	{BIT_RATE_230400, "152"},
+	{BIT_RATE_460800, "160"},
+	{BIT_RATE_921600, "168"},
+	{BIT_RATE_1843200, "176"},
+	{BIT_RATE_3686400, "184"},
+	{-1, 0}
+};
+
+/**
+ * CSI [ Ps x
+ * @param opts
+ */
+static void ICACHE_FLASH_ATTR do_csi_decreqtparm(CSI_Data *opts)
+{
+	const int n1 = opts->n[0];
+
+	// reference http://vt100.net/docs/vt100-ug/chapter3.html - search DECREPTPARM
+	if (n1 <= 1) {
+		apars_respond("\033["); // this is a response on request (2 would be gratuitous)
+
+		apars_respond(n1 == 0 ? "2;" : "3;");
+
+		// Parity
+		for(const struct DECREPTPARM_parity *p = DECREPTPARM_parity_arr; p->parity != -1; p++) {
+			if (p->parity == sysconf->uart_parity) {
+				apars_respond(p->msg);
+				break;
+			}
+		}
+
+		// bits per character (uart byte) - 1 = 8, 2 = 7
+		apars_respond(";1;");
+
+		// Baud rate
+		for(const struct DECREPTPARM_baud *p = DECREPTPARM_baud_arr; p->baud != -1; p++) {
+			if (p->baud == sysconf->uart_baudrate) {
+				apars_respond(p->msg);
+				apars_respond(";");
+				apars_respond(p->msg);
+				break;
+			}
+		}
+
+		// multiplier 1, flags 0
+		apars_respond(";1;0x"); // ROM cartridge number ??
+	}
+}

user/apars_csi.h

@@ -0,0 +1,10 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+
+#ifndef ESP_VT100_FIRMWARE_APARS_CSI_H
+#define ESP_VT100_FIRMWARE_APARS_CSI_H
+
+void apars_handle_csi(char leadchar, const int *params, int count, char keychar);
+
+#endif //ESP_VT100_FIRMWARE_APARS_CSI_H

user/apars_dcs.c

@@ -0,0 +1,89 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+// Handle DCS sequences (Device Control String)
+// DCS Pt ST
+// (DCS = ESC P)
+//
+// Those are used for terminal status queries.
+//
+// Pt =
+// $ q " p .... read conformance level
+// $ q " q .... read character protection attribute
+// $ q r ...... read scrolling region extents
+// $ q s ...... read horizontal margins extents
+// $ q m ...... read SGR in a format that would restore them exactly when run as a CSI Pm m
+// $ q SP q ... read cursor style
+//
+// For details, see
+// http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Device-Control-functions
+//
+
+#include <esp8266.h>
+#include "apars_dcs.h"
+#include "ansi_parser_callbacks.h"
+#include "screen.h"
+#include "apars_logging.h"
+
+/**
+ * Helper function to parse incoming DCS (Device Control String)
+ * @param buffer - the DCS body (after DCS and before ST)
+ */
+void ICACHE_FLASH_ATTR
+apars_handle_dcs(const char *buffer)
+{
+	char buf[64]; // just about big enough for full-house SGR
+	size_t len = strlen(buffer);
+	if ((len == 3 || len == 4) && strneq(buffer, "$q", 2)) {
+		// DECRQSS - Request Status String
+		if (strneq(buffer+2, "\"p", 2)) {
+			// DECSCL - Select Conformance Level
+			apars_respond("\033P1$r64;1\"p\033\\"); // 64;1 - Pretend we are VT400 with 7-bit characters
+		}
+		else if (strneq(buffer+2, "\"q", 2)) {
+			// DECSCA - Select character protection attribute
+			sprintf(buf, "\033P1$r%d\"q\033\\", 0); // 0 - Can erase - TODO real protection status if implemented
+			apars_respond(buf);
+		}
+		else if (buffer[2] == 'r') {
+			// DECSTBM - Query scrolling region
+			sprintf(buf, "\033P1$r%d;%dr\033\\", 1, termconf_scratch.height); // 1-80 TODO real extent of scrolling region
+			apars_respond(buf);
+		}
+		else if (buffer[2] == 's') {
+			// DECSLRM - Query horizontal margins
+			sprintf(buf, "\033P1$r%d;%ds\033\\", 1, termconf_scratch.width); // Can erase - TODO real extent of horiz margins if implemented
+			apars_respond(buf);
+		}
+		else if (buffer[2] == 'm') {
+			// SGR - query SGR
+			apars_respond("\033P1$r");
+			screen_report_sgr(buf);
+			apars_respond(buf);
+			apars_respond("m\033\\");
+		}
+		else if (strneq(buffer+2, " q", 2)) {
+			// DECSCUSR - Query cursor style
+			sprintf(buf, "\033P1$r%d q\033\\", 1);
+			/*
+				Ps = 0  -> blinking block.
+				Ps = 1  -> blinking block (default).
+				Ps = 2  -> steady block.
+				Ps = 3  -> blinking underline.
+				Ps = 4  -> steady underline.
+				Ps = 5  -> blinking bar (xterm).
+				Ps = 6  -> steady bar (xterm).
+			 */
+			apars_respond(buf);
+		}
+		else {
+			// invalid query
+			ansi_noimpl("DCS %s ST", buffer);
+			sprintf(buf, "\033P0$r%s\033\\", buffer+2);
+		}
+	}
+	else {
+		ansi_warn("Bad DCS: %s", buffer);
+		apars_show_context();
+	}
+}

user/apars_dcs.h

@@ -0,0 +1,10 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+
+#ifndef ESP_VT100_FIRMWARE_APARS_DCS_H
+#define ESP_VT100_FIRMWARE_APARS_DCS_H
+
+void apars_handle_dcs(const char *buffer);
+
+#endif //ESP_VT100_FIRMWARE_APARS_DCS_H

user/apars_logging.h

@@ -0,0 +1,37 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+// Logging functions for the parser, can be switched off with a compile flag
+//
+
+#ifndef ESP_VT100_FIRMWARE_APARS_LOGGING_H
+#define ESP_VT100_FIRMWARE_APARS_LOGGING_H
+
+#include <esp8266.h>
+
+#ifndef DEBUG_ANSI
+#define DEBUG_ANSI 0
+#endif
+
+#ifndef DEBUG_ANSI_NOIMPL
+#define DEBUG_ANSI_NOIMPL 0
+#endif
+
+// defined in the makefile
+#if DEBUG_ANSI
+#define ansi_warn warn
+#define ansi_dbg dbg
+#else
+#define ansi_warn(fmt, ...)
+#define ansi_dbg(fmt, ...)
+#endif
+
+#if DEBUG_ANSI_NOIMPL
+#define ansi_noimpl(fmt, ...) warn("NOIMPL: " fmt, ##__VA_ARGS__)
+#define ansi_noimpl_r(fmt, ...) warn(fmt, ##__VA_ARGS__)
+#else
+#define ansi_noimpl(fmt, ...)
+#define ansi_noimpl_r(fmt, ...)
+#endif
+
+#endif //ESP_VT100_FIRMWARE_APARS_LOGGING_H

user/apars_osc.c

@@ -0,0 +1,65 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+// Handle OSC commands (Operating System Command)
+// ESC ] Ps ; Pt ST
+//
+// Those are used to pass various text variables to the terminal:
+//
+// Ps = 0 or 2 ... set screen title to Pt
+// Ps = 81-85  ... set button label to Pt
+//
+
+#include "apars_osc.h"
+#include "apars_logging.h"
+#include "screen.h"
+#include "ansi_parser.h"
+
+/**
+ * Helper function to set terminal button label
+ * @param num - button number 1-5
+ * @param str - button text
+ */
+static void ICACHE_FLASH_ATTR
+set_button_text(int num, const char *str)
+{
+	strncpy(termconf_scratch.btn[num-1], str, TERM_BTN_LEN);
+	screen_notifyChange(CHANGE_LABELS);
+}
+
+/**
+ * Helper function to parse incoming OSC (Operating System Control)
+ * @param buffer - the OSC body (after OSC and before ST)
+ */
+void ICACHE_FLASH_ATTR
+apars_handle_osc(const char *buffer)
+{
+	const char *orig_buff = buffer;
+	int n = 0;
+	char c = 0;
+	while ((c = *buffer++) != 0) {
+		if (c >= '0' && c <= '9') {
+			n = (n * 10 + (c - '0'));
+		} else {
+			break;
+		}
+	}
+
+	if (c == ';') {
+		// Do something with the data string and number
+		// (based on xterm manpage)
+		if (n == 0 || n == 2) {
+			screen_set_title(buffer);
+		}
+		else if (n >= 81 && n <= 85) { // numbers chosen to not collide with any xterm supported codes
+			set_button_text(n - 80, buffer);
+		}
+		else {
+			ansi_noimpl("OSC %d ; %s ST", n, buffer);
+		}
+	}
+	else {
+		ansi_warn("BAD OSC: %s", orig_buff);
+		apars_show_context();
+	}
+}

user/apars_osc.h

@@ -0,0 +1,10 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+
+#ifndef ESP_VT100_FIRMWARE_APARS_OSC_H
+#define ESP_VT100_FIRMWARE_APARS_OSC_H
+
+void apars_handle_osc(const char *buffer);
+
+#endif //ESP_VT100_FIRMWARE_APARS_OSC_H

user/apars_short.c

@@ -0,0 +1,179 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+// Short sequences: (* = not implemented)
+//
+// ESC char
+//   ESC 6     Back Index (DECBI), VT420 and up.
+//   ESC 7     Save Cursor (DECSC).
+//   ESC 8     Restore Cursor (DECRC).
+//   ESC 9     Forward Index (DECFI), VT420 and up.
+//   ESC =     Application Keypad (DECKPAM).
+//   ESC >     Normal Keypad (DECKPNM).
+//   ESC F     Cursor to lower left corner of screen.
+//   ESC c     Full Reset (RIS).
+//  *ESC l     Memory Lock (per HP terminals). Locks memory above the cursor.
+//  *ESC m     Memory Unlock (per HP terminals).
+//   ESC n     Invoke the G2 Character Set as GL (LS2).
+//   ESC o     Invoke the G3 Character Set as GL (LS3).
+//  *ESC |     Invoke the G3 Character Set as GR (LS3R).
+//  *ESC }     Invoke the G2 Character Set as GR (LS2R).
+//  *ESC ~     Invoke the G1 Character Set as GR (LS1R).
+//
+// ESC # Ps
+//  *ESC # 3   DEC double-height line, top half (DECDHL).
+//  *ESC # 4   DEC double-height line, bottom half (DECDHL).
+//  *ESC # 5   DEC single-width line (DECSWL).
+//  *ESC # 6   DEC double-width line (DECDWL).
+//   ESC # 8   DEC Screen Alignment Test (DECALN).
+//
+// ESC SP char
+//  *ESC SP F  7-bit controls (S7C1T).
+//  *ESC SP G  8-bit controls (S8C1T).
+//  *ESC SP L  Set ANSI conformance level 1 (dpANS X3.134.1).
+//  *ESC SP M  Set ANSI conformance level 2 (dpANS X3.134.1).
+//  *ESC SP N  Set ANSI conformance level 3 (dpANS X3.134.1).
+//
+// Charset commands
+//   ESC ( char  Designate G0 character set ('0' = symbols, 'B' = ASCII-US, 'A' = ASCII-UK)
+//   ESC ) char  Designate G1 character set
+//   SO          Switch to G0 character set
+//   SI          Switch to G1 character set
+//
+
+#include <esp8266.h>
+#include "apars_short.h"
+#include "apars_logging.h"
+#include "screen.h"
+
+// ----- Character Set ---
+
+/**
+ * Command to assign G0 or G1
+ * @param slot - ( or ) for G0 or G1
+ * @param c - character table ID (0, B etc)
+ */
+void ICACHE_FLASH_ATTR
+apars_handle_chs_designate(char slot, char c)
+{
+	if (slot == '(') screen_set_charset(0, c); // G0
+	else if (slot == ')') screen_set_charset(1, c); // G1
+	else {
+		ansi_noimpl("ESC %c %c", slot, c);
+	}
+	// other alternatives * + . - / not implemented
+}
+
+/** Select charset slot */
+void ICACHE_FLASH_ATTR
+apars_handle_chs_switch(int Gx)
+{
+	screen_set_charset_n(Gx);
+}
+
+// ----- ESC SP char -----
+
+/**
+ * ESC SP <c> (this sets 8/7-bit mode and some other archaic options)
+ * @param c - key character
+ */
+void ICACHE_FLASH_ATTR
+apars_handle_space_cmd(char c)
+{
+	ansi_noimpl("ESC SP %c", c);
+}
+
+// ----- ESC # num -----
+
+/**
+ * Codes in the format ESC # n
+ * @param c - the trailing symbol (numeric ASCII)
+ */
+void ICACHE_FLASH_ATTR apars_handle_hash_cmd(char c)
+{
+	switch(c) {
+		case '3': // Double size, top half
+		case '4': // Single size, bottom half
+		case '5': // Single width, single height
+		case '6': // Double width
+			ansi_noimpl("Double Size Line");
+			break;
+
+		case '8':
+			screen_fill_with_E();
+			break;
+
+		default:
+			ansi_noimpl("ESC # %c", c);
+	}
+}
+
+// ----- ESC char -----
+
+/**
+ * Single-character escape codes (ESC x)
+ * @param c - the trailing symbol (ASCII)
+ */
+void ICACHE_FLASH_ATTR apars_handle_short_cmd(char c)
+{
+	switch(c) {
+		case 'c': // screen reset
+			screen_reset();
+			break;
+
+		case '7': // save cursor + attributes
+			screen_cursor_save(true);
+			break;
+
+		case '8': // restore cursor + attributes
+			screen_cursor_restore(true);
+			break;
+
+		case 'E': // same as CR LF
+			screen_cursor_move(1, 0, false);
+			screen_cursor_set_x(0);
+			break;
+
+		case 'F': // bottom left
+			screen_cursor_set(termconf_scratch.height-1, 0);
+			break;
+
+		case 'D': // move cursor down, scroll screen up if needed
+			screen_cursor_move(1, 0, true);
+			break;
+
+		case 'M': // move cursor up, scroll screen down if needed
+			screen_cursor_move(-1, 0, true);
+			break;
+
+		case 'H':
+			screen_set_tab();
+			break;
+
+		case '>':
+			screen_set_numpad_alt_mode(false);
+			break;
+
+		case '<': // "Enter ANSI / VT100 mode" - no-op (we don't support VT52 mode)
+			break;
+
+		case '=':
+			screen_set_numpad_alt_mode(true);
+			break;
+
+		case '|': // Invoke the G3 Character Set as GR (LS3R).
+		case '}': // Invoke the G2 Character Set as GR (LS2R).
+		case '~': // Invoke the G1 Character Set as GR (LS1R).
+			// Those do not seem to do anything TODO investigate
+			break;
+
+		case '@': // no-op padding char (?)
+			break;
+
+		case '\\': // spurious string terminator
+			break;
+
+		default:
+			ansi_noimpl("ESC %c", c);
+	}
+}

user/apars_short.h

@@ -0,0 +1,14 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+
+#ifndef ESP_VT100_FIRMWARE_APARS_SIMPLE_H
+#define ESP_VT100_FIRMWARE_APARS_SIMPLE_H
+
+void apars_handle_short_cmd(char c);
+void apars_handle_hash_cmd(char c);
+void apars_handle_space_cmd(char c);
+void apars_handle_chs_designate(char slot, char c);
+void apars_handle_chs_switch(int Gx);
+
+#endif //ESP_VT100_FIRMWARE_APARS_SIMPLE_H

user/apars_string.c

@@ -0,0 +1,52 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+// String based commands.
+// Those command start with a introducer sequence, followed by arbitrary string,
+// and end with a String Terminator (`ESC \`, or `BEL`)
+//
+// ESC k Pt ST ... set screen title (same as `OSC 0 ; Pt ST`, is shorter)
+// ESC ] Pt ST ... OSC - Operating System Command (split to its own file)
+// ESC P Pt ST ... DCS - Device Control String (split to its own file)
+// ESC ^ Pt ST ... PM - Privacy message (unused)
+// ESC _ Pt ST ... APC - Application Program Command (unused)
+// ESC X Pt ST ... SOS - Start Of String (unused; sent back in response to ENQ)
+
+#include <esp8266.h>
+#include "apars_string.h"
+#include "apars_logging.h"
+#include "ansi_parser_callbacks.h"
+#include "screen.h"
+
+// ----- Generic String cmd - disambiguation -----
+
+void ICACHE_FLASH_ATTR
+apars_handle_string_cmd(char leadchar, const char *buffer)
+{
+	switch (leadchar) {
+		case 'k': // ESC k TITLE ST (defined in GNU screen manpage)
+			screen_set_title(buffer);
+			break;
+
+		case ']': // OSC - Operating System Command
+			apars_handle_osc(buffer);
+			break;
+
+		case 'P': // DCS - Device Control String
+			apars_handle_dcs(buffer);
+			break;
+
+		case '^': // PM - Privacy Message
+			break;
+
+		case '_': // APC - Application Program Command
+			break;
+
+		case 'X': // SOS - Start of String (purpose unclear)
+			break;
+
+		default:
+			ansi_warn("Bad str cmd");
+			apars_show_context();
+	}
+}

user/apars_string.h

@@ -0,0 +1,10 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+
+#ifndef ESP_VT100_FIRMWARE_APARS_STRING_H
+#define ESP_VT100_FIRMWARE_APARS_STRING_H
+
+void apars_handle_string_cmd(char leadchar, const char *buffer);
+
+#endif //ESP_VT100_FIRMWARE_APARS_STRING_H

user/apars_utf8.c

@@ -0,0 +1,84 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+// UTF-8 parser - collects bytes of a code point before writing them
+// into a screen cell.
+//
+
+#include "apars_utf8.h"
+#include "apars_logging.h"
+#include "screen.h"
+
+static char utf_collect[4];
+static int utf_i = 0;
+static int utf_j = 0;
+
+/**
+ * Clear the buffer where we collect pieces of a code point.
+ * This is used for parser reset.
+ */
+void ICACHE_FLASH_ATTR
+apars_reset_utf8buffer(void)
+{
+	utf_i = 0;
+	utf_j = 0;
+	memset(utf_collect, 0, 4);
+}
+
+/**
+ * Handle a received plain character
+ * @param c - received character
+ */
+void ICACHE_FLASH_ATTR
+apars_handle_plainchar(char c)
+{
+	// collecting unicode glyphs...
+	if (c & 0x80) {
+		if (utf_i == 0) {
+			// start
+			if (c == 192 || c == 193 || c >= 245) {
+				// forbidden codes
+				goto fail;
+			}
+
+			if ((c & 0xE0) == 0xC0) {
+				utf_i = 2;
+			}
+			else if ((c & 0xF0) == 0xE0) {
+				utf_i = 3;
+			}
+			else if ((c & 0xF8) == 0xF0) {
+				utf_i = 4;
+			}
+			else {
+				// chars over 127 that don't start unicode sequences
+				goto fail;
+			}
+
+			utf_collect[0] = c;
+			utf_j = 1;
+		}
+		else {
+			if ((c & 0xC0) != 0x80) {
+				goto fail;
+			}
+			else {
+				utf_collect[utf_j++] = c;
+				if (utf_j >= utf_i) {
+					screen_putchar(utf_collect);
+					apars_reset_utf8buffer();
+				}
+			}
+		}
+	}
+	else {
+		utf_collect[0] = c;
+		utf_collect[1] = 0; // just to make sure it's closed...
+		screen_putchar(utf_collect);
+	}
+
+	return;
+	fail:
+	ansi_warn("Bad UTF-8: %0Xh", c);
+	apars_reset_utf8buffer();
+}

user/apars_utf8.h

@@ -0,0 +1,11 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+
+#ifndef ESP_VT100_FIRMWARE_APARS_UTF8_H
+#define ESP_VT100_FIRMWARE_APARS_UTF8_H
+
+void apars_handle_plainchar(char c);
+void apars_reset_utf8buffer(void);
+
+#endif //ESP_VT100_FIRMWARE_APARS_UTF8_H

user/ascii.h

@@ -0,0 +1,49 @@
+//
+// Created by MightyPork on 2017/08/19.
+//
+
+#ifndef ESP_VT100_FIRMWARE_ASCII_H
+#define ESP_VT100_FIRMWARE_ASCII_H
+
+enum ASCII_CODES {
+	NUL = 0,
+	SOH = 1,
+	STX = 2,
+	ETX = 3,
+	EOT = 4,
+	ENQ = 5,
+	ACK = 6,
+	BEL = 7, /* \a */
+	BS = 8,  /* \b */
+	TAB = 9, /* \t */
+	LF = 10, /* \n */
+	VT = 11, /* \v */
+	FF = 12, /* \f */
+	CR = 13, /* \r */
+	SO = 14,
+	SI = 15,
+	DLE = 16,
+	DC1 = 17,
+	DC2 = 18,
+	DC3 = 19,
+	DC4 = 20,
+	NAK = 21,
+	SYN = 22,
+	ETB = 23,
+	CAN = 24,
+	EM = 25,
+	SUB = 26,
+	ESC = 27, /* \033, \x1b, \e */
+	FS = 28,
+	GS = 29,
+	RS = 30,
+	US = 31,
+	SP = 32,
+	DEL = 127,
+
+	// aliases
+	XON = DC1,
+	XOFF = DC3,
+};
+
+#endif //ESP_VT100_FIRMWARE_ASCII_H

user/cgi_main.c

@@ -5,7 +5,7 @@
 
 #include "cgi_main.h"
 #include "screen.h"
-#include "user_main.h"
+#include "version.h"
 #include "helpers.h"
 
 /**

user/cgi_sockets.c

@@ -5,28 +5,43 @@
 #include "cgi_sockets.h"
 #include "uart_driver.h"
 #include "screen.h"
+#include "uart_buffer.h"
+#include "ansi_parser.h"
 
 #define SOCK_BUF_LEN 1024
 static char sock_buff[SOCK_BUF_LEN];
 
 volatile bool notify_available = true;
+volatile bool notify_cooldown = false;
 
-static ETSTimer notifyTim;
+static ETSTimer notifyContentTim;
-static ETSTimer notifyTim2;
+static ETSTimer notifyLabelsTim;
+static ETSTimer notifyCooldownTim;
 
 // we're trying to do a kind of mutex here, without the actual primitives
 // this might glitch, very rarely.
 // it's recommended to put some delay between setting labels and updating the screen.
 
+/**
+ * Cooldown delay is over
+ * @param arg
+ */
 static void ICACHE_FLASH_ATTR
-notifyTimCb(void *arg) {
+notifyCooldownTimCb(void *arg)
-	void *data = NULL;
+{
+	notify_cooldown = false;
+}
 
-	if (!notify_available) {
+static void ICACHE_FLASH_ATTR
+notifyContentTimCb(void *arg)
+{
+	void *data = NULL;
+	int max_bl, total_bl;
+	cgiWebsockMeasureBacklog(URL_WS_UPDATE, &max_bl, &total_bl);
+
+	if (!notify_available || notify_cooldown || (max_bl > 2048)) { // do not send if we have anything significant backlogged
 		// postpone a little
-		os_timer_disarm(&notifyTim);
+		TIMER_START(&notifyContentTim, notifyContentTimCb, 5, 0);
-		os_timer_setfn(&notifyTim, notifyTimCb, NULL);
-		os_timer_arm(&notifyTim, 1, 0);
 		return;
 	}
 	notify_available = false;
@@ -43,17 +58,18 @@ notifyTimCb(void *arg) {
 	// cleanup
 	screenSerializeToBuffer(NULL, SOCK_BUF_LEN, &data);
 
+	notify_cooldown = true;
 	notify_available = true;
+
+	TIMER_START(&notifyCooldownTim, notifyCooldownTimCb, termconf->display_cooldown_ms, 0);
 }
 
 static void ICACHE_FLASH_ATTR
 notifyLabelsTimCb(void *arg)
 {
-	if (!notify_available) {
+	if (!notify_available || notify_cooldown) {
 		// postpone a little
-		os_timer_disarm(&notifyTim2);
+		TIMER_START(&notifyLabelsTim, notifyLabelsTimCb, 1, 0);
-		os_timer_setfn(&notifyTim2, notifyLabelsTimCb, NULL);
-		os_timer_arm(&notifyTim2, 1, 0);
 		return;
 	}
 	notify_available = false;
@@ -61,7 +77,18 @@ notifyLabelsTimCb(void *arg)
 	screenSerializeLabelsToBuffer(sock_buff, SOCK_BUF_LEN);
 	cgiWebsockBroadcast(URL_WS_UPDATE, sock_buff, (int) strlen(sock_buff), 0);
 
+	notify_cooldown = true;
 	notify_available = true;
+
+	TIMER_START(&notifyCooldownTim, notifyCooldownTimCb, termconf->display_cooldown_ms, 0);
+}
+
+/** Beep */
+void ICACHE_FLASH_ATTR
+send_beep(void)
+{
+	// here's some potential for a race error with the other broadcast functions :C
+	cgiWebsockBroadcast(URL_WS_UPDATE, "B", 1, 0);
 }
 
 
@@ -74,18 +101,17 @@ void ICACHE_FLASH_ATTR screen_notifyChange(ScreenNotifyChangeTopic topic)
 {
 	// this is not the most ideal/cleanest implementation
 	// PRs are welcome for a nicer update "queue" solution
+	if (termconf->display_tout_ms == 0) termconf->display_tout_ms = SCR_DEF_DISPLAY_TOUT_MS;
+
+	// NOTE: the timers are restarted if already running
 
 	if (topic == CHANGE_LABELS) {
 		// separate timer from content change timer, to avoid losing that update
-		os_timer_disarm(&notifyTim2);
+		TIMER_START(&notifyLabelsTim, notifyLabelsTimCb, termconf->display_tout_ms, 0);
-		os_timer_setfn(&notifyTim2, notifyLabelsTimCb, NULL);
-		os_timer_arm(&notifyTim2, SCREEN_NOTIFY_DELAY_MS, 0);
 	}
 	else if (topic == CHANGE_CONTENT) {
 		// throttle delay
-		os_timer_disarm(&notifyTim);
+		TIMER_START(&notifyContentTim, notifyContentTimCb, termconf->display_tout_ms, 0);
-		os_timer_setfn(&notifyTim, notifyTimCb, NULL);
-		os_timer_arm(&notifyTim, SCREEN_NOTIFY_DELAY_MS, 0);
 	}
 }
 
@@ -98,17 +124,21 @@ void ICACHE_FLASH_ATTR updateSockRx(Websock *ws, char *data, int len, int flags)
 
 	// TODO re-implement those, use single byte markers and B2 encoding
 
-	dbg("Sock RX str: %s, len %d", data, len);
+	ws_dbg("Sock RX str: %s, len %d", data, len);
 
 	if (strstarts(data, "STR:")) {
 		// pass string verbatim
-		UART_WriteString(UART0, data+4, UART_TIMEOUT_US);
+		UART_SendAsync(data+4, -1);
+		// debug loopback
+//		for(int i=4;i<strlen(data); i++) {
+//			ansi_parser(data[i]);
+//		}
 	}
 	else if (strstarts(data, "BTN:")) {
 		// send button as low ASCII value 1-9
-		int btnNum = data[4] - '0';
+		u8 btnNum = (u8) (data[4] - '0');
 		if (btnNum > 0 && btnNum < 10) {
-			UART_WriteChar(UART0, (unsigned char)btnNum, UART_TIMEOUT_US);
+			UART_SendAsync((const char *) &btnNum, 1);
 		}
 	}
 	else if (strstarts(data, "TAP:")) {
@@ -134,24 +164,24 @@ void ICACHE_FLASH_ATTR updateSockRx(Websock *ws, char *data, int len, int flags)
 		}
 
 		if (!screen_isCoordValid(y, x)) {
-			warn("Mouse input at invalid coordinates");
+			ws_warn("Mouse input at invalid coordinates");
 			return;
 		}
 
-		dbg("Screen clicked at row %d, col %d", y+1, x+1);
+		ws_dbg("Screen clicked at row %d, col %d", y+1, x+1);
 
 		// Send as 1-based to user
 		sprintf(buf, "\033[%d;%dM", y+1, x+1);
-		UART_WriteString(UART0, buf, UART_TIMEOUT_US);
+		UART_SendAsync(buf, -1);
 	}
 	else {
-		warn("Bad command.");
+		ws_warn("Bad command.");
 	}
 }
 
 /** Socket connected for updates */
 void ICACHE_FLASH_ATTR updateSockConnect(Websock *ws)
 {
-	info("Socket connected to "URL_WS_UPDATE);
+	ws_info("Socket connected to "URL_WS_UPDATE);
 	ws->recvCb = updateSockRx;
 }

user/cgi_sockets.h

@@ -3,10 +3,24 @@
 
 #define URL_WS_UPDATE "/term/update.ws"
 
+#include <cgiwebsocket.h>
 #include "screen.h"
 
 /** Update websocket connect callback */
 void updateSockConnect(Websock *ws);
 void screen_notifyChange(ScreenNotifyChangeTopic topic);
 
+void send_beep(void);
+
+// defined in the makefile
+#if DEBUG_INPUT
+#define ws_warn warn
+#define ws_dbg dbg
+#define ws_info info
+#else
+#define ws_warn(...)
+#define ws_dbg(...)
+#define ws_info(...)
+#endif
+
 #endif //CGI_SOCKETS_H

user/cgi_term_cfg.c

@@ -20,7 +20,7 @@ cgiTermCfgSetParams(HttpdConnData *connData)
 {
 	char buff[50];
 	char redir_url_buf[100];
-	int n, w, h;
+	int32 n, w, h;
 
 	bool shall_clear_screen = false;
 
@@ -85,13 +85,41 @@ cgiTermCfgSetParams(HttpdConnData *connData)
 		dbg("Parser timeout: %s ms", buff);
 		n = atoi(buff);
 		if (n >= 0) {
-			termconf->parser_tout_ms = (u8) n;
+			termconf->parser_tout_ms = n;
 		} else {
-			warn("Bad timeout %s", buff);
+			warn("Bad parser timeout %s", buff);
 			redir_url += sprintf(redir_url, "parser_tout_ms,");
 		}
 	}
 
+	if (GET_ARG("display_tout_ms")) {
+		dbg("Display update idle timeout: %s ms", buff);
+		n = atoi(buff);
+		if (n > 0) {
+			termconf->display_tout_ms = n;
+		} else {
+			warn("Bad update timeout %s", buff);
+			redir_url += sprintf(redir_url, "display_tout_ms,");
+		}
+	}
+
+	if (GET_ARG("display_cooldown_ms")) {
+		dbg("Display update cooldown: %s ms", buff);
+		n = atoi(buff);
+		if (n > 0) {
+			termconf->display_cooldown_ms = n;
+		} else {
+			warn("Bad cooldown %s", buff);
+			redir_url += sprintf(redir_url, "display_cooldown_ms,");
+		}
+	}
+
+	if (GET_ARG("fn_alt_mode")) {
+		dbg("FN alt mode: %s", buff);
+		n = atoi(buff);
+		termconf->fn_alt_mode = (bool)n;
+	}
+
 	if (GET_ARG("default_fg")) {
 		dbg("Screen default FG: %s", buff);
 		n = atoi(buff);
@@ -175,6 +203,15 @@ tplTermCfg(HttpdConnData *connData, char *token, void **arg)
 	else if (streq(token, "parser_tout_ms")) {
 		sprintf(buff, "%d", termconf->parser_tout_ms);
 	}
+	else if (streq(token, "display_tout_ms")) {
+		sprintf(buff, "%d", termconf->display_tout_ms);
+	}
+	else if (streq(token, "display_cooldown_ms")) {
+		sprintf(buff, "%d", termconf->display_cooldown_ms);
+	}
+	else if (streq(token, "fn_alt_mode")) {
+		sprintf(buff, "%d", (int)termconf->fn_alt_mode);
+	}
 	else if (streq(token, "theme")) {
 		sprintf(buff, "%d", termconf->theme);
 	}

user/io.c

@@ -13,6 +13,8 @@
 #include "ansi_parser_callbacks.h"
 #include "wifimgr.h"
 #include "persist.h"
+#include "screen.h"
+#include "ansi_parser.h"
 
 #define BTNGPIO 0
 
@@ -21,6 +23,28 @@ static bool enable_ap_button = false;
 
 static ETSTimer resetBtntimer;
 static ETSTimer blinkyTimer;
+static ETSTimer ansiParserResetTimer;
+
+static void ICACHE_FLASH_ATTR ansiParserResetTimerCb(void *arg) {
+	static u32 last_charcnt = 0;
+	static int same_charcnt = -1;
+	if (termconf->parser_tout_ms == 0) return;
+
+	if (last_charcnt != ansi_parser_char_cnt) {
+		last_charcnt = ansi_parser_char_cnt;
+		same_charcnt = 0;
+	}
+	else {
+		if (same_charcnt != -1) {
+			same_charcnt++;
+			if (same_charcnt > termconf->parser_tout_ms) {
+				ansi_parser_reset();
+				same_charcnt = -1;
+			}
+		}
+	}
+}
+
 
 // Holding BOOT pin triggers AP reset, then Factory Reset.
 // Indicate that by blinking the on-board LED.
@@ -102,6 +126,10 @@ void ICACHE_FLASH_ATTR ioInit() {
 	os_timer_setfn(&resetBtntimer, resetBtnTimerCb, NULL);
 	os_timer_arm(&resetBtntimer, 500, 1);
 
+	os_timer_disarm(&ansiParserResetTimer);
+	os_timer_setfn(&ansiParserResetTimer, ansiParserResetTimerCb, NULL);
+	os_timer_arm(&ansiParserResetTimer, 1, 1);
+
 	// One way to enter AP mode - hold GPIO0 low.
 	if (GPIO_INPUT_GET(BTNGPIO) == 0) {
 		// starting "in BOOT mode" - do not install the AP reset timer

user/screen.h

@@ -34,29 +34,41 @@
  *
  */
 
-// Size designed for the wifi config structure
+// Size designed for the terminal config structure
 // Must be constant to avoid corrupting user config after upgrade
 #define TERMCONF_SIZE 200
 
 #define TERM_BTN_LEN 10
 #define TERM_TITLE_LEN 64
 
-typedef enum {
+#define SCR_DEF_DISPLAY_TOUT_MS 10
-	CHANGE_CONTENT,
+#define SCR_DEF_DISPLAY_COOLDOWN_MS 30
-	CHANGE_LABELS,
+#define SCR_DEF_PARSER_TOUT_MS 10
-} ScreenNotifyChangeTopic;
+#define SCR_DEF_FN_ALT_MODE false
+#define SCR_DEF_WIDTH 26
+#define SCR_DEF_HEIGHT 10
+#define SCR_DEF_TITLE "ESPTerm"
 
-#define SCREEN_NOTIFY_DELAY_MS 20
+/** Maximum screen size (determines size of the static data array) */
+#define MAX_SCREEN_SIZE (80*26)
+
+#define TERMCONF_VERSION 1
+
+// --- Persistent Settings ---
 
 typedef struct {
 	u32 width;
 	u32 height;
-	u8 default_bg;
+	u8 default_bg; // should be the Color typedef, but this way the size is more explicit
 	u8 default_fg;
 	char title[TERM_TITLE_LEN];
 	char btn[5][TERM_BTN_LEN];
 	u8 theme;
 	u32 parser_tout_ms;
+	u32 display_tout_ms;
+	bool fn_alt_mode; // xterm compatibility mode (alternate codes for some FN keys)
+	u8 config_version;
+	u32 display_cooldown_ms;
 } TerminalConfigBundle;
 
 // Live config
@@ -68,45 +80,49 @@ extern TerminalConfigBundle * const termconf;
  */
 extern TerminalConfigBundle termconf_scratch;
 
+/** Restore default settings to termconf. Does not apply or copy to scratch. */
 void terminal_restore_defaults(void);
+/** Apply settings, redraw (clears the screen) */
 void terminal_apply_settings(void);
-void terminal_apply_settings_noclear(void); // the same, but with no screen reset / init
+/** Apply settings, redraw (no clear - not resized) */
+void terminal_apply_settings_noclear(void);
+/** Init the screen */
+void screen_init(void);
+/** Change the screen size */
+void screen_resize(int rows, int cols);
+/** Set screen title */
+void screen_set_title(const char *title);
+/** Set a button text */
+void screen_set_button_text(int num, const char *text);
 
-/**
+// --- Encoding ---
- * Maximum screen size (determines size of the static data array)
- *
- * TODO May need adjusting if there are size problems when flashing the ESP.
- * We could also try to pack the Cell struct to a single 32bit word.
- */
-#define MAX_SCREEN_SIZE (80*30)
-
-typedef enum {
-	CLEAR_TO_CURSOR=0, CLEAR_FROM_CURSOR=1, CLEAR_ALL=2
-} ClearMode;
-
-typedef uint8_t Color;
-
-httpd_cgi_state screenSerializeToBuffer(char *buffer, size_t buf_len, void **data);
-
-void screenSerializeLabelsToBuffer(char *buffer, size_t buf_len);
 
 typedef struct {
 	u8 lsb;
 	u8 msb;
 } WordB2;
 
+typedef struct {
+	u8 lsb;
+	u8 msb;
+	u8 xsb;
+} WordB3;
+
 /** Encode number to two nice ASCII bytes */
 void encode2B(u16 number, WordB2 *stru);
 
-/** Init the screen */
+httpd_cgi_state screenSerializeToBuffer(char *buffer, size_t buf_len, void **data);
-void screen_init(void);
+
-/** Change the screen size */
+void screenSerializeLabelsToBuffer(char *buffer, size_t buf_len);
-void screen_resize(int rows, int cols);
-/** Check if coord is valid */
-bool screen_isCoordValid(int y, int x);
 
 // --- Clearing ---
 
+typedef enum {
+	CLEAR_TO_CURSOR = 0,
+	CLEAR_FROM_CURSOR = 1,
+	CLEAR_ALL = 2
+} ClearMode;
+
 /** Screen reset to default state */
 void screen_reset(void);
 /** Clear entire screen */
@@ -115,18 +131,23 @@ void screen_clear(ClearMode mode);
 void screen_clear_line(ClearMode mode);
 /** Clear part of line */
 void screen_clear_in_line(unsigned int count);
+/** Swap to alternate buffer (really what this does is backup terminal title, size and other global attributes) */
+void screen_swap_state(bool alternate);
+
+// --- insert / delete ---
+
+/** Insert lines at cursor, shove down */
+void screen_insert_lines(unsigned int lines);
+/** Delete lines at cursor, pull up */
+void screen_delete_lines(unsigned int lines);
+/** Insert characters at cursor, shove right */
+void screen_insert_characters(unsigned int count);
+/** Delete characters at cursor, pull left */
+void screen_delete_characters(unsigned int count);
 /** Shift screen upwards */
 void screen_scroll_up(unsigned int lines);
 /** Shift screen downwards */
 void screen_scroll_down(unsigned int lines);
-/** esc # 8 - fill entire screen with E of default colors */
-void screen_fill_with_E(void);
-
-// --- insert / delete ---
-void screen_insert_lines(unsigned int lines);
-void screen_delete_lines(unsigned int lines);
-void screen_insert_characters(unsigned int count);
-void screen_delete_characters(unsigned int count);
 
 // --- Cursor control ---
 
@@ -138,31 +159,81 @@ void screen_cursor_get(int *y, int *x);
 void screen_cursor_set_x(int x);
 /** Set cursor Y position */
 void screen_cursor_set_y(int y);
-/** Reset cursor attribs */
-void screen_reset_cursor(void);
 /** Relative cursor move */
 void screen_cursor_move(int dy, int dx, bool scroll);
 /** Save the cursor pos */
 void screen_cursor_save(bool withAttrs);
 /** Restore the cursor pos */
 void screen_cursor_restore(bool withAttrs);
-/** Enable cursor display */
+
-void screen_cursor_enable(bool enable);
+// --- Cursor behavior setting ---
+
+/** Toggle INSERT / REPLACE */
+void screen_set_insert_mode(bool insert);
+/** Enable CR auto */
+void screen_set_newline_mode(bool nlm);
 /** Enable auto wrap */
 void screen_wrap_enable(bool enable);
+/** Set scrolling region */
+void screen_set_scrolling_region(int from, int to);
+/** Enable or disable origin remap to top left of scrolling region */
+void screen_set_origin_mode(bool region_origin);
 
-// --- Colors ---
+// --- Graphic rendition setting ---
+
+typedef uint8_t Color; // 0-16
+
+#define ATTR_BOLD (1<<0)
+#define ATTR_FAINT (1<<1)
+#define ATTR_ITALIC (1<<2)
+#define ATTR_UNDERLINE (1<<3)
+#define ATTR_BLINK (1<<4)
+#define ATTR_FRAKTUR (1<<5)
+#define ATTR_STRIKE (1<<6)
 
 /** Set cursor foreground color */
 void screen_set_fg(Color color);
 /** Set cursor background coloor */
 void screen_set_bg(Color color);
-/** make foreground bright */
+/** Enable/disable attrs by bitmask */
-void screen_set_bold(bool bold);
+void screen_set_sgr(u8 attrs, bool ena);
-/** Set cursor foreground and background color */
+/** Set the inverse attribute */
-void screen_set_colors(Color fg, Color bg);
+void screen_set_sgr_inverse(bool ena);
-/** Invert colors */
+/** Reset cursor attribs */
-void screen_inverse(bool inverse);
+void screen_reset_sgr(void);
+
+// --- Global modes and attributes ---
+
+/** Enable cursor display */
+void screen_set_cursor_visible(bool visible);
+/** Toggle application keypad mode */
+void screen_set_numpad_alt_mode(bool app_mode);
+/** Toggle application cursor mode */
+void screen_set_cursors_alt_mode(bool app_mode);
+/** Set reverse video mode */
+void screen_set_reverse_video(bool reverse);
+
+// --- Charset ---
+
+/** Switch G0 <-> G1 */
+void screen_set_charset_n(int Gx);
+/** Assign G0 or G1 */
+void screen_set_charset(int Gx, char charset);
+
+// --- Tab stops ---
+
+/** Remove all tabs on the screen */
+void screen_clear_all_tabs(void);
+/** Set tab at the current column */
+void screen_set_tab(void);
+/** Remove tab at the current column (if any) */
+void screen_clear_tab(void);
+/** Move forward one tab */
+void screen_tab_forward(int count);
+/** Move backward one tab */
+void screen_tab_reverse(int count);
+
+// --- Printing characters ---
 
 /**
  * Set a character in the cursor color, move to right with wrap.
@@ -170,12 +241,31 @@ void screen_inverse(bool inverse);
  * unicode (then it can be 4 chars, or terminated by a zero)
  */
 void screen_putchar(const char *ch);
+/**
+ * esc # 8 - fill entire screen with E of default colors
+ * (DEC alignment test mode)
+ */
+void screen_fill_with_E(void);
 
-#if 0
+// --- Queries ---
-/** Debug dump */
-void screen_dd(void);
-#endif
 
+/** Check if coord is valid */
+bool screen_isCoordValid(int y, int x);
+/** Report current SGR as num;num;... for DAC query */
+void screen_report_sgr(char *buffer);
+
+// --- Notify ---
+
+typedef enum {
+	CHANGE_CONTENT = 0,
+	CHANGE_LABELS = 1,
+} ScreenNotifyChangeTopic;
+
+/**
+ * Called when the screen content or settings change
+ * and the front-end should redraw / update.
+ * @param topic - what kind of change this is (chooses what message to send)
+ */
 extern void screen_notifyChange(ScreenNotifyChangeTopic topic);
 
 #endif // SCREEN_H

user/serial.c

@@ -4,6 +4,47 @@
 #include "ansi_parser.h"
 #include "syscfg.h"
 
+#define LOGBUF_SIZE 1500
+static char logbuf[LOGBUF_SIZE];
+static u32 lb_nw = 1;
+static u32 lb_ls = 0;
+static ETSTimer flushLogTimer;
+
+static void buf_putc(char c)
+{
+	if (lb_ls != lb_nw) {
+		logbuf[lb_nw++] = c;
+		if (lb_nw >= LOGBUF_SIZE) lb_nw = 0;
+	}
+}
+
+static void buf_pop(void *unused)
+{
+	u32 quantity = 32;
+	u32 old_ls;
+	while (quantity > 0) {
+		// stop when done
+		if ((lb_ls == lb_nw-1) || (lb_ls == LOGBUF_SIZE-1 && lb_nw == 0)) break;
+
+		old_ls = lb_ls;
+		lb_ls++;
+		if (lb_ls >= LOGBUF_SIZE) lb_ls = 0;
+
+		if (OK == UART_WriteCharCRLF(UART1, logbuf[lb_ls], 1000)) {
+			quantity--;
+		} else {
+			// try another time
+			lb_ls = old_ls;
+			break;
+		}
+	}
+}
+
+LOCAL void my_putc(char c)
+{
+	UART_WriteCharCRLF(UART1, (u8) c, 10);
+}
+
 /**
  * Init the serial ports
  */
@@ -15,7 +56,15 @@ void ICACHE_FLASH_ATTR serialInitBase(void)
 	UART_SetStopBits(UART1, ONE_STOP_BIT);
 	UART_SetBaudrate(UART1, BIT_RATE_115200);
 	UART_SetPrintPort(UART1);
+	os_install_putc1(buf_putc);
+	//os_install_putc1(my_putc);
 	UART_SetupAsyncReceiver();
+
+	// 1 ms timer
+	os_timer_disarm(&flushLogTimer);
+	os_timer_setfn(&flushLogTimer, buf_pop, NULL);
+	//os_timer_arm(&flushLogTimer, 1, 1);
+	ets_timer_arm_new(&flushLogTimer, 1, 500, 0); // us timer
 }
 
 /**
@@ -42,5 +91,5 @@ void ICACHE_FLASH_ATTR serialInit(void)
  */
 void ICACHE_FLASH_ATTR UART_HandleRxByte(char c)
 {
-	ansi_parser(&c, 1);
+	ansi_parser(c);
 }

user/sgr.h

@@ -0,0 +1,37 @@
+//
+// Created by MightyPork on 2017/08/19.
+//
+
+#ifndef ESP_VT100_FIRMWARE_SGR_H
+#define ESP_VT100_FIRMWARE_SGR_H
+
+enum SGR_CODES {
+	SGR_RESET = 0,
+	SGR_BOLD = 1,
+	SGR_FAINT = 2,
+	SGR_ITALIC = 3,
+	SGR_UNDERLINE = 4,
+	SGR_BLINK = 5,
+	SGR_BLINK_FAST = 6,
+	SGR_INVERSE = 7,
+	SGR_STRIKE = 9,
+	SGR_FRAKTUR = 20,
+
+	SGR_FG_START = 30,
+	SGR_FG_END = 37,
+	SGR_FG_DEFAULT = 39,
+
+	SGR_BG_START = 40,
+	SGR_BG_END = 47,
+	SGR_BG_DEFAULT = 49,
+
+	SGR_FG_BRT_START = 90,
+	SGR_FG_BRT_END = 97,
+
+	SGR_BG_BRT_START = 100,
+	SGR_BG_BRT_END = 107,
+};
+
+#define SGR_OFF(n) (20+(n))
+
+#endif //ESP_VT100_FIRMWARE_SGR_H

user/syscfg.c

@@ -12,6 +12,8 @@ SystemConfigBundle * const sysconf = &persist.current.sysconf;
 void ICACHE_FLASH_ATTR
 sysconf_apply_settings(void)
 {
+	// !!! Update to current version !!!
+
 	serialInit();
 }
 

user/syscfg.h

@@ -10,11 +10,13 @@
 // Size designed for the wifi config structure
 // Must be constant to avoid corrupting user config after upgrade
 #define SYSCONF_SIZE 200
+#define SYSCONF_VERSION 0
 
 typedef struct {
 	u32 uart_baudrate;
 	u8 uart_parity;
 	u8 uart_stopbits;
+	u8 config_version;
 } SystemConfigBundle;
 
 extern SystemConfigBundle * const sysconf;

user/uart_asyncdrv.c-

@@ -0,0 +1,830 @@
+/*
+ * File	: uart.c
+ * Copyright (C) 2013 - 2016, Espressif Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of version 3 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <esp8266.h>
+#include <uart_register.h>
+#include "uart_asyncdrv.h-"
+
+// UartDev is defined and initialized in rom code.
+extern UartDevice    UartDev;
+
+struct UartBuffer {
+	uint32 UartBuffSize;
+	uint8 *pUartBuff;
+	uint8 *pInPos;
+	uint8 *pOutPos;
+	STATUS BuffState;
+	uint16 Space;  //remanent space of the buffer
+	uint8 TcpControl;
+	struct UartBuffer *nextBuff;
+};
+
+struct UartRxBuff {
+	uint32 UartRxBuffSize;
+	uint8 *pUartRxBuff;
+	uint8 *pWritePos;
+	uint8 *pReadPos;
+	STATUS RxBuffState;
+	uint32 Space;  //remanent space of the buffer
+};
+
+LOCAL struct UartBuffer* pTxBuffer = NULL;
+LOCAL struct UartBuffer* pRxBuffer = NULL;
+
+// Forward declare
+#if UART_BUFF_EN
+LOCAL void  Uart_Buf_Cpy(struct UartBuffer* pCur, char* pdata , uint16 data_len);
+void  uart_buf_free(struct UartBuffer* pBuff);
+void  tx_buff_enq(char* pdata, uint16 data_len );
+LOCAL void  tx_fifo_insert(struct UartBuffer* pTxBuff, uint8 data_len,  uint8 uart_no);
+void  tx_start_uart_buffer(uint8 uart_no);
+uint16  rx_buff_deq(char* pdata, uint16 data_len );
+void  Uart_rx_buff_enq();
+#endif
+
+//void ICACHE_FLASH_ATTR uart_test_rx();
+STATUS uart_tx_one_char(uint8 uart, uint8 TxChar);
+STATUS uart_tx_one_char_no_wait(uint8 uart, uint8 TxChar);
+void  uart1_sendStr_no_wait(const char *str);
+struct UartBuffer*  UART_AsyncBufferInit(u32 size);
+
+void  uart_rx_intr_enable(uint8 uart_no);
+void  uart_rx_intr_disable(uint8 uart_no);
+void uart0_tx_buffer(uint8 *buf, uint16 len);
+
+void uart0_sendStr(const char *str);
+
+
+/*uart demo with a system task, to output what uart receives*/
+/*this is a example to process uart data from task,please change the priority to fit your application task if exists*/
+/*it might conflict with your task, if so,please arrange the priority of different task,  or combine it to a different event in the same task. */
+#define uart_recvTaskPrio        0
+#define uart_recvTaskQueueLen    10
+os_event_t    uart_recvTaskQueue[uart_recvTaskQueueLen];
+
+#define DBG
+#define DBG1 uart1_sendStr_no_wait
+#define DBG2 os_printf
+
+
+LOCAL void uart0_rx_intr_handler(void *para);
+
+/******************************************************************************
+ * FunctionName : uart_config
+ * Description  : Internal used function
+ *                UART0 used for data TX/RX, RX buffer size is 0x100, interrupt enabled
+ *                UART1 just used for debug output
+ * Parameters   : uart_no, use UART0 or UART1 defined ahead
+ * Returns      : NONE
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+uart_config(uint8 uart_no)
+{
+    if (uart_no == UART1){
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_U1TXD_BK);
+    }else{
+        /* rcv_buff size if 0x100 */
+        ETS_UART_INTR_ATTACH(uart0_rx_intr_handler,  &(UartDev.rcv_buff));
+        PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0TXD_U);
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD);
+	#if UART_HW_RTS
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, FUNC_U0RTS);   //HW FLOW CONTROL RTS PIN
+        #endif
+	#if UART_HW_CTS
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_U0CTS);   //HW FLOW CONTROL CTS PIN
+        #endif
+    }
+    uart_div_modify(uart_no, UART_CLK_FREQ / (UartDev.baut_rate));//SET BAUDRATE
+
+    WRITE_PERI_REG(UART_CONF0(uart_no), ((UartDev.exist_parity & UART_PARITY_EN_M)  <<  UART_PARITY_EN_S) //SET BIT AND PARITY MODE
+                                                                        | ((UartDev.parity & UART_PARITY_M)  <<UART_PARITY_S )
+                                                                        | ((UartDev.stop_bits & UART_STOP_BIT_NUM) << UART_STOP_BIT_NUM_S)
+                                                                        | ((UartDev.data_bits & UART_BIT_NUM) << UART_BIT_NUM_S));
+
+    //clear rx and tx fifo,not ready
+    SET_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);    //RESET FIFO
+    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
+
+    if (uart_no == UART0){
+        //set rx fifo trigger
+        WRITE_PERI_REG(UART_CONF1(uart_no),
+        ((100 & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S) |
+        #if UART_HW_RTS
+        ((110 & UART_RX_FLOW_THRHD) << UART_RX_FLOW_THRHD_S) |
+        UART_RX_FLOW_EN |   //enbale rx flow control
+        #endif
+        (0x02 & UART_RX_TOUT_THRHD) << UART_RX_TOUT_THRHD_S |
+        UART_RX_TOUT_EN|
+        ((0x10 & UART_TXFIFO_EMPTY_THRHD)<<UART_TXFIFO_EMPTY_THRHD_S));//wjl
+        #if UART_HW_CTS
+        SET_PERI_REG_MASK( UART_CONF0(uart_no),UART_TX_FLOW_EN);  //add this sentense to add a tx flow control via MTCK( CTS )
+        #endif
+        SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_TOUT_INT_ENA |UART_FRM_ERR_INT_ENA);
+    }else{
+        WRITE_PERI_REG(UART_CONF1(uart_no),((UartDev.rcv_buff.TrigLvl & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S));//TrigLvl default val == 1
+    }
+    //clear all interrupt
+    WRITE_PERI_REG(UART_INT_CLR(uart_no), 0xffff);
+    //enable rx_interrupt
+    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_OVF_INT_ENA);
+}
+
+/******************************************************************************
+ * FunctionName : uart1_tx_one_char
+ * Description  : Internal used function
+ *                Use uart1 interface to transfer one char
+ * Parameters   : uint8 TxChar - character to tx
+ * Returns      : OK
+*******************************************************************************/
+ STATUS uart_tx_one_char(uint8 uart, uint8 TxChar)
+{
+    while (true){
+        uint32 fifo_cnt = READ_PERI_REG(UART_STATUS(uart)) & (UART_TXFIFO_CNT<<UART_TXFIFO_CNT_S);
+        if ((fifo_cnt >> UART_TXFIFO_CNT_S & UART_TXFIFO_CNT) < 126) {
+            break;
+        }
+    }
+    WRITE_PERI_REG(UART_FIFO(uart) , TxChar);
+    return OK;
+}
+
+/******************************************************************************
+ * FunctionName : uart1_write_char
+ * Description  : Internal used function
+ *                Do some special deal while tx char is '\r' or '\n'
+ * Parameters   : char c - character to tx
+ * Returns      : NONE
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+uart1_write_char(char c)
+{
+    if (c == '\n'){
+        uart_tx_one_char(UART1, '\r');
+        uart_tx_one_char(UART1, '\n');
+    }else if (c == '\r'){
+
+    }else{
+        uart_tx_one_char(UART1, c);
+    }
+}
+
+//os_printf output to fifo or to the tx buffer
+LOCAL void ICACHE_FLASH_ATTR
+uart0_write_char_no_wait(char c)
+{
+#if UART_BUFF_EN    //send to uart0 fifo but do not wait 
+    uint8 chr;
+//    if (c == '\n'){
+//        chr = '\r';
+//        tx_buff_enq(&chr, 1);
+//        chr = '\n';
+//        tx_buff_enq(&chr, 1);
+//    }else if (c == '\r'){
+//
+//    }else{
+      tx_buff_enq(&c,1);
+//    }
+#else //send to uart tx buffer
+    if (c == '\n'){
+        uart_tx_one_char_no_wait(UART0, '\r');
+        uart_tx_one_char_no_wait(UART0, '\n');
+    }else if (c == '\r'){
+
+    }
+    else{
+        uart_tx_one_char_no_wait(UART0, c);
+    }
+#endif
+}
+
+/******************************************************************************
+ * FunctionName : uart0_tx_buffer
+ * Description  : use uart0 to transfer buffer
+ * Parameters   : uint8 *buf - point to send buffer
+ *                uint16 len - buffer len
+ * Returns      :
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+uart0_tx_buffer(uint8 *buf, uint16 len)
+{
+    uint16 i;
+    for (i = 0; i < len; i++)
+    {
+        uart_tx_one_char(UART0, buf[i]);
+    }
+}
+
+/******************************************************************************
+ * FunctionName : uart0_sendStr
+ * Description  : use uart0 to transfer buffer
+ * Parameters   : uint8 *buf - point to send buffer
+ *                uint16 len - buffer len
+ * Returns      :
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+uart0_sendStr(const char *str)
+{
+    while(*str){
+        uart_tx_one_char(UART0, *str++);
+    }
+}
+void at_port_print(const char *str) __attribute__((alias("uart0_sendStr")));
+/******************************************************************************
+ * FunctionName : uart0_rx_intr_handler
+ * Description  : Internal used function
+ *                UART0 interrupt handler, add self handle code inside
+ * Parameters   : void *para - point to ETS_UART_INTR_ATTACH's arg
+ * Returns      : NONE
+*******************************************************************************/
+LOCAL void
+uart0_rx_intr_handler(void *para)
+{
+    /* uart0 and uart1 intr combine togther, when interrupt occur, see reg 0x3ff20020, bit2, bit0 represents
+    * uart1 and uart0 respectively
+    */
+    uint8 RcvChar;
+    uint8 uart_no = UART0;//UartDev.buff_uart_no;
+    uint8 fifo_len = 0;
+    uint8 buf_idx = 0;
+    uint8 temp,cnt;
+    //RcvMsgBuff *pRxBuff = (RcvMsgBuff *)para;
+
+    	/*ATTENTION:*/
+	/*IN NON-OS VERSION SDK, DO NOT USE "ICACHE_FLASH_ATTR" FUNCTIONS IN THE WHOLE HANDLER PROCESS*/
+	/*ALL THE FUNCTIONS CALLED IN INTERRUPT HANDLER MUST BE DECLARED IN RAM */
+	/*IF NOT , POST AN EVENT AND PROCESS IN SYSTEM TASK */
+    if(UART_FRM_ERR_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_FRM_ERR_INT_ST)){
+        DBG1("FRM_ERR\r\n");
+        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_FRM_ERR_INT_CLR);
+    }else if(UART_RXFIFO_FULL_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_FULL_INT_ST)){
+		// Full interrupt - FIFO threshold reached
+        DBG("f");
+        uart_rx_intr_disable(UART0);
+        WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR);
+        system_os_post(uart_recvTaskPrio, 0, 0); // tell the handler
+    }else if(UART_RXFIFO_TOUT_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_TOUT_INT_ST)){
+		// Timeout interrupt - Line idle for a while
+        DBG("t");
+        uart_rx_intr_disable(UART0);
+        WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_TOUT_INT_CLR);
+        system_os_post(uart_recvTaskPrio, 0, 0); // tell the handler
+    }else if(UART_TXFIFO_EMPTY_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_TXFIFO_EMPTY_INT_ST)){
+        DBG("e");
+		// TX fifo is empty, can send more.
+
+	/* to output uart data from uart buffer directly in empty interrupt handler*/
+	/*instead of processing in system event, in order not to wait for current task/function to quit */
+	/*ATTENTION:*/
+	/*IN NON-OS VERSION SDK, DO NOT USE "ICACHE_FLASH_ATTR" FUNCTIONS IN THE WHOLE HANDLER PROCESS*/
+	/*ALL THE FUNCTIONS CALLED IN INTERRUPT HANDLER MUST BE DECLARED IN RAM */
+	CLEAR_PERI_REG_MASK(UART_INT_ENA(UART0), UART_TXFIFO_EMPTY_INT_ENA);
+	#if UART_BUFF_EN
+		tx_start_uart_buffer(UART0);
+	#endif
+        //system_os_post(uart_recvTaskPrio, 1, 0);
+        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_TXFIFO_EMPTY_INT_CLR);
+
+    }else if(UART_RXFIFO_OVF_INT_ST  == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_OVF_INT_ST)){
+        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_RXFIFO_OVF_INT_CLR);
+        DBG1("RX OVF!!\r\n");
+    }
+
+}
+
+/******************************************************************************
+ * FunctionName : uart_init
+ * Description  : user interface for init uart
+ * Parameters   : UartBautRate uart0_br - uart0 bautrate
+ *                UartBautRate uart1_br - uart1 bautrate
+ * Returns      : NONE
+*******************************************************************************/
+#if UART_SELFTEST&UART_BUFF_EN
+os_timer_t buff_timer_t;
+void ICACHE_FLASH_ATTR
+uart_test_rx()
+{
+    uint8 uart_buf[128]={0};
+    uint16 len = 0;
+    len = rx_buff_deq(uart_buf, 128 );
+    tx_buff_enq(uart_buf,len);
+}
+#endif
+
+LOCAL void ICACHE_FLASH_ATTR ///////
+uart_recvTask(os_event_t *events)
+{
+    if(events->sig == 0){
+    #if  UART_BUFF_EN
+        Uart_rx_buff_enq();
+    #else
+        uint8 fifo_len = (READ_PERI_REG(UART_STATUS(UART0))>>UART_RXFIFO_CNT_S)&UART_RXFIFO_CNT;
+        uint8 d_tmp = 0;
+        uint8 idx=0;
+        for(idx=0;idx<fifo_len;idx++) {
+            d_tmp = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;
+            uart_tx_one_char(UART0, d_tmp);
+        }
+        WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR|UART_RXFIFO_TOUT_INT_CLR);
+        uart_rx_intr_enable(UART0);
+    #endif
+    }else if(events->sig == 1){
+    #if UART_BUFF_EN
+	 //already move uart buffer output to uart empty interrupt
+        //tx_start_uart_buffer(UART0);
+    #else
+
+    #endif
+    }
+}
+
+void ICACHE_FLASH_ATTR
+uart_init(UartBautRate uart0_br, UartBautRate uart1_br)
+{
+    /*this is a example to process uart data from task,please change the priority to fit your application task if exists*/
+    system_os_task(uart_recvTask, uart_recvTaskPrio, uart_recvTaskQueue, uart_recvTaskQueueLen);  //demo with a task to process the uart data
+
+    UartDev.baut_rate = uart0_br;
+    uart_config(UART0);
+    UartDev.baut_rate = uart1_br;
+    uart_config(UART1);
+    ETS_UART_INTR_ENABLE();
+
+    #if UART_BUFF_EN
+    pTxBuffer = UART_AsyncBufferInit(UART_TX_BUFFER_SIZE);
+    pRxBuffer = UART_AsyncBufferInit(UART_RX_BUFFER_SIZE);
+    #endif
+
+
+    /*option 1: use default print, output from uart0 , will wait some time if fifo is full */
+    //do nothing...
+
+    /*option 2: output from uart1,uart1 output will not wait , just for output debug info */
+    /*os_printf output uart data via uart1(GPIO2)*/
+    os_install_putc1((void *)uart1_write_char);    //use this one to output debug information via uart1 //
+
+    /*option 3: output from uart0 will skip current byte if fifo is full now... */
+    /*see uart0_write_char_no_wait:you can output via a buffer or output directly */
+    /*os_printf output uart data via uart0 or uart buffer*/
+    //os_install_putc1((void *)uart0_write_char_no_wait);  //use this to print via uart0
+
+    #if UART_SELFTEST&UART_BUFF_EN
+    os_timer_disarm(&buff_timer_t);
+    os_timer_setfn(&buff_timer_t, uart_test_rx , NULL);   //a demo to process the data in uart rx buffer
+    os_timer_arm(&buff_timer_t,10,1);
+    #endif
+}
+
+//void ICACHE_FLASH_ATTR
+//uart_reattach()
+//{
+//    uart_init(BIT_RATE_115200, BIT_RATE_115200);
+//}
+
+/******************************************************************************
+ * FunctionName : uart_tx_one_char_no_wait
+ * Description  : uart tx a single char without waiting for fifo 
+ * Parameters   : uint8 uart - uart port
+ *                uint8 TxChar - char to tx
+ * Returns      : STATUS
+*******************************************************************************/
+STATUS uart_tx_one_char_no_wait(uint8 uart, uint8 TxChar)
+{
+    uint8 fifo_cnt = (( READ_PERI_REG(UART_STATUS(uart))>>UART_TXFIFO_CNT_S)& UART_TXFIFO_CNT);
+    if (fifo_cnt < 126) {
+        WRITE_PERI_REG(UART_FIFO(uart) , TxChar);
+    }
+    return OK;
+}
+
+//STATUS uart0_tx_one_char_no_wait(uint8 TxChar)
+//{
+//    uint8 fifo_cnt = (( READ_PERI_REG(UART_STATUS(UART0))>>UART_TXFIFO_CNT_S)& UART_TXFIFO_CNT);
+//    if (fifo_cnt < 126) {
+//        WRITE_PERI_REG(UART_FIFO(UART0) , TxChar);
+//    }
+//    return OK;
+//}
+
+
+/******************************************************************************
+ * FunctionName : uart1_sendStr_no_wait
+ * Description  : uart tx a string without waiting for every char, used for print debug info which can be lost
+ * Parameters   : const char *str - string to be sent
+ * Returns      : NONE
+*******************************************************************************/
+void uart1_sendStr_no_wait(const char *str)
+{
+    while(*str){
+        uart_tx_one_char_no_wait(UART1, *str++);
+    }
+}
+
+
+#if UART_BUFF_EN
+/******************************************************************************
+ * FunctionName : Uart_Buf_Init
+ * Description  : tx buffer enqueue: fill a first linked buffer 
+ * Parameters   : char *pdata - data point  to be enqueue
+ * Returns      : NONE
+*******************************************************************************/
+struct UartBuffer* ICACHE_FLASH_ATTR
+UART_AsyncBufferInit(uint32 buf_size)
+{
+    uint32 heap_size = system_get_free_heap_size();
+    if(heap_size <=buf_size){
+        DBG1("no buf for uart\n\r");
+        return NULL;
+    }else{
+        DBG("test heap size: %d\n\r",heap_size);
+        struct UartBuffer* pBuff = (struct UartBuffer* )os_malloc(sizeof(struct UartBuffer));
+        pBuff->UartBuffSize = buf_size;
+        pBuff->pUartBuff = (uint8*)os_malloc(pBuff->UartBuffSize);
+        pBuff->pInPos = pBuff->pUartBuff;
+        pBuff->pOutPos = pBuff->pUartBuff;
+        pBuff->Space = (uint16) pBuff->UartBuffSize;
+        pBuff->BuffState = OK;
+        pBuff->nextBuff = NULL;
+        pBuff->TcpControl = RUN;
+        return pBuff;
+    }
+}
+
+
+//copy uart buffer
+LOCAL void Uart_Buf_Cpy(struct UartBuffer* pCur, char* pdata , uint16 data_len)
+{
+    if(data_len == 0) return;
+
+    uint16 tail_len = (uint16) (pCur->pUartBuff + pCur->UartBuffSize - pCur->pInPos);
+    if(tail_len >= data_len){  //do not need to loop back  the queue
+        os_memcpy(pCur->pInPos , pdata , data_len );
+        pCur->pInPos += ( data_len );
+        pCur->pInPos = (pCur->pUartBuff +  (pCur->pInPos - pCur->pUartBuff) % pCur->UartBuffSize );
+        pCur->Space -=data_len;
+    }else{
+        os_memcpy(pCur->pInPos, pdata, tail_len);
+        pCur->pInPos += ( tail_len );
+        pCur->pInPos = (pCur->pUartBuff +  (pCur->pInPos - pCur->pUartBuff) % pCur->UartBuffSize );
+        pCur->Space -=tail_len;
+        os_memcpy(pCur->pInPos, pdata+tail_len , data_len-tail_len);
+        pCur->pInPos += ( data_len-tail_len );
+        pCur->pInPos = (pCur->pUartBuff +  (pCur->pInPos - pCur->pUartBuff) % pCur->UartBuffSize );
+        pCur->Space -=( data_len-tail_len);
+    }
+
+}
+
+/******************************************************************************
+ * FunctionName : uart_buf_free
+ * Description  : deinit of the tx buffer
+ * Parameters   : struct UartBuffer* pTxBuff - tx buffer struct pointer
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+uart_buf_free(struct UartBuffer* pBuff)
+{
+    os_free(pBuff->pUartBuff);
+    os_free(pBuff);
+}
+
+
+//rx buffer dequeue
+uint16 ICACHE_FLASH_ATTR
+rx_buff_deq(char* pdata, uint16 data_len)
+{
+    uint16 buf_len =  (pRxBuffer->UartBuffSize- pRxBuffer->Space);
+    uint16 tail_len = pRxBuffer->pUartBuff + pRxBuffer->UartBuffSize - pRxBuffer->pOutPos ;
+    uint16 len_tmp = 0;
+    len_tmp = ((data_len > buf_len)?buf_len:data_len);
+    if(pRxBuffer->pOutPos <= pRxBuffer->pInPos){
+        os_memcpy(pdata, pRxBuffer->pOutPos,len_tmp);
+        pRxBuffer->pOutPos+= len_tmp;
+        pRxBuffer->Space += len_tmp;
+    }else{
+        if(len_tmp>tail_len){
+            os_memcpy(pdata, pRxBuffer->pOutPos, tail_len);
+            pRxBuffer->pOutPos += tail_len;
+            pRxBuffer->pOutPos = (pRxBuffer->pUartBuff +  (pRxBuffer->pOutPos- pRxBuffer->pUartBuff) % pRxBuffer->UartBuffSize );
+            pRxBuffer->Space += tail_len;
+
+            os_memcpy(pdata+tail_len , pRxBuffer->pOutPos, len_tmp-tail_len);
+            pRxBuffer->pOutPos+= ( len_tmp-tail_len );
+            pRxBuffer->pOutPos= (pRxBuffer->pUartBuff +  (pRxBuffer->pOutPos- pRxBuffer->pUartBuff) % pRxBuffer->UartBuffSize );
+            pRxBuffer->Space +=( len_tmp-tail_len);
+        }else{
+            //os_printf("case 3 in rx deq\n\r");
+            os_memcpy(pdata, pRxBuffer->pOutPos, len_tmp);
+            pRxBuffer->pOutPos += len_tmp;
+            pRxBuffer->pOutPos = (pRxBuffer->pUartBuff +  (pRxBuffer->pOutPos- pRxBuffer->pUartBuff) % pRxBuffer->UartBuffSize );
+            pRxBuffer->Space += len_tmp;
+        }
+    }
+    if(pRxBuffer->Space >= UART_FIFO_LEN){
+        uart_rx_intr_enable(UART0);
+    }
+    return len_tmp;
+}
+
+
+//move data from uart fifo to rx buffer
+void Uart_rx_buff_enq()
+{
+    uint8 fifo_len,buf_idx;
+    uint8 fifo_data;
+    #if 1
+    fifo_len = (READ_PERI_REG(UART_STATUS(UART0))>>UART_RXFIFO_CNT_S)&UART_RXFIFO_CNT;
+    if(fifo_len >= pRxBuffer->Space){
+        os_printf("buf full!!!\n\r");
+    }else{
+        buf_idx=0;
+        while(buf_idx < fifo_len){
+            buf_idx++;
+            fifo_data = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;
+            *(pRxBuffer->pInPos++) = fifo_data;
+            if(pRxBuffer->pInPos == (pRxBuffer->pUartBuff + pRxBuffer->UartBuffSize)){
+                pRxBuffer->pInPos = pRxBuffer->pUartBuff;
+            }
+        }
+        pRxBuffer->Space -= fifo_len ;
+        if(pRxBuffer->Space >= UART_FIFO_LEN){
+            //os_printf("after rx enq buf enough\n\r");
+            uart_rx_intr_enable(UART0);
+        }
+    }
+    #endif
+}
+
+
+//fill the uart tx buffer
+void ICACHE_FLASH_ATTR
+tx_buff_enq(char* pdata, uint16 data_len )
+{
+    if(pTxBuffer == NULL){
+        DBG1("\n\rnull, create buffer struct\n\r");
+        pTxBuffer = UART_AsyncBufferInit(UART_TX_BUFFER_SIZE);
+        if(pTxBuffer!= NULL){
+            Uart_Buf_Cpy(pTxBuffer ,  pdata,  data_len );
+        }else{
+            DBG1("uart tx MALLOC no buf \n\r");
+        }
+    }else{
+        if(data_len <= pTxBuffer->Space){
+        Uart_Buf_Cpy(pTxBuffer ,  pdata,  data_len);
+        }else{
+            DBG1("UART TX BUF FULL!!!!\n\r");
+        }
+    }
+    #if 0
+    if(pTxBuffer->Space <= URAT_TX_LOWER_SIZE){
+	    set_tcp_block();
+    }
+    #endif
+    SET_PERI_REG_MASK(UART_CONF1(UART0), (UART_TX_EMPTY_THRESH_VAL & UART_TXFIFO_EMPTY_THRHD)<<UART_TXFIFO_EMPTY_THRHD_S);
+    SET_PERI_REG_MASK(UART_INT_ENA(UART0), UART_TXFIFO_EMPTY_INT_ENA);
+}
+
+
+
+//--------------------------------
+LOCAL void tx_fifo_insert(struct UartBuffer* pTxBuff, uint8 data_len,  uint8 uart_no)
+{
+    uint8 i;
+    for(i = 0; i<data_len;i++){
+        WRITE_PERI_REG(UART_FIFO(uart_no) , *(pTxBuff->pOutPos++));
+        if(pTxBuff->pOutPos == (pTxBuff->pUartBuff + pTxBuff->UartBuffSize)){
+            pTxBuff->pOutPos = pTxBuff->pUartBuff;
+        }
+    }
+    pTxBuff->pOutPos = (pTxBuff->pUartBuff +  (pTxBuff->pOutPos - pTxBuff->pUartBuff) % pTxBuff->UartBuffSize );
+    pTxBuff->Space += data_len;
+}
+
+
+/******************************************************************************
+ * FunctionName : tx_start_uart_buffer
+ * Description  : get data from the tx buffer and fill the uart tx fifo, co-work with the uart fifo empty interrupt
+ * Parameters   : uint8 uart_no - uart port num
+ * Returns      : NONE
+*******************************************************************************/
+void tx_start_uart_buffer(uint8 uart_no)
+{
+    uint8 tx_fifo_len = (READ_PERI_REG(UART_STATUS(uart_no))>>UART_TXFIFO_CNT_S)&UART_TXFIFO_CNT;
+    uint8 fifo_remain = UART_FIFO_LEN - tx_fifo_len ;
+    uint8 len_tmp;
+    uint16 tail_ptx_len,head_ptx_len,data_len;
+    //struct UartBuffer* pTxBuff = *get_buff_prt();
+
+    if(pTxBuffer){
+        data_len = (pTxBuffer->UartBuffSize - pTxBuffer->Space);
+        if(data_len > fifo_remain){
+            len_tmp = fifo_remain;
+			tx_fifo_enq(pTxBuffer, len_tmp, uart_no);
+            SET_PERI_REG_MASK(UART_INT_ENA(UART0), UART_TXFIFO_EMPTY_INT_ENA);
+        }else{
+            len_tmp = data_len;
+			tx_fifo_enq(pTxBuffer, len_tmp, uart_no);
+        }
+    }else{
+        DBG1("pTxBuff null \n\r");
+    }
+}
+
+#endif
+
+
+void uart_rx_intr_disable(uint8 uart_no)
+{
+#if 1
+    CLEAR_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);
+#else
+    ETS_UART_INTR_DISABLE();
+#endif
+}
+
+void uart_rx_intr_enable(uint8 uart_no)
+{
+#if 1
+    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);
+#else
+    ETS_UART_INTR_ENABLE();
+#endif
+}
+
+
+//========================================================
+LOCAL void
+uart0_write_char(char c)
+{
+    if (c == '\n') {
+        uart_tx_one_char(UART0, '\r');
+        uart_tx_one_char(UART0, '\n');
+    } else if (c == '\r') {
+    } else {
+        uart_tx_one_char(UART0, c);
+    }
+}
+
+void ICACHE_FLASH_ATTR
+UART_SetWordLength(uint8 uart_no, UartBitsNum4Char len)
+{
+    SET_PERI_REG_BITS(UART_CONF0(uart_no),UART_BIT_NUM,len,UART_BIT_NUM_S);
+}
+
+void ICACHE_FLASH_ATTR
+UART_SetStopBits(uint8 uart_no, UartStopBitsNum bit_num)
+{
+    SET_PERI_REG_BITS(UART_CONF0(uart_no),UART_STOP_BIT_NUM,bit_num,UART_STOP_BIT_NUM_S);
+}
+
+void ICACHE_FLASH_ATTR
+UART_SetLineInverse(uint8 uart_no, UART_LineLevelInverse inverse_mask)
+{
+    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_LINE_INV_MASK);
+    SET_PERI_REG_MASK(UART_CONF0(uart_no), inverse_mask);
+}
+
+void ICACHE_FLASH_ATTR
+UART_SetParity(uint8 uart_no, UartParityMode Parity_mode)
+{
+    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_PARITY |UART_PARITY_EN);
+    if(Parity_mode==NONE_BITS){
+    }else{
+        SET_PERI_REG_MASK(UART_CONF0(uart_no), Parity_mode|UART_PARITY_EN);
+    }
+}
+
+void ICACHE_FLASH_ATTR
+UART_SetBaudrate(uint8 uart_no,uint32 baud_rate)
+{
+    uart_div_modify(uart_no, UART_CLK_FREQ /baud_rate);
+}
+
+void ICACHE_FLASH_ATTR
+UART_SetFlowCtrl(uint8 uart_no,UART_HwFlowCtrl flow_ctrl,uint8 rx_thresh)
+{
+    if(flow_ctrl&USART_HardwareFlowControl_RTS){
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, FUNC_U0RTS);
+        SET_PERI_REG_BITS(UART_CONF1(uart_no),UART_RX_FLOW_THRHD,rx_thresh,UART_RX_FLOW_THRHD_S);
+        SET_PERI_REG_MASK(UART_CONF1(uart_no), UART_RX_FLOW_EN);
+    }else{
+        CLEAR_PERI_REG_MASK(UART_CONF1(uart_no), UART_RX_FLOW_EN);
+    }
+    if(flow_ctrl&USART_HardwareFlowControl_CTS){
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_UART0_CTS);
+        SET_PERI_REG_MASK(UART_CONF0(uart_no), UART_TX_FLOW_EN);
+    }else{
+        CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_TX_FLOW_EN);
+    }
+}
+
+void ICACHE_FLASH_ATTR
+UART_WaitTxFifoEmpty(uint8 uart_no , uint32 time_out_us) //do not use if tx flow control enabled
+{
+    uint32 t_s = system_get_time();
+    while (READ_PERI_REG(UART_STATUS(uart_no)) & (UART_TXFIFO_CNT << UART_TXFIFO_CNT_S)){
+
+        if(( system_get_time() - t_s )> time_out_us){
+            break;
+        }
+	WRITE_PERI_REG(0X60000914, 0X73);//WTD
+
+    }
+}
+
+
+bool ICACHE_FLASH_ATTR
+UART_CheckOutputFinished(uint8 uart_no, uint32 time_out_us)
+{
+    uint32 t_start = system_get_time();
+    uint8 tx_fifo_len;
+    uint32 tx_buff_len;
+    while(1){
+        tx_fifo_len =( (READ_PERI_REG(UART_STATUS(uart_no))>>UART_TXFIFO_CNT_S)&UART_TXFIFO_CNT);
+        if(pTxBuffer){
+            tx_buff_len = ((pTxBuffer->UartBuffSize)-(pTxBuffer->Space));
+        }else{
+            tx_buff_len = 0;
+        }
+
+        if( tx_fifo_len==0 && tx_buff_len==0){
+            return TRUE;
+        }
+        if( system_get_time() - t_start > time_out_us){
+            return FALSE;
+        }
+	WRITE_PERI_REG(0X60000914, 0X73);//WTD
+    }
+}
+
+
+void ICACHE_FLASH_ATTR
+UART_ResetFifo(uint8 uart_no)
+{
+    SET_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
+    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
+}
+
+void ICACHE_FLASH_ATTR
+UART_ClearIntrStatus(uint8 uart_no,uint32 clr_mask)
+{
+    WRITE_PERI_REG(UART_INT_CLR(uart_no), clr_mask);
+}
+
+void ICACHE_FLASH_ATTR
+UART_SetIntrEna(uint8 uart_no,uint32 ena_mask)
+{
+    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), ena_mask);
+}
+
+
+void ICACHE_FLASH_ATTR
+UART_SetPrintPort(uint8 uart_no)
+{
+    if(uart_no==1){
+        os_install_putc1(uart1_write_char);
+    }else{
+        /*option 1: do not wait if uart fifo is full,drop current character*/
+        os_install_putc1(uart0_write_char_no_wait);
+	/*option 2: wait for a while if uart fifo is full*/
+	os_install_putc1(uart0_write_char);
+    }
+}
+
+
+//========================================================
+
+//
+///*test code*/
+//void ICACHE_FLASH_ATTR
+//uart_init_2(UartBautRate uart0_br, UartBautRate uart1_br)
+//{
+//    // rom use 74880 baut_rate, here reinitialize
+//    UartDev.baut_rate = uart0_br;
+//    UartDev.exist_parity = STICK_PARITY_EN;
+//    UartDev.parity = EVEN_BITS;
+//    UartDev.stop_bits = ONE_STOP_BIT;
+//    UartDev.data_bits = EIGHT_BITS;
+//
+//    uart_config(UART0);
+//    UartDev.baut_rate = uart1_br;
+//    uart_config(UART1);
+//    ETS_UART_INTR_ENABLE();
+//
+//    // install uart1 putc callback
+//    os_install_putc1((void *)uart1_write_char);//print output at UART1
+//}
+//
+//

user/uart_asyncdrv.h-

@@ -0,0 +1,178 @@
+/*
+ * File	: uart.h
+ * Copyright (C) 2013 - 2016, Espressif Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of version 3 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef UART_APP_H
+#define UART_APP_H
+
+#include <esp8266.h>
+
+#define UART_TX_BUFFER_SIZE 512  //Ring buffer length of tx buffer
+#define UART_RX_BUFFER_SIZE 512 //Ring buffer length of rx buffer
+
+#define UART_BUFF_EN  1   //use uart buffer  , FOR UART0
+#define UART_SELFTEST  0  //set 1:enable the loop test demo for uart buffer, FOR UART0
+
+#define UART_HW_RTS  0   //set 1: enable uart hw flow control RTS, PIN MTDO, FOR UART0
+#define UART_HW_CTS  0    //set1: enable uart hw flow contrl CTS , PIN MTCK, FOR UART0
+
+#define UART0   0
+#define UART1   1
+
+typedef enum {
+	FIVE_BITS = 0x0,
+	SIX_BITS = 0x1,
+	SEVEN_BITS = 0x2,
+	EIGHT_BITS = 0x3
+} UartBitsNum4Char;
+
+typedef enum {
+	ONE_STOP_BIT = 0x1,
+	ONE_HALF_STOP_BIT = 0x2,
+	TWO_STOP_BIT = 0x3
+} UartStopBitsNum;
+
+typedef enum {
+	NONE_BITS = 0x2,
+	ODD_BITS = 1,
+	EVEN_BITS = 0
+} UartParityMode;
+
+typedef enum {
+	STICK_PARITY_DIS = 0,
+	STICK_PARITY_EN = 1
+} UartExistParity;
+
+typedef enum {
+	UART_None_Inverse = 0x0,
+	UART_Rxd_Inverse = UART_RXD_INV,
+	UART_CTS_Inverse = UART_CTS_INV,
+	UART_Txd_Inverse = UART_TXD_INV,
+	UART_RTS_Inverse = UART_RTS_INV,
+} UART_LineLevelInverse;
+
+
+typedef enum {
+	BIT_RATE_300 = 300,
+	BIT_RATE_600 = 600,
+	BIT_RATE_1200 = 1200,
+	BIT_RATE_2400 = 2400,
+	BIT_RATE_4800 = 4800,
+	BIT_RATE_9600 = 9600,
+	BIT_RATE_19200 = 19200,
+	BIT_RATE_38400 = 38400,
+	BIT_RATE_57600 = 57600,
+	BIT_RATE_74880 = 74880,
+	BIT_RATE_115200 = 115200,
+	BIT_RATE_230400 = 230400,
+	BIT_RATE_460800 = 460800,
+	BIT_RATE_921600 = 921600,
+	BIT_RATE_1843200 = 1843200,
+	BIT_RATE_3686400 = 3686400,
+} UartBautRate;
+
+typedef enum {
+	NONE_CTRL,
+	HARDWARE_CTRL,
+	XON_XOFF_CTRL
+} UartFlowCtrl;
+
+typedef enum {
+	USART_HardwareFlowControl_None = 0x0,
+	USART_HardwareFlowControl_RTS = 0x1,
+	USART_HardwareFlowControl_CTS = 0x2,
+	USART_HardwareFlowControl_CTS_RTS = 0x3
+} UART_HwFlowCtrl;
+
+typedef enum {
+	EMPTY,
+	UNDER_WRITE,
+	WRITE_OVER
+} RcvMsgBuffState;
+
+typedef struct {
+	uint32 RcvBuffSize;
+	uint8 *pRcvMsgBuff;
+	uint8 *pWritePos;
+	uint8 *pReadPos;
+	uint8 TrigLvl; //JLU: may need to pad
+	RcvMsgBuffState BuffState;
+} RcvMsgBuff;
+
+typedef struct {
+	uint32 TrxBuffSize;
+	uint8 *pTrxBuff;
+} TrxMsgBuff;
+
+typedef enum {
+	BAUD_RATE_DET,
+	WAIT_SYNC_FRM,
+	SRCH_MSG_HEAD,
+	RCV_MSG_BODY,
+	RCV_ESC_CHAR,
+} RcvMsgState;
+
+typedef struct {
+	UartBautRate baut_rate;
+	UartBitsNum4Char data_bits;
+	UartExistParity exist_parity;
+	UartParityMode parity;
+	UartStopBitsNum stop_bits;
+	UartFlowCtrl flow_ctrl;
+	RcvMsgBuff rcv_buff;
+	TrxMsgBuff trx_buff;
+	RcvMsgState rcv_state;
+	int received;
+	int buff_uart_no;  //indicate which uart use tx/rx buffer
+} UartDevice;
+
+void uart_init(UartBautRate uart0_br, UartBautRate uart1_br);
+
+///////////////////////////////////////
+#define UART_FIFO_LEN  128  //define the tx fifo length
+#define UART_TX_EMPTY_THRESH_VAL 0x10
+
+
+typedef enum {
+    RUN = 0,
+    BLOCK = 1,
+} TCPState;
+
+
+//==============================================
+#define FUNC_UART0_CTS 4
+#define FUNC_U0CTS                      4
+#define FUNC_U1TXD_BK                   2
+#define UART_LINE_INV_MASK  (0x3f<<19)
+void UART_SetWordLength(uint8 uart_no, UartBitsNum4Char len);
+void UART_SetStopBits(uint8 uart_no, UartStopBitsNum bit_num);
+void UART_SetLineInverse(uint8 uart_no, UART_LineLevelInverse inverse_mask);
+void UART_SetParity(uint8 uart_no, UartParityMode Parity_mode);
+void UART_SetBaudrate(uint8 uart_no, uint32 baud_rate);
+void UART_SetFlowCtrl(uint8 uart_no, UART_HwFlowCtrl flow_ctrl, uint8 rx_thresh);
+void UART_WaitTxFifoEmpty(uint8 uart_no, uint32 time_out_us); //do not use if tx flow control enabled
+void UART_ResetFifo(uint8 uart_no);
+void UART_ClearIntrStatus(uint8 uart_no, uint32 clr_mask);
+void UART_SetIntrEna(uint8 uart_no, uint32 ena_mask);
+void UART_SetPrintPort(uint8 uart_no);
+bool UART_CheckOutputFinished(uint8 uart_no, uint32 time_out_us);
+//==============================================
+
+// Buffer functions
+uint16 rx_buff_deq(char* pdata, uint16 data_len);
+void tx_buff_enq(char* pdata, uint16 data_len);
+
+#endif
+

user/uart_buffer.c

@@ -0,0 +1,259 @@
+//
+// Created by MightyPork on 2017/08/24.
+//
+
+#include "uart_buffer.h"
+#include "uart_driver.h"
+#include "uart_handler.h"
+#include <esp8266.h>
+#include <uart_register.h>
+
+#define UART_TX_BUFFER_SIZE 256  //Ring buffer length of tx buffer
+#define UART_RX_BUFFER_SIZE 512 //Ring buffer length of rx buffer
+
+struct UartBuffer {
+	uint32 UartBuffSize;
+	uint8 *pUartBuff;
+	uint8 *pInPos;
+	uint8 *pOutPos;
+	uint16 Space;
+};
+
+static struct UartBuffer *pTxBuffer = NULL;
+static struct UartBuffer *pRxBuffer = NULL;
+
+static struct UartBuffer *UART_AsyncBufferInit(uint32 buf_size);
+
+void ICACHE_FLASH_ATTR UART_AllocBuffers(void)
+{
+	pTxBuffer = UART_AsyncBufferInit(UART_TX_BUFFER_SIZE);
+	pRxBuffer = UART_AsyncBufferInit(UART_RX_BUFFER_SIZE);
+}
+
+/******************************************************************************
+ * FunctionName : Uart_Buf_Init
+ * Description  : tx buffer enqueue: fill a first linked buffer
+ * Parameters   : char *pdata - data point  to be enqueue
+ * Returns      : NONE
+*******************************************************************************/
+static struct UartBuffer *ICACHE_FLASH_ATTR
+UART_AsyncBufferInit(uint32 buf_size)
+{
+	uint32 heap_size = system_get_free_heap_size();
+	if (heap_size <= buf_size) {
+		error("uart buf malloc fail, out of memory");
+		return NULL;
+	}
+	else {
+		struct UartBuffer *pBuff = (struct UartBuffer *) os_malloc(sizeof(struct UartBuffer));
+		pBuff->UartBuffSize = buf_size;
+		pBuff->pUartBuff = (uint8 *) os_malloc(pBuff->UartBuffSize);
+		pBuff->pInPos = pBuff->pUartBuff;
+		pBuff->pOutPos = pBuff->pUartBuff;
+		pBuff->Space = (uint16) pBuff->UartBuffSize;
+		return pBuff;
+	}
+}
+
+
+/**
+ * Copy data onto Buffer
+ * @param pCur - buffer
+ * @param pdata - data src
+ * @param data_len - data len
+ */
+static void UART_WriteToAsyncBuffer(struct UartBuffer *pCur, const char *pdata, uint16 data_len)
+{
+	if (data_len == 0) return;
+
+	uint16 tail_len = (uint16) (pCur->pUartBuff + pCur->UartBuffSize - pCur->pInPos);
+	if (tail_len >= data_len) {  //do not need to loop back  the queue
+		os_memcpy(pCur->pInPos, pdata, data_len);
+		pCur->pInPos += (data_len);
+		pCur->pInPos = (pCur->pUartBuff + (pCur->pInPos - pCur->pUartBuff) % pCur->UartBuffSize);
+		pCur->Space -= data_len;
+	}
+	else {
+		os_memcpy(pCur->pInPos, pdata, tail_len);
+		pCur->pInPos += (tail_len);
+		pCur->pInPos = (pCur->pUartBuff + (pCur->pInPos - pCur->pUartBuff) % pCur->UartBuffSize);
+		pCur->Space -= tail_len;
+		os_memcpy(pCur->pInPos, pdata + tail_len, data_len - tail_len);
+		pCur->pInPos += (data_len - tail_len);
+		pCur->pInPos = (pCur->pUartBuff + (pCur->pInPos - pCur->pUartBuff) % pCur->UartBuffSize);
+		pCur->Space -= (data_len - tail_len);
+	}
+}
+
+/******************************************************************************
+ * FunctionName : uart_buf_free
+ * Description  : deinit of the tx buffer
+ * Parameters   : struct UartBuffer* pTxBuff - tx buffer struct pointer
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR UART_FreeAsyncBuffer(struct UartBuffer *pBuff)
+{
+	os_free(pBuff->pUartBuff);
+	os_free(pBuff);
+}
+
+u16 ICACHE_FLASH_ATTR UART_AsyncRxCount(void)
+{
+	return (u16) (pRxBuffer->UartBuffSize - pRxBuffer->Space);
+}
+
+/**
+ * Retrieve some data from the RX buffer
+ * @param pdata - target
+ * @param data_len - max data to retrieve
+ * @return real nr of bytes retrieved
+ */
+uint16 ICACHE_FLASH_ATTR
+UART_ReadAsync(char *pdata, uint16 data_len)
+{
+	uint16 buf_len = (uint16) (pRxBuffer->UartBuffSize - pRxBuffer->Space);
+	uint16 tail_len = (uint16) (pRxBuffer->pUartBuff + pRxBuffer->UartBuffSize - pRxBuffer->pOutPos);
+	uint16 len_tmp = 0;
+	len_tmp = ((data_len > buf_len) ? buf_len : data_len);
+	if (pRxBuffer->pOutPos <= pRxBuffer->pInPos) {
+		os_memcpy(pdata, pRxBuffer->pOutPos, len_tmp);
+		pRxBuffer->pOutPos += len_tmp;
+		pRxBuffer->Space += len_tmp;
+	}
+	else {
+		if (len_tmp > tail_len) {
+			os_memcpy(pdata, pRxBuffer->pOutPos, tail_len);
+			pRxBuffer->pOutPos += tail_len;
+			pRxBuffer->pOutPos = (pRxBuffer->pUartBuff +
+								  (pRxBuffer->pOutPos - pRxBuffer->pUartBuff) % pRxBuffer->UartBuffSize);
+			pRxBuffer->Space += tail_len;
+
+			os_memcpy(pdata + tail_len, pRxBuffer->pOutPos, len_tmp - tail_len);
+			pRxBuffer->pOutPos += (len_tmp - tail_len);
+			pRxBuffer->pOutPos = (pRxBuffer->pUartBuff +
+								  (pRxBuffer->pOutPos - pRxBuffer->pUartBuff) % pRxBuffer->UartBuffSize);
+			pRxBuffer->Space += (len_tmp - tail_len);
+		}
+		else {
+			//os_printf("case 3 in rx deq\n\r");
+			os_memcpy(pdata, pRxBuffer->pOutPos, len_tmp);
+			pRxBuffer->pOutPos += len_tmp;
+			pRxBuffer->pOutPos = (pRxBuffer->pUartBuff +
+								  (pRxBuffer->pOutPos - pRxBuffer->pUartBuff) % pRxBuffer->UartBuffSize);
+			pRxBuffer->Space += len_tmp;
+		}
+	}
+	// this maybe shouldnt be here??
+	if (pRxBuffer->Space >= UART_FIFO_LEN) {
+		uart_rx_intr_enable(UART0);
+	}
+	return len_tmp;
+}
+
+//move data from uart fifo to rx buffer
+void UART_RxFifoCollect(void)
+{
+	uint8 fifo_len, buf_idx;
+	uint8 fifo_data;
+	fifo_len = (uint8) ((READ_PERI_REG(UART_STATUS(UART0)) >> UART_RXFIFO_CNT_S) & UART_RXFIFO_CNT);
+	if (fifo_len >= pRxBuffer->Space) {
+		UART_WriteChar(UART1, '%', 100);
+	}
+	else {
+		buf_idx = 0;
+		while (buf_idx < fifo_len) {
+			buf_idx++;
+			fifo_data = (uint8) (READ_PERI_REG(UART_FIFO(UART0)) & 0xFF);
+			*(pRxBuffer->pInPos++) = fifo_data;
+			if (pRxBuffer->pInPos == (pRxBuffer->pUartBuff + pRxBuffer->UartBuffSize)) {
+				pRxBuffer->pInPos = pRxBuffer->pUartBuff;
+			}
+		}
+		pRxBuffer->Space -= fifo_len;
+
+		if (pRxBuffer->Space >= UART_FIFO_LEN) {
+			uart_rx_intr_enable(UART0);
+		}
+	}
+}
+
+/**
+ * Schedule data to be sent
+ * @param pdata
+ * @param data_len - can be -1 for strlen
+ */
+void ICACHE_FLASH_ATTR
+UART_SendAsync(const char *pdata, int16_t data_len)
+{
+	u16 real_len = (u16) data_len;
+	if (data_len <= 0) real_len = (u16) strlen(pdata);
+
+//	if (pTxBuffer == NULL) {
+//		printf("init tx buf\n\r");
+//		pTxBuffer = UART_AsyncBufferInit(UART_TX_BUFFER_SIZE);
+//		if (pTxBuffer != NULL) {
+//			UART_WriteToAsyncBuffer(pTxBuffer, pdata, real_len);
+//		}
+//		else {
+//			printf("tx alloc fail\r\n");
+//		}
+//	}
+//	else {
+		if (real_len <= pTxBuffer->Space) {
+			UART_WriteToAsyncBuffer(pTxBuffer, pdata, real_len);
+		}
+		else {
+			UART_WriteChar(UART1, '^', 100);
+		}
+//	}
+
+	// Here we enable TX empty interrupt that will take care of sending the content
+	SET_PERI_REG_MASK(UART_CONF1(UART0), (UART_TX_EMPTY_THRESH_VAL & UART_TXFIFO_EMPTY_THRHD) << UART_TXFIFO_EMPTY_THRHD_S);
+	SET_PERI_REG_MASK(UART_INT_ENA(UART0), UART_TXFIFO_EMPTY_INT_ENA);
+}
+
+
+//--------------------------------
+static void UART_TxFifoEnq(struct UartBuffer *pTxBuff, uint8 data_len, uint8 uart_no)
+{
+	uint8 i;
+	for (i = 0; i < data_len; i++) {
+		WRITE_PERI_REG(UART_FIFO(uart_no), *(pTxBuff->pOutPos++));
+		if (pTxBuff->pOutPos == (pTxBuff->pUartBuff + pTxBuff->UartBuffSize)) {
+			pTxBuff->pOutPos = pTxBuff->pUartBuff;
+		}
+	}
+	pTxBuff->pOutPos = (pTxBuff->pUartBuff + (pTxBuff->pOutPos - pTxBuff->pUartBuff) % pTxBuff->UartBuffSize);
+	pTxBuff->Space += data_len;
+}
+
+
+/******************************************************************************
+ * FunctionName : TxFromBuffer
+ * Description  : get data from the tx buffer and fill the uart tx fifo, co-work with the uart fifo empty interrupt
+ * Parameters   : uint8 uart_no - uart port num
+ * Returns      : NONE
+*******************************************************************************/
+void UART_DispatchFromTxBuffer(uint8 uart_no)
+{
+	const uint8 tx_fifo_len = (uint8) ((READ_PERI_REG(UART_STATUS(uart_no)) >> UART_TXFIFO_CNT_S) & UART_TXFIFO_CNT);
+	const uint8 fifo_remain = (uint8) (UART_FIFO_LEN - tx_fifo_len);
+	uint8 len_tmp;
+	uint16 data_len;
+
+//	if (pTxBuffer) {
+		data_len = (uint8) (pTxBuffer->UartBuffSize - pTxBuffer->Space);
+		if (data_len > fifo_remain) {
+			len_tmp = fifo_remain;
+			UART_TxFifoEnq(pTxBuffer, len_tmp, uart_no);
+			SET_PERI_REG_MASK(UART_INT_ENA(UART0), UART_TXFIFO_EMPTY_INT_ENA);
+		}
+		else {
+			len_tmp = (uint8) data_len;
+			UART_TxFifoEnq(pTxBuffer, len_tmp, uart_no);
+		}
+//	}
+//	else {
+//		error("pTxBuff null \n\r");
+//	}
+}

user/uart_buffer.h

@@ -0,0 +1,26 @@
+//
+// Created by MightyPork on 2017/08/24.
+//
+
+#ifndef ESP_VT100_FIRMWARE_UART_BUFFER_H
+#define ESP_VT100_FIRMWARE_UART_BUFFER_H
+
+#include <esp8266.h>
+
+// the init func
+void UART_AllocBuffers(void);
+
+// read from rx buffer
+uint16 UART_ReadAsync(char *pdata, uint16 data_len);
+
+// write to tx buffer
+void UART_SendAsync(const char *pdata, int16_t data_len);
+
+//move data from uart fifo to rx buffer
+void UART_RxFifoCollect(void);
+//move data from uart tx buffer to fifo
+void UART_DispatchFromTxBuffer(uint8 uart_no);
+
+u16 UART_AsyncRxCount(void);
+
+#endif //ESP_VT100_FIRMWARE_UART_BUFFER_H

user/uart_driver.c

@@ -84,7 +84,7 @@ bool ICACHE_FLASH_ATTR UART_CheckOutputFinished(UARTn uart_no, uint32 time_out_u
 	uint8 tx_fifo_len;
 
 	while (1) {
-		tx_fifo_len = UART_TxQueLen(uart_no);
+		tx_fifo_len = UART_TxFifoCount(uart_no);
 
 		// TODO If using output circbuf, check if empty
 
@@ -162,7 +162,7 @@ STATUS UART_WriteChar(UARTn uart_no, uint8 c, uint32 timeout_us)
 	uint32 t_s = system_get_time();
 
 	while ((system_get_time() - t_s) < timeout_us) {
-		uint8 fifo_cnt = UART_TxQueLen(uart_no);
+		uint8 fifo_cnt = UART_TxFifoCount(uart_no);
 
 		if (fifo_cnt < UART_TX_FULL_THRESH_VAL) {
 			WRITE_PERI_REG(UART_FIFO(uart_no), c);

user/uart_driver.h

@@ -172,8 +172,8 @@ extern UartDevice UartDev;
 //==============================================
 
 // FIFO used count
-#define UART_TxQueLen(uart_no) ((READ_PERI_REG(UART_STATUS((uart_no))) >> UART_TXFIFO_CNT_S) & UART_TXFIFO_CNT)
+#define UART_TxFifoCount(uart_no) ((READ_PERI_REG(UART_STATUS((uart_no))) >> UART_TXFIFO_CNT_S) & UART_TXFIFO_CNT)
-#define UART_RxQueLen(uart_no) ((READ_PERI_REG(UART_STATUS((uart_no))) >> UART_RXFIFO_CNT_S) & UART_RXFIFO_CNT)
+#define UART_RxFifoCount(uart_no) ((READ_PERI_REG(UART_STATUS((uart_no))) >> UART_RXFIFO_CNT_S) & UART_RXFIFO_CNT)
 
 STATUS UART_WriteCharCRLF(UARTn uart_no, uint8 c, uint32 timeout_us);
 STATUS UART_WriteChar(UARTn uart_no, uint8 c, uint32 timeout_us);

user/uart_handler.c

@@ -14,15 +14,26 @@
 #include <esp8266.h>
 #include "uart_driver.h"
 #include "uart_handler.h"
+#include "uart_buffer.h"
 
 // messy irq/task based UART handling below
 
 static void uart0_rx_intr_handler(void *para);
+
 static void uart_recvTask(os_event_t *events);
+static void uart_processTask(os_event_t *events);
+
+// Those heavily affect the byte loss ratio
+#define PROCESS_CHUNK_LEN 1
+#define FIFO_FULL_THRES 4
 
 #define uart_recvTaskPrio        1
-#define uart_recvTaskQueueLen    10
+#define uart_recvTaskQueueLen    25
 static os_event_t uart_recvTaskQueue[uart_recvTaskQueueLen];
+//
+#define uart_processTaskPrio        0
+#define uart_processTaskQueueLen    25
+static os_event_t uart_processTaskQueue[uart_processTaskQueueLen];
 
 /** Clear the fifos */
 void ICACHE_FLASH_ATTR clear_rxtx(int uart_no)
@@ -50,21 +61,27 @@ void ICACHE_FLASH_ATTR UART_Init(void)
 	UART_ResetFifo(UART0);
 	UART_SetWordLength(UART1, EIGHT_BITS); // debug (output only)
 	UART_ResetFifo(UART1);
+
+	// remainder is configured based on user settings in serial.c
 }
 
 /** Configure Rx on UART0 */
 void ICACHE_FLASH_ATTR UART_SetupAsyncReceiver(void)
 {
+	UART_AllocBuffers();
+
 	// Start the Rx reading task
 	system_os_task(uart_recvTask, uart_recvTaskPrio, uart_recvTaskQueue, uart_recvTaskQueueLen);
+	system_os_task(uart_processTask, uart_processTaskPrio, uart_processTaskQueue, uart_processTaskQueueLen);
+
 	// set handler
 	ETS_UART_INTR_ATTACH((void *)uart0_rx_intr_handler, &(UartDev.rcv_buff)); // the buf will be used as an arg
 
-	// fifo threshold config
+	// fifo threshold config (max: UART_RXFIFO_FULL_THRHD = 127)
-	uint32_t conf = ((100 & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S);
+	uint32_t conf = ((FIFO_FULL_THRES & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S);
 	conf |= ((0x10 & UART_TXFIFO_EMPTY_THRHD) << UART_TXFIFO_EMPTY_THRHD_S);
 	// timeout config
-	conf |= ((0x02 & UART_RX_TOUT_THRHD) << UART_RX_TOUT_THRHD_S); // timeout threshold
+	conf |= ((0x06 & UART_RX_TOUT_THRHD) << UART_RX_TOUT_THRHD_S); // timeout threshold
 	conf |= UART_RX_TOUT_EN; // enable timeout
 	WRITE_PERI_REG(UART_CONF1(UART0), conf);
 
@@ -83,48 +100,80 @@ void ICACHE_FLASH_ATTR UART_SetupAsyncReceiver(void)
 // ---- async receive stuff ----
 
 
-void uart_rx_intr_disable(uint8 uart_no)
-{
-	CLEAR_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA | UART_RXFIFO_TOUT_INT_ENA);
-}
-
-
-void uart_rx_intr_enable(uint8 uart_no)
-{
-	SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA | UART_RXFIFO_TOUT_INT_ENA);
-}
 
+//
+//void ICACHE_FLASH_ATTR UART_PollRx(void)
+//{
+//	uint8 fifo_len = (uint8) UART_GetRxFifoCount(UART0);
+//
+//	for (uint8 idx = 0; idx < fifo_len; idx++) {
+//		uint8 d_tmp = (uint8) (READ_PERI_REG(UART_FIFO(UART0)) & 0xFF);
+//		UART_HandleRxByte(d_tmp);
+//	}
+//}
 
 /**
- * @brief get number of bytes in UART tx fifo
+ * This is the system task handling UART Rx bytes.
- * @param UART number
+ * The function must be re-entrant.
+ *
+ * @param events
  */
-#define UART_GetRxFifoCount(uart_no) ((READ_PERI_REG(UART_STATUS((uart_no))) >> UART_RXFIFO_CNT_S) & UART_RXFIFO_CNT)
+static void uart_recvTask(os_event_t *events)
-
-
-void ICACHE_FLASH_ATTR UART_PollRx(void)
 {
-	uint8 fifo_len = UART_GetRxFifoCount(UART0);
+//#define PROCESS_CHUNK_LEN 64
+//	static char buf[PROCESS_CHUNK_LEN];
 
-	for (uint8 idx = 0; idx < fifo_len; idx++) {
-		uint8 d_tmp = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;
-		UART_HandleRxByte(d_tmp);
-	}
-}
-
-
-static void ICACHE_FLASH_ATTR uart_recvTask(os_event_t *events)
-{
 	if (events->sig == 0) {
-		UART_PollRx();
+		UART_RxFifoCollect();
 
 		// clear irq flags
 		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR | UART_RXFIFO_TOUT_INT_CLR);
 		// enable rx irq again
 		uart_rx_intr_enable(UART0);
-	} else if (events->sig == 1) {
+
+		// Trigger the Reading task
+		system_os_post(uart_processTaskPrio, 5, 0);
+	}
+	else if (events->sig == 1) {
 		// ???
 	}
+//	else if (events->sig == 5) {
+//		// Send a few to the parser...
+//		int bytes = UART_ReadAsync(buf, PROCESS_CHUNK_LEN);
+//		for (uint8 idx = 0; idx < bytes; idx++) {
+//			UART_HandleRxByte(buf[idx]);
+//		}
+//
+//		// ask for another run
+//		if (UART_AsyncRxCount() > 0) {
+//			system_os_post(uart_recvTaskPrio, 5, 0);
+//		}
+//	}
+}
+
+
+/**
+ * This is the system task handling UART Rx bytes.
+ * The function must be re-entrant.
+ *
+ * @param events
+ */
+static void uart_processTask(os_event_t *events)
+{
+	static char buf[PROCESS_CHUNK_LEN];
+
+	if (events->sig == 5) {
+		// Send a few to the parser...
+		int bytes = UART_ReadAsync(buf, PROCESS_CHUNK_LEN);
+		for (uint8 idx = 0; idx < bytes; idx++) {
+			UART_HandleRxByte(buf[idx]);
+		}
+
+		// ask for another run
+		if (UART_AsyncRxCount() > 0) {
+			system_os_post(uart_processTaskPrio, 5, 0);
+		}
+	}
 }
 
 
@@ -153,7 +202,7 @@ uart0_rx_intr_handler(void *para)
 		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR);
 
 		// run handler
-		system_os_post(uart_recvTaskPrio, 0, 0); /* -> notify the polling thread */
+		system_os_post(uart_recvTaskPrio, 0, 1); /* -> notify the polling thread */
 	}
 
 	if (status_reg & UART_RXFIFO_TOUT_INT_ST) {
@@ -167,9 +216,14 @@ uart0_rx_intr_handler(void *para)
 
 	if (status_reg & UART_TXFIFO_EMPTY_INT_ST) {
 		CLEAR_PERI_REG_MASK(UART_INT_ENA(UART0), UART_TXFIFO_EMPTY_INT_ENA);
+		UART_DispatchFromTxBuffer(UART0);
+//		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_TXFIFO_EMPTY_INT_CLR); //- is called by the dispatch func if more data is to be sent.
 	}
 
 	if (status_reg & UART_RXFIFO_OVF_INT_ST) {
 		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_OVF_INT_CLR);
+
+		// overflow error
+		UART_WriteChar(UART1, '!', 100);
 	}
 }

user/uart_handler.h

@@ -21,7 +21,22 @@ void UART_SetupAsyncReceiver(void);
 /** User must provide this func for handling received bytes */
 extern void UART_HandleRxByte(char c);
 
-/** Poll uart manually while waiting for something */
+static inline void uart_rx_intr_disable(uint8 uart_no)
-void UART_PollRx(void);
+{
+	CLEAR_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA | UART_RXFIFO_TOUT_INT_ENA);
+}
+
+static inline void uart_rx_intr_enable(uint8 uart_no)
+{
+	SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA | UART_RXFIFO_TOUT_INT_ENA);
+}
+
+/**
+ * @brief get number of bytes in UART tx fifo
+ * @param UART number
+ */
+static inline u8 UART_GetRxFifoCount(u8 uart_no) {
+	return (u8) ((READ_PERI_REG(UART_STATUS((uart_no))) >> UART_RXFIFO_CNT_S) & UART_RXFIFO_CNT);
+}
 
 #endif

user/user_main.c

@@ -23,7 +23,7 @@
 #include "io.h"
 #include "screen.h"
 #include "routes.h"
-#include "user_main.h"
+#include "version.h"
 #include "uart_driver.h"
 #include "ansi_parser_callbacks.h"
 #include "wifimgr.h"
@@ -113,10 +113,12 @@ void ICACHE_FLASH_ATTR user_init(void)
 	espFsInit((void *) (webpages_espfs_start));
 #endif
 
+#if DEBUG_HEAP
 	// Heap use timer & blink
 	os_timer_disarm(&prHeapTimer);
 	os_timer_setfn(&prHeapTimer, prHeapTimerCb, NULL);
 	os_timer_arm(&prHeapTimer, 1000, 1);
+#endif
 
 	// do later (some functions do not work if called from user_init)
 	os_timer_disarm(&userStartTimer);

user/user_main.h

@@ -1,7 +0,0 @@
-#ifndef USER_MAIN_H_H
-#define USER_MAIN_H_H
-
-#define FIRMWARE_VERSION "0.6.5+" GIT_HASH
-#define TERMINAL_GITHUB_REPO "https://github.com/MightyPork/esp-vt100-firmware"
-
-#endif //USER_MAIN_H_H

user/version.h

@@ -0,0 +1,16 @@
+//
+// Created by MightyPork on 2017/08/20.
+//
+
+#ifndef ESP_VT100_FIRMWARE_VERSION_H
+#define ESP_VT100_FIRMWARE_VERSION_H
+
+#define FW_V_MAJOR 0
+#define FW_V_MINOR 6
+#define FW_V_PATCH 8
+
+#define FIRMWARE_VERSION STR(FW_V_MAJOR) "." STR(FW_V_MINOR) "." STR(FW_V_PATCH) "+" GIT_HASH
+#define FIRMWARE_VERSION_NUM (FW_V_MAJOR*10000 + FW_V_MINOR*100 + FW_V_PATCH) // this is used in ID queries
+#define TERMINAL_GITHUB_REPO "https://github.com/MightyPork/esp-vt100-firmware"
+
+#endif //ESP_VT100_FIRMWARE_VERSION_H

user/wifimgr.c

@@ -43,11 +43,6 @@ wifimgr_restore_defaults(void)
 	IP4_ADDR(&wificonf->sta_addr.ip, 192, 168, 0, (mac[5] == 1 ? 2 : mac[5])); // avoid being the same as "default gw"
 	IP4_ADDR(&wificonf->sta_addr.netmask, 255, 255, 255, 0);
 	IP4_ADDR(&wificonf->sta_addr.gw, 192, 168, 0, 1);
-
-	// DEBUG ONLY - TODO remove for release
-//	wificonf->opmode = STATION_MODE;
-//	sprintf((char*)wificonf->sta_ssid, "Chlivek");
-//	sprintf((char*)wificonf->sta_password, "prase chrochta");
 }
 
 static void ICACHE_FLASH_ATTR
@@ -161,6 +156,8 @@ wifimgr_apply_settings(void)
 {
 	info("[WiFi] Initializing...");
 
+	// !!! Update to current version !!!
+
 	// Force wifi cycle
 	// Disconnect - may not be needed?
 	WIFI_MODE opmode = wifi_get_opmode();

user/wifimgr.h

@@ -17,6 +17,8 @@
 // Must be constant to avoid corrupting user config after upgrade
 #define WIFICONF_SIZE 340
 
+#define WIFICONF_VERSION 0
+
 /**
  * A structure holding all configured WiFi parameters
  * and the active state.
@@ -42,6 +44,7 @@ typedef struct {
 	u8 sta_password[PASSWORD_LEN];
 	bool sta_dhcp_enable;
 	struct ip_info sta_addr;
+	u8 config_version;
 } WiFiConfigBundle;
 
 typedef struct  {