d6
/
pmacs3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

--HG-- 

branch : pmacs2
This commit is contained in:
moculus 2009-03-20 19:41:56 +00:00
parent 03105557a6
commit 18686df3d2
5 changed files with 47 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
method/__init__.py
View File

@ -342,71 +342,6 @@ class UppercaseWord(Method):
w.insert_string(p1, word.upper())
class MetaX(Method):
'''Invoke commands by name'''
args = [arg('method', dt="method", p="M-x ", h='Method to execute')]
name_re = re.compile(r'^ *([a-z0-9_-]+) *(?:\( *\))? *$')
full_re = re.compile(r'^ *([a-z0-9_-]+) *\((.*)\) *$')
arg_re = re.compile(r' *(-?[0-9\.]+|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\\"])*") *')
varg_re = re.compile(r' *([a-zA-Z0-9_]+) *= *(-?[0-9\.]+|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\\"])*") *')
def _execute(self, w, **vargs):
m = self.name_re.match(vargs['method'])
if m:
name2 = m.group(1)
self._sub_execute(w, name2, {})
return
m = self.full_re.match(vargs['method'])
if m:
vargs2 = {}
if '=' in m.group(2):
name2, vargs_str = m.group(1), m.group(2)
i = 0
m = self.varg_re.search(vargs_str, i)
while m:
i = m.end()
vargs2[m.group(1)] = eval(m.group(2))
if i == len(vargs_str):
break
elif vargs_str[i] != ',':
break
else:
i += 1
m = self.varg_re.search(vargs_str, i)
if i == len(vargs_str):
self._sub_execute(w, name2, vargs2)
return
else:
name2, args_str = m.group(1), m.group(2)
i = 0
m = self.arg_re.search(args_str, i)
args = []
while m:
i = m.end()
args.append(eval(m.group(1)))
if i == len(args_str):
break
elif args_str[i] != ',':
break
else:
i += 1
m = self.arg_re.search(args_str, i)
d = {}
try:
meth = w.application.methods[name2]
for (arg, value) in zip(meth.args, args):
vargs2[arg.name] = value
except:
pass
if i == len(args_str):
self._sub_execute(w, name2, vargs2)
return
w.set_error('could not parse argument %r' % vargs['method'])
def _sub_execute(self, w, name, vargs):
if name in w.application.methods:
w.application.methods[name].execute(w, **vargs)
else:
w.set_error('no method named %r found' % name)
class MetaXTwo(MetaX):
args = [arg('method', dt="method", p="M-x ", h='Method to execute')]
name_re = re.compile(r'[a-z0-9_-]+')
@ -485,7 +420,16 @@ class MetaXTwo(MetaX):
else:
args.append(value)
w.set_error("func %r; other %r; args %r; vargs %r" % (func, other, args, vargs))
meth = w.application.methods.get(func)
if meth is None:
w.set_error("method %r not found" % func)
return
try:
for (arg, value) in zip(meth.args, args): vargs[arg.name] = value
except:
w.set_error("4fail")
return
meth.execute(w, **vargs)
class ToggleMargins(Method):
'''Show or hide column margins'''

26
mode/elisp.py
View File

