Some thoughts about more-smarter-operator

[Adam Jiang]

Hi,

I think there are some natural requirements from programmers on the editor to fill up proper whitespaces around operators like typing 'a+b' should be printed to the buffer as 'a + b'. There is an extension called smart-operator.el could do a part of these jobs. However, when I tried it out with my emacs, it failed to me frequently in cc-mode. I have documented these failure to

http://www.emacswiki.org/emacs/SmartOperator

I also tried to fix these problems. But, finally, my head got shocked when I tried to mimic some code in autopair.el. It seems that smart-operator.el is not smart enough because it doesn't use any syntax analysis result which could be supported by emacs from the beginning. 'smart-operator.el' has to be customized for each languages for its determinative facts are heavily depends on regexs which is proceeding operators. The basic logics in 'smart-operator.el' look like

''''' pseudo code
if (in c-buffer)
   if (looking-back "PATTERN1")
       insert-whitespaces-as-wrapper OPERATOR
   else if (looking-back "PATTERN2")
       insert-whitespaces-only-behind OPERATOR
   else if (looking-back "PATTERN3")
       insert-whitespaces-only-front OPERATOR
   else
       insert-whitespaces-none OPERATOR

Actually, I think the conditions could not rely on PATTERNS but OPERATORS for each major-mode. Then, we can simplify the code for insertion. Here is the situation.

There is no way to figure out what is an operator with emacs' syntax-table. (I am not sure about this, if there was, please let me know). However, an operator is an element in the superset of one of the subsets of 'punctuator'. For example, with cc-mode, we have punctuators in syntax-table

'*', '%', '/', '+', '-', ...

then, operators could be listed in cc-mode would be 

'*' - binary operator for multiplication
'*' - unary operator for get value in a point
'*' - delimiter for point declaration
'**' - a point to point
'****' - a point to point to point to point
'*=' - assignment after multiplication
etc.

If there was a way to describe what kind of strings could be an operator for each major-mode, then, I can introduce some rules based on the assertion to address the same problem that smart-operator wanted to solve, like

- remap keybindings to 'puncuators' to a handler
- in the handler,

if ('puncuator' is in 'operator-list')
    if (concat last-N-charactors-before-current-position value-of-curent-positon) is in 'operator-list')
       (back-to-previous position
        delete-whitespace
        call 'handler recursively)
    if 'operator' is unray
        insert whitespaces before ;;; like char *a;
    else if 'operator' is binary ;;; '?' ':' could be considered as binary operators
        insert whitespaces wrapper ;;; like c = a * b;
else
    insert 'puncuator' ;;;

backspace, and RET(puncuator) should be solved specially as well.

There are some merits which the current smart-operator.el could not provide.

- solve the problem by more generic way
- easy to be customized; define a list of operators in regex to each major-mode

I would like to do this, but, now, the biggest problem for me is that I am not very familiar with elisp. SAD... is anyone interesting in implementing the code in elisp? Do you have any comments on the analysis?

Best regards,
/Adam