@ -1,8 +1,7 @@
import commands, os.path, string, sys, traceback
import color, completer, default, mode, method, regex, tab
from mode import Fundamental
from point import Point
from lex import Grammar, PatternRule, RegionRule, OverridePatternRule
from mode.lisp import LispTabber
from mode.lisp import Lisp, LispTabber
class StringGrammar(Grammar):
rules = [
@ -15,41 +14,36 @@ class ELispGrammar(Grammar):
rules = [
PatternRule(r'comment', r';.*$'),
PatternRule(r'delimiter', r'[()]'),
PatternRule(r'elisp_reserved', r'(?:nil)(?![a-zA-Z0-9_])'),
PatternRule(r'elisp_keyword', r'(?:while|when|unless|setq-default|setq|require|or|not|mapcar|list|let|lambda|if|exists|equal|defvar|defun|defalias|count|cons|cdr|car|apply|and)(?![a-zA-Z0-9_])'),
PatternRule(r'spaces', r' +'),
PatternRule(r'eol', r'\n'),
PatternRule(r'elisp_reserved', r'(?:t|nil)(?![^\"\' \t()])'),
PatternRule(r'keyword', r'(?:while|when|unless|setq-default|setq|setcar|require|provide|or|not|mapcar|list|let\*|let|lambda|if|exists|equal|defvar|defun|defstruct|defface|defalias|count|cons|c[ad]+r|apply|and)(?![^\"\' \t()])'),
PatternRule(r'elisp_symbol', r"'[a-zA-Z_][a-zA-Z0-9-_]*"),
PatternRule(r'delimiter', r"'"),
PatternRule(r'elisp_type', r":[a-zA-Z_][a-zA-Z0-9-_]*"),
PatternRule(r'attribute', r"&[a-zA-Z_][a-zA-Z0-9-_]*"),
PatternRule(r'bareword', r"[a-zA-Z_][a-zA-Z0-9-_]*"),
PatternRule(r"integer", r"(?<![\.0-9a-zA-Z_])(?:0|-?[1-9][0-9]*|0[0-7]+|0[xX][0-9a-fA-F]+)[lL]?(?![\.0-9a-zA-Z_])"),
PatternRule(r"float", r"(?<![\.0-9a-zA-Z_])(?:[0-9]+\.[0-9]*|\.[0-9]+|(?:[0-9]|[0-9]+\.[0-9]*|\.[0-9]+)[eE][\+-]?[0-9]+)(?![\.0-9a-zA-Z_])"),
PatternRule(r"imaginary", r"(?<![\.0-9a-zA-Z_])(?:[0-9]+|(?:[0-9]+\.[0-9]*|\.[0-9]+|(?:[0-9]|[0-9]+\.[0-9]*|\.[0-9]+)[eE][\+-]?[0-9]+)[jJ])(?![\.0-9a-zA-Z_])"),
PatternRule(r'elisp_word', r"[^\"' \t()]+"),
RegionRule(r'string', r'"', StringGrammar, r'"'),
PatternRule(r'eol', r'\n$'),
]
class ELisp(mode.Fundamental):
class ELisp(Lisp):
name = 'ELisp'
tabwidth = 2
basenames = ['.emacs']
extensions = ['.el']
tabbercls = LispTabber
grammar = ELispGrammar
commentc = ';'
opentokens = ('delimiter',)
opentags = {'(': ')', '[': ']', '{': '}'}
closetokens = ('delimiter',)
closetags = {')': '(', ']': '[', '}': '{'}
colors = {
'elisp_keyword': ('cyan', 'default', 'bold'),
'elisp_reserved': ('blue', 'default', 'bold'),
'elisp_symbol': ('magenta', 'default', 'bold'),
'elisp_type': ('blue', 'default', 'bold'),
}
_bindings = {
'close-paren': (')',),
'close-brace': ('}',),
'close-bracket': (']',),
'elisp_word': ('default', 'default'),
}
install = ELisp.install

16
mode/lisp.py
View File

@ -1,20 +1,21 @@
import commands, os.path, string, sys, traceback
import color, completer, default, mode, method, regex, tab
from point import Point
from lex import Grammar, PatternRule, RegionRule, OverridePatternRule
import regex
from mode import Fundamental
from tab import StackTabber
from lex import Grammar, PatternRule, RegionRule
from mode.python import StringGrammar2
from method import CommentRegion, UncommentRegion
class LispGrammar(Grammar):
rules = [
PatternRule(r'comment', r';.*$'),
PatternRule(r'delimiter', r'[()]'),
PatternRule(r'keyword', r'(?:or|not|list|let\*|let|lambda|if|cons|c[ad]+r|apply|and)(?![^\"\' \t()])'),
PatternRule(r'lisp_word', r"[^\"' \t()]+"),
RegionRule(r'string', r'"', StringGrammar2, r'"'),
PatternRule(r'spaces', r' +'),
PatternRule(r'eol', r'\n'),
]
class LispTabber(tab.StackTabber):
class LispTabber(StackTabber):
wsre = regex.whitespace
wst = ('spaces', 'null', 'eol',)
sre = regex.space
@ -35,11 +36,12 @@ class LispTabber(tab.StackTabber):
self._append(token.string, level)
return currlvl
class Lisp(mode.Fundamental):
class Lisp(Fundamental):
name = 'Lisp'
tabwidth = 2
tabbercls = LispTabber
grammar = LispGrammar
commentc = ';'
opentokens = ('delimiter',)
opentags = {'(': ')'}
closetokens = ('delimiter',)

23
mode/mbox.py
View File

@ -192,21 +192,14 @@ class MboxOpenPath(Method):
class MailListGrammar(Grammar):
rules = [
PatternGroupRule(r'xyz',
r'index', r'^ *[0-9]+',
r'spaces', r' ',
r'flag', r'.',
r'spaces', r' ',
r'month', r'Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec',
#r'dow', r'Mon|Tue|Wed|Thu|Fri|Sat|Sun',
r'spaces', r' +',
r'day', r'[0-9]+',
r'spaces', r' +',
r'sender', r'.{16}',
r'spaces', r' +',
r'size', r'[0-9]+',
r'spaces', ' +',
r'subject', r'.+$'),
PatternGroupRule(
r'xyz', r'index', r'^ *[0-9]+', r'spaces', r' ',
r'flag', r'.', r'spaces', r' ',
r'month', r'Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec',
r'spaces', r' +', r'day', r'[0-9]+', r'spaces', r' +',
r'sender', r'.{16}', r'spaces', r' +', r'size', r'[0-9]+',
r'spaces', ' +', r'subject', r'.+$',
),
]
class MboxMsg(mode.Fundamental):

27
mode/scheme.py
View File

@ -1,14 +1,14 @@
import commands, os.path, string, sys, traceback
import color, completer, default, mode, method, regex, tab
from method import Method
from method.shell import Interact
from point import Point
from lex import Grammar, PatternRule, RegionRule, OverridePatternRule
import mode.lisp
from mode.lisp import StringGrammar2, Lisp, LispTabber
class SchemeGrammar(Grammar):
rules = [
PatternRule(r'comment', r';.*$'),
PatternRule(r'delimiter', r'[()]'),
RegionRule(r'string', r'"', mode.lisp.StringGrammar2, r'"'),
RegionRule(r'string', r'"', StringGrammar2, r'"'),
PatternRule(r'spaces', r' +'),
PatternRule(r'eol', r'\n'),
PatternRule(r'abbrev', r"'|`|,\@|,"),
@ -25,7 +25,7 @@ class SchemeGrammar(Grammar):
PatternRule(r'variable', r'[a-zA-Z!$%&*/:<=>?\^_~][-a-zA-Z0-9!$%&*/:<=>?^_~+.@]*|\+|-|\.\.\.'),
]
class SchemeCheckSyntax(method.Method):
class SchemeCheckSyntax(Method):
'''Check the syntax of a scheme file'''
def _execute(self, w, **vargs):
app = w.application
@ -37,30 +37,23 @@ class SchemeCheckSyntax(method.Method):
else:
app.data_buffer("*Scheme-Check-Syntax*", output)
class GuileStart(method.shell.Interact):
class GuileStart(Interact):
args = []
def _execute(self, w, **vargs):
method.shell.Interact._execute(self, w, bname='*Guile*', cmd='guile')
Interact._execute(self, w, bname='*Guile*', cmd='guile')
class GuileLoadFile(method.shell.Interact):
class GuileLoadFile(Interact):
args = []
def _execute(self, w, **vargs):
method.shell.Interact._execute(self, w, bname='*Guile*', cmd='guile')
Interact._execute(self, w, bname='*Guile*', cmd='guile')
b = w.application.get_buffer_by_name('*Guile*')
path = os.path.realpath(w.buffer.path)
b.pipe_write('(load "%s")\n' % path)
class Scheme(mode.Fundamental):
class Scheme(Lisp):
name = 'Scheme'
extensions = ['.scm']
tabwidth = 2
tabbercls = mode.lisp.LispTabber
grammar = SchemeGrammar
commentc = ';'
opentokens = ('delimiter',)
opentags = {'(': ')'}
closetokens = ('delimiter',)
closetags = {')': '('}
colors = {
'scheme_keyword': ('cyan', 'default', 'bold'),
'scheme_char': ('green', 'default', 'bold'),