Skip to content
Browse files

Version 1.0: Initial upload

  • Loading branch information...
0 parents commit d7e69740fa9966570c79bc458332ad57708c5b7c @sunsol sunsol committed with
3 README
@@ -0,0 +1,3 @@
+This is a mirror of http://www.vim.org/scripts/script.php?script_id=4303
+
+https://raw.github.com/sunsol/custom_dict/master/demo.gif
BIN demo.gif
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
648 dicts/python.PIL.zh_CN.dict
@@ -0,0 +1,648 @@
++-*/PIL p
++-*/+-*/Image p 图像核心模块
+坐标体系:(0,0)是左上角
++-*/+-*/+-*/FLIP_LEFT_RIGHT d 左右翻转
++-*/+-*/+-*/FLIP_TOP_BOTTOM d 上下翻转
++-*/+-*/+-*/ROTATE_90 d 逆时针旋转90度
++-*/+-*/+-*/ROTATE_180 d 旋转180度
++-*/+-*/+-*/ROTATE_270 d 顺时针旋转90度
++-*/+-*/+-*/NEAREST d 近邻模式
++-*/+-*/+-*/BILINEAR d 双线性模式
++-*/+-*/+-*/BICUBIC d 双三次模式
++-*/+-*/+-*/ANTIALIAS d 平滑模式
++-*/+-*/+-*/EXTENT d 剪切矩形变换
++-*/+-*/+-*/AFFINE d 仿射变换
++-*/+-*/+-*/QUAD d 四边形变换,原图四边形->新图
++-*/+-*/+-*/MESH d 四边形变换,原图->新图四边形
++-*/+-*/+-*/new f 创建新的image对象
+Image.new(mode, size) => image
+Image.new(mode, size, color) => image
+ mode: 字符串
+ 1 1位黑白图像,1个字节1个像素
+ L 8位灰度图像
+ P 8位调色板图像
+ RGB 24位彩色图像
+ RGBA 24位彩色带透明通道图像
+ CMYK 32位印刷图像
+ YCbCr 24位视频格式图像
+ I 像素为32位有符号整数
+ F 像素为32位浮点数
+ LA 8位带通道灰度图像
+ RGBX RGBa
+ size: 2元素元组(宽,高)
+ color: 字符串,填充色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
+ 如设为None图像将不初始化,默认填满黑色0
++-*/+-*/+-*/open f 由图像文件生成image对象
+Image.open(infile) => image
+Image.open(infile, mode) => image
+ infile: 文件名或文件对象
+ mode: 字符串
+ 1 1位黑白图像,1个字节1个像素
+ L 8位灰度图像
+ P 8位调色板图像
+ RGB 24位彩色图像
+ RGBA 24位彩色带透明通道图像
+ CMYK 32位印刷图像
+ YCbCr 24位视频格式图像
+ I 像素为32位有符号整数
+ F 像素为32位浮点数
+ LA 8位带通道灰度图像
+ RGBX RGBa
+打开时并没有马上读取数据
++-*/+-*/+-*/blend f 使用透明度参数合成图像为新的image对象
+Image.blend(image1, image2, alpha) => image
+ 相当于 out = image1 * (1.0 - alpha) + image2 * alpha
+ 两个图像大小要一样
++-*/+-*/+-*/composite f 使用蒙版合成两个图像为新的image对象
+Image.composite(image1, image2, mask) => image
+ mask: "1", "L","RGBA"模式蒙板图像
+ 三个图像大小要一样
++-*/+-*/+-*/eval f 对图像的每个像素作处理生成新的image对象
+Image.eval(image, function) => image
++-*/+-*/+-*/frombuffer f 由数据生成image对象
+Image.frombuffer(mode, size, data) => image
+Image.frombuffer(mode, size, data, decoder, parameters) => image
+ im = Image.frombuffer(mode, size, data, "raw", mode, 0, 1)
+ 支持图像内存共享的模式有"L","RGBX","RGBA","CMYK"
++-*/+-*/+-*/fromstring f 由字符串像素数据生成image对象
+Image.fromstring(mode, size, data) => image
+Image.fromstring(mode, size, data, decoder, parameters) => image
++-*/+-*/+-*/merge f 组合多个通道为一个新的图像
+Image.merge(mode, bands) => image
+ mode描述的是图像格式,bands多个图像将按mode给出的方式作为各通道来组合成图像
+ 所有bands大小必须相同
+ mode: 字符串
+ 1 1位黑白图像,1个字节1个像素
+ L 8位灰度图像
+ P 8位调色板图像
+ RGB 24位彩色图像
+ RGBA 24位彩色带透明通道图像
+ CMYK 32位印刷图像
+ YCbCr 24位视频格式图像
+ I 像素为32位有符号整数
+ F 像素为32位浮点数
+ LA 8位带通道灰度图像
+ RGBX RGBa
++-*/+-*/+-*/Image c 图像类
++-*/+-*/+-*/+-*/convert m 转换模式生成新的image对象
+im.convert(mode) => image
+im.convert(mode, matrix) => image
+ rgb2xyz = (
+ 0.412453, 0.357580, 0.180423, 0,
+ 0.212671, 0.715160, 0.072169, 0,
+ 0.019334, 0.119193, 0.950227, 0 )
+ RGB图像可使用矩阵转换为新的RGB或灰阶图像
+ out = im.convert("RGB", rgb2xyz)
+ mode: 字符串
+ 1 1位黑白图像,1个字节1个像素
+ L 8位灰度图像
+ P 8位调色板图像
+ RGB 24位彩色图像
+ RGBA 24位彩色带透明通道图像
+ CMYK 32位印刷图像
+ YCbCr 24位视频格式图像
+ I 像素为32位有符号整数
+ F 像素为32位浮点数
+ LA 8位带通道灰度图像
+ RGBX RGBa
++-*/+-*/+-*/+-*/copy m 复制一个image对象
+im.copy() => image
++-*/+-*/+-*/+-*/crop m 裁剪图像生成一个新的image对象
+im.crop(box) => image
+ box: 裁剪矩形的4元组(左,上,右,下)
++-*/+-*/+-*/+-*/draft m 配置加载图像的方式
+im.draft(mode, size)
+ 如果图像已加载则没有效果
++-*/+-*/+-*/+-*/filter m 使用滤镜生成新的image对象
+im.filter(filter) => image
+ filter:
+ ImageFilter.BLUR 模糊滤镜
+ ImageFilter.CONTOUR 轮廓滤镜
+ ImageFilter.DETAIL 清晰滤镜
+ ImageFilter.EDGE_ENHANCE 边界加强
+ ImageFilter.EDGE_ENHANCE_MORE 边界加强(阀值更大)
+ ImageFilter.EMBOSS 浮雕滤镜
+ ImageFilter.FIND_EDGES 边界滤镜
+ ImageFilter.SMOOTH 平滑滤镜
+ ImageFilter.SMOOTH_MORE 平滑滤镜(阀值更大)
+ ImageFilter.SHARPEN 锐化滤镜
++-*/+-*/+-*/+-*/fromstring m 从数据加载图像
+im.fromstring(data)
+im.fromstring(data, decoder, parameters)
++-*/+-*/+-*/+-*/getbands m 获得各通道的名称
+im.getbands() => tuple of strings
+ 例如RGB图像将返回("R", "G", "B").
++-*/+-*/+-*/+-*/getbbox m 计算能容下实际图像的方形位置
+im.getbbox() => 4-tuple or None
+ 返回矩形的4元组(左,上,右,下)
++-*/+-*/+-*/+-*/getcolors m 统计颜色数量
+im.getcolors() => a list of (count, color) tuples or None
+im.getcolors(maxcolors) => a list of (count, color) tuples or None
+ maxcolors: 如颜色的数量超过此值将停止计算返回None
++-*/+-*/+-*/+-*/getdata m 获取图像数据,像素数据按行生成
+im.getdata() => sequence
++-*/+-*/+-*/+-*/getextrema m 获取图像最小和最大的值
+im.getextrema() => 2-tuple
+ 只适用'L'图像
++-*/+-*/+-*/+-*/getpixel m 获取某点的像素
+im.getpixel(xy) => value or tuple
+ xy: (x,y)
+ 如果图像是多层的图像,将返回元组
++-*/+-*/+-*/+-*/histogram m 获取图像的灰度直方图
+im.histogram() => list
+im.histogram(mask) => list
+ mask 蒙板图像,必须是"1"或"L"模式同大小图,用以筛选像素
++-*/+-*/+-*/+-*/load m 加载图像(一般不需要,会自动加载)
+ 返回图像数据对象,对此对象操作速度会快于getpixel和putpixel
+ pix = im.load()
+ print pix[x, y]
+ pix[x, y] = value
++-*/+-*/+-*/+-*/paste m 将另一图像粘贴到此图像里
+im.paste(image, box)
+ box: 粘贴位置矩形的4元组(左,上,右,下),另一图像的大小需符合此矩形
+ 或者是粘贴位置的左上角坐标(x,y)
+ 或者是None(0,0)
+im.paste(image, box, mask)
+ mask: alpha混合系数
+im.paste(colour, box)
+ colour: 是填充色,0是黑色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
+im.paste(colour, box, mask)
++-*/+-*/+-*/+-*/point m 转换像素生成新的image对象
+im.point(table) => image
+im.point(function) => image
+ out = im.point(lambda i: i * 1.2 + 10)
+im.point(table, mode) => image
+im.point(function, mode) => image
++-*/+-*/+-*/+-*/putalpha m 存入新的透明通道
+im.putalpha(band)
+ 图像必须是RGBA或LA模式,band必须是'L'或'1'模式
++-*/+-*/+-*/+-*/putdata m 更改数据
+im.putdata(data)
+im.putdata(data, scale, offset)
+ scale,offset为校正系数
+ pixel = value * scale + offset
++-*/+-*/+-*/+-*/putpalette m 存入调色板
+im.putpalette(sequence)
+ sequence调色板序列,长度必须是768
++-*/+-*/+-*/+-*/putpixel m 更新某点像素颜色
+im.putpixel(xy, colour)
+ xy: (x,y)
+ color: 字符串,填充色,0是黑色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
+ 如果是批量数据,使用下面方法比较快
+ pix = im.load()
+ for i in range(n):
+ ...
+ pix[x, y] = value
++-*/+-*/+-*/+-*/resize m 改变图像大小生成新的image对象
+im.resize(size) => image
+im.resize(size, filter) => image
+ filter:
+ Image.NEAREST 近邻模式
+ Image.BILINEAR 双线性模式
+ Image.BICUBIC 双三次模式
+ Image.ANTIALIAS 平滑模式
+ size: 2元素元组(宽,高)
++-*/+-*/+-*/+-*/rotate m 逆时针旋转图像生成新的image对象
+im.rotate(angle) => image
+im.rotate(angle, filter=NEAREST, expand=0) => image
+ angle: 角度
+ filter:
+ Image.NEAREST 近邻模式
+ Image.BILINEAR 双线性模式
+ Image.BICUBIC 双三次模式
+ Image.ANTIALIAS 平滑模式
+ expand: 如果为真,会自动扩大图像以容下旋转的图像
++-*/+-*/+-*/+-*/save m 保存图像
+im.save(outfile, options...)
+im.save(outfile, format, options...)
+ outfile: 文件名或文件对象,可自动根据后缀识别要保存的格式
+ format: 字符串
+ GIF 保存格式为GIF87a
+ BMP JPEG PCX PNG PPM TIFF XBM PDF
++-*/+-*/+-*/+-*/seek m 定位到某一帧
+im.seek(frame)
++-*/+-*/+-*/+-*/show m 显示图像
+im.show()
+ 在unix下需有xv程式
++-*/+-*/+-*/+-*/split m 按通道生成多个image对象
+im.split() => sequence
+ 例如RGB图像将生成三个颜色通道的灰阶图像
++-*/+-*/+-*/+-*/tell m 当前帧号
+im.tell() => integer
++-*/+-*/+-*/+-*/thumbnail m 修改自身图像为缩略图
+im.thumbnail(size)
+im.thumbnail(size, filter)
+ filter:
+ Image.NEAREST 近邻模式
+ Image.BILINEAR 双线性模式
+ Image.BICUBIC 双三次模式
+ Image.ANTIALIAS 平滑模式
++-*/+-*/+-*/+-*/tobitmap m 转换图像为X11图像数据
+im.tobitmap() => string
++-*/+-*/+-*/+-*/tostring m 获取图像的像素数据
+im.tostring() => string
+im.tostring(encoder, parameters) => string
++-*/+-*/+-*/+-*/transform m 变换图像生成新的image对象
+im.transform(size, method, data) => image
+im.transform(size, method, data, filter) => image
+ size: 新图像大小(宽,高)
+ filter:
+ Image.NEAREST 近邻模式
+ Image.BILINEAR 双线性模式
+ Image.BICUBIC 双三次模式
+ Image.ANTIALIAS 平滑模式
+ method:
+ Image.EXTENT 剪切矩形
+ data: 裁剪矩形的4元组(左,上,右,下)
+ 此方法和crop不同的是可以拉伸缩小剪切图像
+ Image.AFFINE 仿射变换
+ data: 仿射矩阵的前两行的6个参数元组(a,b,c,d,e,f)
+ 对像素(x,y)作(ax+by+c,dx+ey+f)变化
+ 可用于缩放,平移,旋转
+ Image.QUAD 四边形变换,原图像里四边形导出到新图像
+ data: 图像里要被提取的四边形的四个顶点的8元组
+ (x0,y0,x1,y1,x2,y2,x3,y3)
+ 顺序为左上角,左下角,右下角,右上角逆时针方向
+ Image.MESH 四边形变换,原图像映射到新图像里的四边形上
+ data: 图像要被映射成的四边形的四个顶点的8元组
+ (x0,y0,x1,y1,x2,y2,x3,y3)是新图像里的坐标
+ 顺序为左上角,左下角,右下角,右上角逆时针方向
++-*/+-*/+-*/+-*/transpose m 旋转图像生成新的image对像
+im.transpose(method) => image
+ method:
+ Image.FLIP_LEFT_RIGHT 左右翻转
+ Image.FLIP_TOP_BOTTOM 上下翻转
+ Image.ROTATE_90 逆时针旋转90度
+ Image.ROTATE_180 旋转180度
+ Image.ROTATE_270 顺时针旋转90度
++-*/+-*/+-*/+-*/verify m 检验图像文件是否损坏
+im.verify()
+ 如在使用此函数后要读取图像数据,必须重新打开图像文件
+ 如检验发现错误,将抛出异常
++-*/+-*/+-*/+-*/format d 图像文件格式(字符串如JPEG)
++-*/+-*/+-*/+-*/mode d 图像模式(字符串)
+ 1 1位黑白图像,1个字节1个像素
+ L 8位灰度图像
+ P 8位调色板图像
+ RGB 24位彩色图像
+ RGBA 24位彩色带透明通道图像
+ CMYK 32位印刷图像
+ YCbCr 24位视频格式图像
+ I 像素为32位有符号整数
+ F 像素为32位浮点数
+ LA 8位带通道灰度图像
+ RGBX RGBa
++-*/+-*/+-*/+-*/size d 图像大小(宽,高)二元组
++-*/+-*/+-*/+-*/palette d 调色板
++-*/+-*/+-*/+-*/info d 图像有关信息(字典)
+info
+ FLI duration保存帧间隔的毫秒数
+ FLC duration保存帧间隔的毫秒数
+ GIF background默认背景色
+ duration保存帧间隔的毫秒数
+ transparency透明色
+ version是GIF87a或GIF89a
+ PNG gamma
+ transparency透明色(保存时可用)
+ optimize是否压缩(保存时可用)
+ bits像素位数(保存时可用)
+ JPEG jfif标志
+ adobe标志
+ progression是否渐进变化(保存时可用)
+ quality图像质量1-95,默认75(保存时可用)
+ optimize是否优化(保存时可用)
+ dpi二元组通常为(96,96)
+ exif附加信息
++-*/+-*/ImagePath p 图像路经模块
++-*/+-*/+-*/Path f 创建路径对象
+ImagePath.Path(coordinates)
+ coordinates 可以是坐标(x,y)序列,也可以是数字序列(x0,y0,x1,y1..)
++-*/+-*/+-*/+-*/compact m 简化路经,消除重复点
+p.compact(distance=2) -> count
+ distance 小于此距离的点将合并为一个点
+ 返回路径上的点数目
++-*/+-*/+-*/+-*/getbbox m 获取容来路径的最小矩形
+p.getbbox() -> 4-tuple
+ 返回4元组(左,上,右,下)
++-*/+-*/+-*/+-*/map m 对路径节点作处理
+p.map(function)
++-*/+-*/+-*/+-*/tolist m 生成点列表
+p.tolist() -> list
+p.tolist(flat=0) -> list
+ flat如为1则返回(x0,y0,x1,y1,..)否则返回((x0,y0),(x1,y1),..)
++-*/+-*/+-*/+-*/transform m 矩阵变换
+p.transform(matrix)
+ matrix (a, b, c, d, e, f)
+ xOut = xIn * a + yIn * b + c
+ yOut = xIn * d + yIn * e + f
++-*/+-*/ImageChops p 图像颜色混合模块
+只支持'L'或'RGB'模式的图像
++-*/+-*/+-*/constant f 根据给定像素数值填充生成同大小的图像
+ImageChops.constant(image, value) => image
++-*/+-*/+-*/duplicate f 复制图像生成新的image对象
+ImageChops.duplicate(image) => image
++-*/+-*/+-*/invert f 对图像反色处理,生成新的image对象
+ImageChops.invert(image) => image
++-*/+-*/+-*/lighter f 混合两个图像,使用变亮模式,生成新的image对象
+ImageChops.lighter(image1, image2) => image
+ out = max(image1,image2)
++-*/+-*/+-*/darker f 混合两个图像,使用变暗模式,生成新的image对象
+ImageChops.darker(image1, image2) => image
+ out = min(image1,image2)
++-*/+-*/+-*/difference f 混合两个图像,使用差值模式(常用于找不同)
+ImageChops.difference(image1, image2) => image
+ out = abs(image1 - image2)
++-*/+-*/+-*/multiply f 混合两个图像,使用相乘模式(也叫正片叠底或复合模式)
+ImageChops.multiply(image1, image2) => image
+ out = image1 * image2 / MAX
+ 画图时常用的模式
++-*/+-*/+-*/screen f 混合两个图像,使用掩蔽模式(也叫滤色模式或屏幕模式)
+ImageChops.screen(image1, image2) => image
+ out = MAX - ((MAX - image1) * (MAX - image2) / MAX)
++-*/+-*/+-*/add f 混合两个图像,使用相加模式(常用于通道处理)
+ImageChops.add(image1, image2, scale, offset) => image
+ scale 缩放因子,默认为1.0 offset 补偿值,默认为0.0
+ out = (image1 + image2) / scale + offset
++-*/+-*/+-*/subtract f 混合两个图像,使用减去模式(常用于通道处理)
+ImageChops.subtract(image1, image2, scale, offset) => image
+ scale 缩放因子,默认为1.0 offset 补偿值,默认为0.0
+ out = (image1 - image2) / scale + offset
++-*/+-*/+-*/blend f 使用透明度参数合成图像为新的image对象
+ImageChops.blend(image1, image2, alpha) => image
+ 相当于 out = image1 * (1.0 - alpha) + image2 * alpha
++-*/+-*/+-*/composite f 使用蒙版合成两个图像为新的image对象
+ImageChops.composite(image1, image2, mask) => image
+ mask: "1", "L","RGBA"模式蒙板图像
++-*/+-*/+-*/offset f 移动图像生成新的image对象
+ImageChops.offset(xoffset, yoffset) => image
+ xoffset,yoffset为偏移距离,如未给yoffset则认为yoffset等于xoffset
++-*/+-*/ImageEnhance p 图像调整模块
++-*/+-*/+-*/Color c 颜色调整器(类似彩电的色彩调整)
+ImageEnhance.Color(image)
++-*/+-*/+-*/+-*/enhance m 按参数对图像作色彩调整生成新的image对象
+enhancer.enhance(factor) => image
+ factor 调整系数 1.0即原图像,0.0为黑白图像,大于1色彩越鲜艳
++-*/+-*/+-*/Brightness c 亮度调整器
+ImageEnhance.Brightness(image)
++-*/+-*/+-*/+-*/enhance m 按参数对图像作明暗调整生成新的image对象
+enhancer.enhance(factor) => image
+ factor 调整系数 1.0即原图像,0.0为纯黑图像,大于1图像越亮
++-*/+-*/+-*/Contrast c 对比度调整器
+ImageEnhance.Contrast(image)
++-*/+-*/+-*/+-*/enhance m 按参数对图像作对比度调整生成新的image对象
+enhancer.enhance(factor) => image
+ factor 调整系数 1.0即原图像,0.0为纯灰色图像,大于1图像对比度越强
++-*/+-*/+-*/Sharpness c 锐度调整器
+ImageEnhance.Sharpness(image)
++-*/+-*/+-*/+-*/enhance m 按参数对图像作锐度调整生成新的image对象
+enhancer.enhance(factor) => image
+ factor 调整系数 1.0即原图像,0.0为模糊图像,2.0为锐利图像
++-*/+-*/ImageFilter p 滤镜模块
++-*/+-*/+-*/BLUR c 模糊滤镜
++-*/+-*/+-*/CONTOUR c 轮廓滤镜
++-*/+-*/+-*/DETAIL c 清晰滤镜
++-*/+-*/+-*/EDGE_ENHANCE c 边界加强
++-*/+-*/+-*/EDGE_ENHANCE_MORE c 边界加强(阀值更大)
++-*/+-*/+-*/EMBOSS c 浮雕滤镜
++-*/+-*/+-*/FIND_EDGES c 边界滤镜
++-*/+-*/+-*/SMOOTH c 平滑滤镜
++-*/+-*/+-*/SMOOTH_MORE c 平滑滤镜(阀值更大)
++-*/+-*/+-*/SHARPEN c 锐化滤镜
++-*/+-*/+-*/Kernel c
+TODO:
+Kernel(size, kernel, scale=None, offset=0)
+
+(New in 1.1.5) Create a convolution kernel of the given size. In the current version, the size must be either (3, 3) or (5, 5), and the kernel argument must be a sequence containing 9 or 25 integer or floating point weights.
+
+If the scale argument is given, the result of applying the kernel to each pixel is divided by the scale value. The default is the sum of the kernel weights.
+
+If the offset argument is given, the value is added to the result, after it has been divided by the scale.
++-*/+-*/+-*/RankFilter c
+TODO:
+RankFilter(size, rank)
+
+(New in 1.1.5) Create a rank filter of the given size. For each pixel in the input image, the rank filter sorts all pixels in a (size, size) environment by pixel value, and copies the rank'th value to the output image.
++-*/+-*/+-*/MinFilter c
+TODO:
+MinFilter(size=3)
+
+(New in 1.1.5) Create a min filter of the given size. For each pixel in the input image, this filter copies the smallest pixel value from a (size, size) environment to the output image.
++-*/+-*/+-*/MedianFilter c
+TODO:
+MedianFilter(size=3)
+
+(New in 1.1.5) Create a median filter of the given size. For each pixel in the input image, this filter copies the median pixel value from a (size, size) environment to the output image.
++-*/+-*/+-*/MaxFilter c
+TODO:
+MaxFilter(size=3)
+
+(New in 1.1.5) Create a max filter of the given size. For each pixel in the input image, this filter copies the largest pixel value from a (size, size) environment to the output image.
++-*/+-*/+-*/ModeFilter c
+TODO:
+ModeFilter(size=3)
+
+(New in 1.1.5) Create a mode filter of the given size. For each pixel in the input image, this filter copies the most common pixel value in a (size, size) environment to the output image. If no pixel value occurs more than once, the original pixel value is used.
++-*/+-*/ImageStat p 图像数据统计模块
++-*/+-*/+-*/Stat c 图像数据统计类
+ImageStat.Stat(image) => Stat instance
+ImageStat.Stat(image, mask) => Stat instance
+ mask 蒙板,如给出将只计算蒙板所包括的像素
+ 值计算将各通道分别计算返回结果为列表
++-*/+-*/+-*/+-*/extrema d 极值min/max
++-*/+-*/+-*/+-*/count 数量
++-*/+-*/+-*/+-*/sum d 和
++-*/+-*/+-*/+-*/sum2 d 平方和
++-*/+-*/+-*/+-*/mean d 平均值
++-*/+-*/+-*/+-*/median d 中值
++-*/+-*/+-*/+-*/rms d 平方平均数
++-*/+-*/+-*/+-*/var d 方差
++-*/+-*/+-*/+-*/stddev d 标准偏差
++-*/+-*/ImageGrab p 屏幕截图模块(只用于windows)
++-*/+-*/+-*/grab f 截取屏幕生成新图像
+ImageGrab.grab() => image
+ImageGrab.grab(bbox) => image
+ bbox: 截取矩形的4元组(左,上,右,下)
++-*/+-*/+-*/grabclipboard f 获取剪贴板里的图像
+ImageGrab.grabclipboard() => image or list of strings or None
+ 返回结果可能是图像,也可能是文件名列表或None
+ 可以使用isinstance来测试返回结果
+im = ImageGrab.grabclipboard()
+if isinstance(im, Image.Image):
+ ... got an image ...
+elif im:
+ for filename in im:
+ try:
+ im = Image.open(filename)
+ except IOError:
+ pass # ignore this file
+ else:
+ ... got an image ...
+else:
+ ... clipboard empty ...
++-*/+-*/ImageFont p 绘图所用字体模块
+PIL有自设的字体格式,可以使用pilfont工具转换BDF和PCF字体(X系统使用)为pil格式
+PIL还支持TrueType(ttf)格式的字体
++-*/+-*/+-*/load f 加载pil格式字体文件返回字体对象
+ImageFont.load(file) => Font instance
++-*/+-*/+-*/load_path f 在sys.path里搜索pil格式字体文件加载返回字体对象
+ImageFont.load_path(file) => Font instance
++-*/+-*/+-*/truetype f 加载ttf格式字体文件返回字体对象
+ImageFont.truetype(file, size) => Font instance
+ImageFont.truetype(file, size, encoding=value) => Font instance
+ size 字体大小
+ encoding 编码方式
+ "unic" (Unicode)
+ "symb" (Microsoft Symbol)
+ "ADOB" (Adobe Standard)
+ "ADBE" (Adobe Expert)
+ "armn" (Apple Roman).
+ 在windows下会在系统字体目录搜索file
++-*/+-*/+-*/load_default f 加载默认字体返回字体对象
++-*/+-*/+-*/ImageFont c
++-*/+-*/+-*/+-*/getsize m 获取容纳文本的面积(宽,高)
+font.getsize(text) => (width, height)
++-*/+-*/+-*/+-*/getmask m 由文本生成新图像
+font.getmask(text, mode="") => Image object
+ 如果字体是抗锯齿的一般mode为'L',其它为'1'
++-*/+-*/ImageColor p 颜色模块
++-*/+-*/+-*/getrgb f 解析颜色字符串返回(红,绿,兰)三元组
+getrgb(color) => (red, green, blue)
+ color: 字符串
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
+ 如不符合以上则报错
++-*/+-*/+-*/getcolor f 按给定模式获取颜色返回(红,绿,兰)三元组或数值
+getcolor(color, mode) => (red, green, blue) or integer
++-*/+-*/ImageDraw p 绘图模块
++-*/+-*/+-*/Draw f 由图像创建一个用以绘图的对象
+Draw(image) => Draw instance
++-*/+-*/+-*/+-*/arc m 画一条圆弧
+draw.arc(xy, start, end, fill=None)
+ xy: 能容纳弧线所在椭圆的矩形范围(左,上,右,下)
+ start: 起始角度
+ end: 结束角度,要画一个椭圆start为0,end为360
+ fill: 指定颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/bitmap m 画上另一个图像
+draw.bitmap(xy, bitmap, fill=None)
+ xy: 绘画位置矩形的4元组(左,上,右,下),另一图像的大小需符合此矩形
+ 或者是绘画位置的左上角坐标(x,y)
+ bitmap:一个image图像,必须是'1','L','RGBA'三种模式之一
+ fill: 指定颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
+ 如果是要纯粘贴图像可使用image.paste
++-*/+-*/+-*/+-*/chord m 画一条弧线(封闭)
+draw.chord(xy, start, end, fill=None, outline=None)
+ xy: 能容纳弧线所在椭圆的矩形范围(左,上,右,下)
+ start: 起始角度
+ end: 结束角度,要画一个椭圆start为0,end为360
+ fill: 指定填充颜色,如不给出则只画线
+ outline:指定线的颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/ellipse m 画椭圆
+draw.ellipse(xy, fill=None, outline=None)
+ xy: 能容纳椭圆的矩形范围(左,上,右,下)
+ fill: 指定填充颜色,如不给出则只画线
+ outline:指定线的颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/line m 画直线
+draw.line(xy, fill=None, width=1)
+ xy: 连接点坐标序列,可以是((x0,y0),(x1,y1),..)形式
+ 或(x0,y0,x1,y1,...),至少两个点,将依次画上之间的直线
+ width: 线的宽度
+ fill: 指定颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/pieslice m 画扇形(就像吃豆子里的那个形状)
+draw.pieslice(xy, start, end, fill=None, outline=None)
+ xy: 能容纳扇形上弧线所在椭圆的矩形范围(左,上,右,下)
+ start: 起始角度
+ end: 结束角度
+ fill: 指定填充颜色,如不给出则只画线
+ outline:指定线的颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/point m 画点
+draw.point(xy, fill=None)
+ xy: 点坐标序列,可以是((x0,y0),(x1,y1),..)形式
+ 或(x0,y0,x1,y1,...),可以多个点
+ fill: 指定颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/polygon m 画多边形
+draw.polygon(xy, fill=None, outline=None)
+ xy: 顶点坐标序列,可以是((x0,y0),(x1,y1),..)形式
+ 或(x0,y0,x1,y1,...),至少三个点
+ fill: 指定填充颜色,如不给出则只画线
+ outline:指定线的颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/rectangle m 画矩形
+draw.rectangle(box, fill=None, outline=None)
+ xy: 左上角点坐标和右下角点坐标,可以是((x0,y0),(x1,y1))形式
+ 或(x0,y0,x1,y1)
+ fill: 指定填充颜色,如不给出则只画线
+ outline:指定线的颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/text m 画文本
+draw.text(position, string, fill=None, font=None, anchor=None)
+ position: 文本开始的左上角点坐标(x,y)
+ font: 指定的imagefont对象
+ string: 一般使用unicode字符串
+ fill: 指定颜色
+ 十六进制模式如"#rgb","#rrggbb"
+ rgb模式如"rgb(255,0,0)","rgb(100%,0%,0%)"
+ hsl模式如"hsl(0,100%,49%)"
+ 名称模式如"red","White"
++-*/+-*/+-*/+-*/textsize m 计算文本在图上的(宽,高)
+draw.textsize(string, font=None) => (width, height)
+ string: 一般使用unicode字符串
+ font: 指定的imagefont对象
++-*/+-*/+-*/+-*/outline d 默认线颜色(?)
+outline
+ 对于模式为'1','L','I'的图像来说此值应是整数
+ 对于模式为'P'的图像来说此值应是浮点数
+ 对于模式为'RGB'的图像来说此值应是(r,g,b)三元组
++-*/+-*/+-*/+-*/fill d 默认填充色(?)
+fill
+ 对于模式为'1','L','I'的图像来说此值应是整数
+ 对于模式为'P'的图像来说此值应是浮点数
+ 对于模式为'RGB'的图像来说此值应是(r,g,b)三元组
++-*/+-*/+-*/+-*/font d 默认字体对象(?)
248 dicts/python.bs4.zh_CN.dict
@@ -0,0 +1,248 @@
++-*/bs4 p 树状形式解析html模块
+所有操作如使用诸如tag名称等参数都要使用小写(如果制定使用xml模块则区分大小写)
++-*/+-*/Tag c 文档里的<xx>..</xx>元素
+bs4.element.Tag
+可使用self.xx来直接访问其包含的第一个<xx>...</xx>的tag对象
+可以使用self['id']来获取或设置<xx id='value'>的value
+对于解析html
+如果属性是class,rel,rev,accept-charset,headers,accesskey返回的是列表
+如tag['class']=['sd','ss']
++-*/+-*/+-*/name d <xx>的xx,赋值的话可直接更改xx为yy
++-*/+-*/+-*/attrs d <xx a='a1' B='b1'>里的{'a':'a1','b':'b1'}属性字典
++-*/+-*/+-*/string d 直接包含的文本内容
+如tag包含有其它tag将返回None
+返回的是bs4.element.NavigableString对象
+可以直接修改其内容,小心会覆盖其它子tag元素
++-*/+-*/+-*/strings d 获取所有的文本列表
++-*/+-*/+-*/stripped_strings d 获取所有的文本列表(除去那些空白的文本)
++-*/+-*/+-*/append m 在子元素最后增加内容
++-*/+-*/+-*/insert m 在子元素列表里插入内容
++-*/+-*/+-*/insert_before m 在本元素之前插入内容
++-*/+-*/+-*/insert_after m 在本元素之后插入内容
++-*/+-*/+-*/clear m 清除子元素列表
++-*/+-*/+-*/extract m 提取本元素
++-*/+-*/+-*/decompose m 删除本元素(包括子元素)
++-*/+-*/+-*/replace_with m 更变其内容
++-*/+-*/+-*/wrap m 外包一个新元素
++-*/+-*/+-*/unwrap m 删除本新元素(不包括子元素)
++-*/+-*/+-*/get_text m 获取没有tag的所有文本,返回unicode
++-*/+-*/NavigableString c 文本text
++-*/+-*/BeautifulSoup c 分析文档
+BeautifulSoup(self, markup='', features=None, from_encoding=None, **kwargs)
+ markup: 需分析的字符串
+ features: 解析器 默认使用可容错的html的解析器
+ 'xml'(通常不用),'lxml'(需有安装),'html5lib'(需有安装),'html.parser'(默认)
+ from_encoding: 字符串的编码
+ 大多数方法返回的对象有两种
+ bs4.element.Tag 或 bs4.element.NavigableString
+ 本身是Tag对象
+ 对于xml或非整体的html会自动加上html和body
++-*/+-*/+-*/parent d 父元素Tag
++-*/+-*/+-*/parents d 祖父元素Tag序列
++-*/+-*/+-*/contents d 直接子元素序列
++-*/+-*/+-*/descendants d 所有子孙元素序列
++-*/+-*/+-*/next_sibling d 其后的兄弟元素
++-*/+-*/+-*/next_siblings d 其后的兄弟元素序列
++-*/+-*/+-*/previous_sibling d 其前的兄弟元素
++-*/+-*/+-*/previous_siblings d 其前的兄弟元素序列
++-*/+-*/+-*/next_element d 在其后的元素
++-*/+-*/+-*/next_elements d 在其后的元素序列
++-*/+-*/+-*/previous_element d 在其前的元素
++-*/+-*/+-*/previous_elements d 在其前的元素序列
++-*/+-*/+-*/find_all m 查找所有符合条件的子孙元素,返回列表
+find_all(self, name=None, attrs={}, recursive=True, text=None, limit=None,
+ **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ recursive: 是否查找孙元素
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ limit: 限制结果数量
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find m 查找符合条件的第一个子孙元素
+find(self, name=None, attrs={}, recursive=True, text=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ recursive: 是否查找孙元素
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_parents m 查找所有符合条件的祖父元素,返回列表
+find_parents(self, name=None, attrs={}, limit=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ limit: 限制结果数量
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_parent m 查找符合条件的第一个祖父元素
+find_parent(self, name=None, attrs={}, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_next_siblings m 查找所有符合条件在其后的兄弟元素,返回列表
+find_next_siblings(self, name=None, attrs={}, text=None, limit=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ limit: 限制结果数量
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_next_sibling m 查找符合条件在其后的第一个兄弟元素
+find_next_sibling(self, name=None, attrs={}, text=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_previous_siblings m 查找所有符合条件在其前的兄弟元素,返回列表
+find_previous_siblings(self, name=None, attrs={}, text=None, limit=None,
+ **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ limit: 限制结果数量
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_previous_sibling m 查找符合条件在其前的第一个兄弟元素
+find_previous_sibling(self, name=None, attrs={}, text=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_all_next m 查找所有符合条件在其后的元素,返回列表
+find_all_next(self, name=None, attrs={}, text=None, limit=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ limit: 限制结果数量
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_next m 查找符合条件在其后的第一个元素,返回列表
+find_next(self, name=None, attrs={}, text=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_all_previous m 查找所有符合条件在其前的元素,返回列表
+find_all_previous(self, name=None, attrs={}, text=None, limit=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ limit: 限制结果数量
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/find_previous m 查找符合条件在其前的第一个元素,返回列表
+find_previous(self, name=None, attrs={}, text=None, **kwargs)
+ name: 字符串: tag名称
+ re对象: tag名称需符合的正则表达式
+ 列表: 多个tag名称
+ True: 所有的tag不包括string
+ 函数: 条件测试函数 func(元素)
+ attrs: {属性名称:条件} 条件同name
+ text: 查找内容符合条件的NavigableString元素,条件同name
+ **kwargs: 属性名称=条件 如id='link2',条件同name
+ 如find_all('p',id='link1')
+ css形式: 参数都为字符串,则按css模式处理
+ 如find_all('p','class1')
+ 这种方式可以查找那些有多种class的元素
+ 如<p class="class1 class2">..</p>
++-*/+-*/+-*/select m 按css选择模式查找元素,返回列表
+select(str)
+ 包含选择: 如 h3 a
+ 群组选择: 如 h1.class1 #id
+ 直接子选择: 如 h3 > p
+ 同胞选择: 如 h2 + p
+ 属性选择: 如 img[altsrc] input[type="text"] a[href^*$|="fdfs"]
++-*/+-*/+-*/new_tag m 产生一个新的Tag
+如new_tag('a',href='dfsdf'),常用与其它tag的append
376 dicts/python.pyparsing.dict
@@ -0,0 +1,376 @@
+/*-+ vim:ft=dict:sw=2:
+/*-+ p:module c:class m:method d:data f:function M:classmethod
++-*/pyparsing p 语法解析模块
++-*/+-*/ParseResults c 解析结果
+ParseResults(toklist,name=None,asList=True,modal=True,isinstance=<built-in function isinstance>)
+ 生成的对象可以像list那样操作如len,xx[0]等等,
+ 也可以像object那样操作,如xx.attrname等等
+ 还可以像dict那样操作,支持get,items,keys等操作
++-*/+-*/+-*/keys m 返回所有有被命名的元素的名称
++-*/+-*/+-*/pop m 移除最后一个元素
+pop(self,index=-1)
++-*/+-*/+-*/get m 按名称获取元素
+get(self,key,defaultValue=None)
++-*/+-*/+-*/insert m 插入一元素
+insert(self,index,insStr)
++-*/+-*/+-*/items m 所有有被命名的元素对
++-*/+-*/+-*/values m 所有有被命名的元素
++-*/+-*/+-*/asList m 将结果按列表形式呈现
++-*/+-*/+-*/asDict m 生成有被命名的元素字典
++-*/+-*/+-*/asXML m 将结果按XML形式呈现
+asXML(self,doctag=None,nameditemsOnly=False,indent='',formatted=True)
++-*/+-*/+-*/getName m 获取自身的名称
++-*/+-*/+-*/dump m
+dump(self,indent='',depth=0)
++-*/+-*/ParserElement c 解析元素的抽象类
+__ini__(self,savelist=False)
++-*/+-*/+-*/copy m 生成备份
++-*/+-*/+-*/setResultsName m 命名
+setResultsName(self,name,listAllMatches=False)
+返回self
+listAllMatches为False时,如有多个同名元素,该命名将只用于最后一个
+为True时,同名元素列表为最后结果
++-*/+-*/+-*/setName m 定义用于调试的名称
+setName(self,name)
+返回self
++-*/+-*/+-*/setBreak m 用于pdb调试
+setBreak(self,breakFlag=True)
+ breakFlag为True表示可以中断,False表示禁用中断
++-*/+-*/+-*/setParseAction m 设定成功获取元素时的操作,可用于校验
+setParseAction(self,*fns,**kwargs)
+返回self
+fn的形式可以是fn(s,loc,toks),fn(loc,toks),fn(toks),fn()
+s = 需解析的整个字符串
+loc = 本元素对应的字符串
+toks = ParseResults对象,对应本元素所解析的元素
+fn如修改toks并返回修改的toks,返回值将替代原先的结果
+当然如不需要修改就无需返回任何值
+fn还可以用以校验,如不符合只需抛出ParseException即可
++-*/+-*/+-*/addParseAction m 增加成功获取元素时的操作
+addParseAction(self,*fns,**kwargs)
+返回self
+fn的形式可以是fn(s,loc,toks),fn(loc,toks),fn(toks),fn()
+s = 需解析的整个字符串
+loc = 本元素对应的字符串
+toks = ParseResults对象,对应本元素所解析的元素
+fn如修改toks并返回修改的toks,返回值将替代原先的结果
+当然如不需要修改就无需返回任何值
++-*/+-*/+-*/setFailAction m 设定如解析失败时的操作
+setFailAction(self,fn)
+返回self
+fn的形式是fn(s,loc,expr,err)
+s = 需解析的整个字符串
+loc = 本元素对应的字符串
+expr = 哪一块未解析成功
+err = 失败时的异常
+fn不返回任何值,如需要中断整个解析,可以在fn抛出ParseFatalException异常
++-*/+-*/+-*/preParse m preParse(self,instring,loc)
++-*/+-*/+-*/parseImpl m parseImpl(self,instring,loc,doActions=True)
++-*/+-*/+-*/postParse m postParse(self,instring,loc)
++-*/+-*/+-*/tryParse m tryParse(self,instring,loc)
++-*/+-*/+-*/parseString m 解析某个字符串
+parseString(self,instring,parseAll=False)
+返回ParseResults对象
+parseString有时会自动执行expandtabs()操作,为了更为准确的在自定义的操作里工作
+可以在parseString之前设定parseWithTabs,或者使用fn(s,loc,toks)来使操作更为精确
++-*/+-*/+-*/parseFile m 解析某个文件
+parseFile(self,f,parseAll=False)
+返回ParseResults对象
+f可以是文件名或类文件对象
++-*/+-*/+-*/scanString m 查找并解析字符串,依次生成多个结果
+scanString(self,instring,maxMatches=2147483647,overlap=False)
+maxMatches可以设定最多解析出多少个结果
+overlap设定是否允许重叠
+此函数是生成器,每次生成的结果包含
+*匹配的元素--一个ParseResults对象
+*匹配的开始位置
+*匹配的结束位置
++-*/+-*/+-*/searchString m 查找并解析字符串,返回结果列表
+scanString(self,instring,maxMatches=2147483647)
++-*/+-*/+-*/transformString m 查找并替换字符串
+transformString(self,instring)
++-*/+-*/+-*/suppress m 静默模式,不在结果里出现
++-*/+-*/+-*/leaveWhitespace m 禁止自动跳过空白
++-*/+-*/+-*/setWhitespcaeChars m 自定义空白字符
+setWhitespcaeChars(self,chars)
+chars默认为(空格,tab,回车,换行)
++-*/+-*/+-*/ignore m 忽略如注释之类的不必要元素
+ignore(self,other)
++-*/+-*/+-*/setDebug m 允许显示调试信息
++-*/+-*/+-*/setDebugActions m 设定调试模式时的操作
+setDebugActions(self,startAction,successAction,errorAction)
++-*/+-*/+-*/validate m 检验是否包含无限循环的模式
+validate(self,validateTrace=[])
++-*/+-*/+-*/parseWithTabs m 禁止默认的将tab转为空格的操作
++-*/+-*/+-*/setDefaultWhitespaceChars M 自定义空白字符
+setDefaultWhitespaceChars(chars)
+chars默认为(空格,tab,回车,换行)
++-*/+-*/+-*/enablePackrat M 允许使用高性能的内存模式
++-*/+-*/+-*/__add__ m +操作,返回And对象
+如Word(nums) + '.'
++-*/+-*/+-*/__sub__ m -操作,返回带停止功能的And对象
+'-'操作是'+'的变形,当前一项匹配时后一项不匹配就会报错产生ParseSyntaxException
+如Word(nums) - ('.'+Word(nums))*3,当字符串不是这种ip地址形式时就会报错
++-*/+-*/+-*/__mul__ m *操作,返回And对象
+Literal('a')*3 相当于 Literal('a')+Literal('a')+Literal('a')
+'*'操作后面可以用包含2个整数(min,max)的元组,如('-'+Word(nums))*(1,2)
++-*/+-*/+-*/__or__ m |操作,返回MatchFirst对象
+按从左到右的顺序检验匹配,如匹配就完成,后面的不再检验
++-*/+-*/+-*/__xor__ m ^操作,返回Or对象
+至少有一个匹配要能被匹配到,如果有多个匹配被匹配到,结果将使用匹配字符串最长的
++-*/+-*/+-*/__and__ m &操作,返回Each对象
+所有匹配都要能匹配
++-*/+-*/+-*/__invert__ m ~操作,返回NotAny对象
++-*/+-*/+-*/__call__ m setResultsName的命名简化版
+__call__(self,name) 相当于.setResultsName(name) 命名
+返回self
++-*/+-*/+-*/Token c 字符串匹配类
++-*/+-*/+-*/+-*/Literal c 静态字符串匹配类,前后可以没有空白
+__init__(self,matchString)
+Literal('else')可能会匹配'elseif'的前4个字符串
++-*/+-*/+-*/+-*/+-*/CaselessLiteral c 静态字符串匹配类.忽略大小写
+__init__(self,matchString)
+结果返回的是定义时的字符串,而不是所找到的不同大小写的字符串
++-*/+-*/+-*/+-*/Keyword c 关键字字符串匹配类
+__init__(self,matchString,identChars='abc...,caseless=False)
+identChars默认为所有字母数字和'_'以及'$'
+Literal('else')可能会匹配'elseif'的前4个字符串
+而Keyword('else')不会出现此情况
++-*/+-*/+-*/+-*/+-*/CaselessKeyword c 关键字字符串匹配类.忽略大小写
+__init__(self,matchString,identChars='abc...)
+结果返回的是定义时的字符串,而不是所找到的不同大小写的字符串
++-*/+-*/+-*/+-*/Word c 单词字符串匹配类
+__init__(self,initChars,bodyChars=None,min=1,max=0,exact=0,
+ asKeyword=False,excludeChars=None)
+initChars 第一个字符所允许使用的字符
+bodyChars 后面字符所允许使用的字符,如无则同initChars
+min 单词的最小长度
+max 单词的最大长度,默认不限
+exact 定长单词,如设定,min和max将无效
+excludeChars 不允许的字符,initChars和bodyChars里将剔除这些字符
++-*/+-*/+-*/+-*/CharsNotIn c 类似Word,但是以不匹配字符来定义的单词字符串匹配类
+__init__(self,notChars,min=1,max=0,exact=0)
+notChars 不允许出现的字符
+min 单词的最小长度
+max 单词的最大长度,默认不限
+exact 定长单词,如设定,min和max将无效
++-*/+-*/+-*/+-*/Regex c 以正则表达式定义的字符串匹配类
+__init__(self,pattern,flags=0)
+pattern 正则表达式
+flags re的参数
+基本和re相同,只是结果按ParseResults形式保存
++-*/+-*/+-*/+-*/QuotedString c 类似带引号的字符串匹配类
+__init__(self,quoteChar,escChar=None,escQuote=None,multiline=Fasle,
+ unquoteResults=True,endQuoteChar=None)
+quoteChar 定义相当于引号的字符串,可以用"'''"这样的定义
+escChar 转义字符,通常为'\',默认为空
+escQuote 转义引号的字符,如"dfd""dd"里的'"',如dblQuotedString
+multiline 是否允许多行
+unquoteResults 结果是否保留引号,默认保留
+endQuoteChar 结尾的引号定义,默认同quoteChar
++-*/+-*/+-*/+-*/White c 定义空白的字符串匹配类
+__init__(self,ws=' \t\r\n',min=1,max=0,exact=0)
+ws 定义相当于空白的字符
+min 单词的最小长度
+max 单词的最大长度,默认不限
+exact 定长单词,如设定,min和max将无效
+通常不需要,默认pyparsing会自动过滤掉空白。
++-*/+-*/+-*/+-*/+-*/whiteStrs d 空白字符的显示字符串
+默认为{'\t':'<TAB>','\n':'<LF>','\x0c':'<FF>','\r':'<CR>',' ':'<SPC>'}
++-*/+-*/+-*/+-*/Empty c 空字符串匹配类,总是匹配的
+通常用于debug
++-*/+-*/+-*/+-*/NoMatch c Empty的反例,总是不匹配的
+通常用于debug
++-*/+-*/+-*/PositionToken _ 位置匹配
++-*/+-*/+-*/+-*/StringStart c 匹配整个文本的开始处
++-*/+-*/+-*/+-*/StringEnd c 匹配整个文本的结束处
++-*/+-*/+-*/+-*/LineStart c 匹配行的开头
++-*/+-*/+-*/+-*/LineEnd c 匹配行的结尾
++-*/+-*/+-*/+-*/WordStart c 匹配单词开头
+__init__(self,wordChars='0123456789abc...)
+默认的单词定义是printables,如果想要正则表达式里的那种,
+可以使用WordStart(alphanums)来定义
++-*/+-*/+-*/+-*/WordEnd c 匹配单词结尾
+__init__(self,wordChars='0123456789abc...)
+默认的单词定义是printables,如果想要正则表达式里的那种,
+可以使用WordEnd(alphanums)来定义
++-*/+-*/+-*/+-*/GotoColumn c 匹配某列
+__init__(self,colno)
+colno列号,通常用于表格形式的文本
++-*/+-*/+-*/ParseExpression c 组合匹配抽象类
+__init__(self,exprs,savelist=False)
++-*/+-*/+-*/+-*/And c 接连匹配,自动忽略空白
+通常由'+'操作产生,如Word(nums) + '.'
+'*'操作产生的也是此类对象,如Literal('a')*3
+'*'操作后面可以用包含2个整数(min,max)的元组,如('-'+Word(nums))*(1,2)
+'-'操作是'+'的变形,当前一项匹配时后一项不匹配就会报错产生ParseSyntaxException
+如Word(nums) - ('.'+Word(nums))*3,当字符串不是这种ip地址形式时就会报错
++-*/+-*/+-*/+-*/Or c 多样式匹配,使用最长的匹配
+通常由'^'操作产生,至少有一个子匹配能被匹配到,如果有多个子匹配被匹配到,
+结果将使用匹配字符串最长的
++-*/+-*/+-*/+-*/MatchFirst c 多样式匹配,使用最先匹配到的匹配
+通常由'|'操作产生,按从左到右的顺序检验子匹配,如匹配就完成,后面的不再检验
++-*/+-*/+-*/+-*/Each c 多样式匹配,所有子模式都要被匹配
+通常由'&'操作产生,所有子匹配都要能匹配
++-*/+-*/+-*/ParseElementEnhance c 高级匹配抽象类
+__init__(self,exprs,savelist=False)
++-*/+-*/+-*/+-*/Optional c ?,可选匹配,如未匹配,则使用默认项,匹配0个或1个
+__init__(self,exprs,default=NullToken())
++-*/+-*/+-*/+-*/ZeroOrMore c *,匹配多个或不匹配
+__init__(self,exprs)
++-*/+-*/+-*/+-*/OneOrMore c +,匹配多个
+__init__(self,exprs)
++-*/+-*/+-*/+-*/FollowedBy c 后检验匹配,只检验,不会包含结果
+__init__(self,exprs)
+此匹配相当于位置匹配,不会包含任何数据结果,只做检验
+如'a'+FollowedBy(Word(nums))+Word(alphanums)
++-*/+-*/+-*/+-*/NotAny c 后检验不可匹配,只检验,不会包含结果
+__init__(self,exprs)
+通常用'~'操作,注意用(),如'a'+(~Word(nums))+Word(alphanums)
++-*/+-*/+-*/+-*/SkipTo c 捕获所有匹配,直到特定的模式被匹配到为止
+__init__(self,other,include=False,ignore=None,failOn=False)
+include 如果设为True,结束的特定模式也包含在内
+comm='/*'+SkipTo(Literal('*/'))+'*/'
++-*/+-*/+-*/+-*/Forward c 构建自嵌套的匹配
+__init__(self)
+一般先构造对象,然后再使用<<操作构建匹配,如
+expr=Forward()
+list='['+ZeroOrMore(expr+',')+expr+']'
+expr<<(Word(nums)|list)
++-*/+-*/+-*/+-*/TokenConverter c 转换结果组合抽象类
+__init__(self,exprs,savelist=False)
++-*/+-*/+-*/+-*/+-*/Combine c 把所有子匹配组合起来为一个匹配,中间不忽略空白
+__init__(self,expr,joinString='',adjacent=True)
+joinString 间隔子匹配的字符串
+adjacent 是否按原始顺序排列
++-*/+-*/+-*/+-*/+-*/Suppress c 结果里忽略包含的匹配内容
+__init__(self,expr)
+expr可以是匹配对象也可以是字符串
+同expr.suppress()
++-*/+-*/+-*/+-*/+-*/Group c 将匹配项转为列表,通常用于ZeroOrMore或OneOrMore
++-*/+-*/+-*/+-*/+-*/Dict c 将匹配项转为字典,通常用于报表文本
+类似Group,不同的是每个子匹配都会以其第一项匹配的内容作索引,一般用于二维数组
++-*/+-*/ParseBaseException e 解析异常的抽象类
+__init__(self,pstr,loc=0,msg=None,elem=None)
++-*/+-*/+-*/markInputline m 在原始文本里标记出出错的地方
+markInputline(self,markerString='>!<')
++-*/+-*/+-*/ParseException e 语法解析异常
+__init__(self, pstr, loc=0, msg=None, elem=None)
++-*/+-*/+-*/+-*/line d 出错的行内容
++-*/+-*/+-*/+-*/lineno d 出错的行号
++-*/+-*/+-*/+-*/col d 出错的列号
++-*/+-*/+-*/ParseFatalException e 解析时操作异常
++-*/+-*/+-*/ParseSyntaxException e 解析时语义异常,通常出现在'-'连接的匹配里
++-*/+-*/RecursiveGrammarException e 语法检查异常,通常是不正确的死循环匹配定义
++-*/+-*/col f 给出当前位置的所在列号
+col(loc, string)
+loc 位置,以0开始
+string 字符串
+列号以1开始
++-*/+-*/lineno f 给出当前位置的所在行号
+lineno(loc, string)
+loc 位置,以0开始
+string 字符串
+行号以1开始
++-*/+-*/line f 给出当前位置的所在行内容
+line(loc, string)
+loc 位置,以0开始
+string 字符串
+通常用于显示出错信息
++-*/+-*/nullDebugAction f 调试用操作,用于输出调试信息
++-*/+-*/traceParseAction f 调试装饰器,用于包裹其他操作
++-*/+-*/delimitedList f 以列表格式匹配
+delimitedList(expr, delim=',', combine=False)
+combine 如为True,则结果为一个包含分隔符的字符串
+ 如为False,则结果为列表
++-*/+-*/countedArray f
+countedArray(expr, intExpr=None)
+Helper to define a counted list of expressions.
++-*/+-*/matchPreviousLiteral f
+matchPreviousLiteral(expr)
+Helper to define an expression that is indirectly defined from the tokens matched in a previous expression, that is, it looks for a 'repeat' of a previous expression.
++-*/+-*/matchPreviousExpr f
+matchPreviousExpr(expr)
+Helper to define an expression that is indirectly defined from the tokens matched in a previous expression, that is, it looks for a 'repeat' of a previous expression.
++-*/+-*/oneOf f 由关键字列表生成MatchFirst匹配对象
+oneOf(strs, caseless=False, useRegex=True)
+strs 可以是以空白分割的字符串,也可以是列表
+如oneOf('''ha fa wa''')
+不管输入的顺序如何,返回的MatchFirst匹配对象将自动性能优化其顺序
++-*/+-*/dictOf f
+dictOf(key, value)
+Helper to easily and clearly define a dictionary by specifying the respective patterns for the key and value.
++-*/+-*/originalTextFor f
+originalTextFor(expr, asString=True)
+Helper to return the original, untokenized text for a given expression.
++-*/+-*/srange f 生成给定范围的Word对象
+srange(s)
+s 是正则表达式里的[]范围
+如srange('[0-9A-Fa-f]')
++-*/+-*/matchOnlyAtCol f
+matchOnlyAtCol(n)
+Helper method for defining parse actions that require matching at a specific column in the input text.
++-*/+-*/replaceWith f 生成一个简单的替换操作函数
+replaceWith(replStr)
+例如Literal("&nbsp;").setParseAction(replaceWith("<BLANK>"))
++-*/+-*/removeQuotes f 一个去除引号的操作函数
+removeQuotes(s, l, t)
+例如quotedString.setParseAction(removeQuotes)
++-*/+-*/upcaseTokens f 转换为大写的操作函数
+upcaseTokens(s, l, t)
++-*/+-*/downcaseTokens f 转换为小写的操作函数
+downcaseTokens(s, l, t)
++-*/+-*/getTokensEndLoc f
+getTokensEndLoc()
+Method to be called from within a parse action to determine the end location of the parsed tokens.
++-*/+-*/makeHTMLTags f 生成html<x ..></x>的2个匹配项
+makeHTMLTags(tagStr)
+返回2个匹配,第一个匹配如<a ff="...">,第二个匹配如</a>
+第一个匹配里会自动建立attr属性字典,如<img src='xx' alt='ss'>解析以后
+可以直接调用结果的.src或.alt
++-*/+-*/makeXMLTags f 生成xml<x ..></x>的2个匹配项,较严格,区分大小写
+makeXMLTags(tagStr)
+返回2个匹配,第一个匹配如<a ff="...">,第二个匹配如</a>
++-*/+-*/withAttribute f
+withAttribute(*args, **attrDict)
+Helper to create a validating parse action to be used with start tags created with makeXMLTags or makeHTMLTags.
++-*/+-*/operatorPrecedence f
+operatorPrecedence(baseExpr, opList)
+Helper method for constructing grammars of expressions made up of operators working in a precedence hierarchy.
++-*/+-*/nestedExpr f 生成可自嵌套的如[]{}类匹配项
+nestedExpr(opener='(', closer=')', content=None, ignoreExpr=quotedString using single or double quotes)
+Helper method for defining nested lists enclosed in opening and closing delimiters ("(" and ")" are the default).
++-*/+-*/indentedBlock f
+indentedBlock(blockStatementExpr, indentStack, indent=True)
+Helper method for defining space-delimited indentation blocks, such as those used to define block statements in Python source code.
++-*/+-*/replaceHTMLEntity f
+replaceHTMLEntity(t)
++-*/+-*/alphas d 字母字符
++-*/+-*/nums d 数字字符
++-*/+-*/alphanums d 字母数字字符
++-*/+-*/alphas8bit d a string containing alphabetic 8-bit characters:
++-*/+-*/punc8bit d
++-*/+-*/printables d 同string.printable,不包含空格
++-*/+-*/restOfLine d 所有字符,除了换行,相当于.*
++-*/+-*/empty d 全局Empty对象;总是被匹配
++-*/+-*/sglQuotedString d 单引号字符串匹配对象,可以有空白,但不能有多行
++-*/+-*/dblQuotedString d 双引号字符串匹配对象,可以有空白,但不能有多行
++-*/+-*/quotedString d sglQuotedString | dblQuotedString, 引号字符串匹配对象
++-*/+-*/unicodeString d 'u'+quotedString, u形式的引号字符串匹配对象
++-*/+-*/cStyleComment d c语言形式的注释匹配对象,/**/,不支持嵌套,可以多行
++-*/+-*/dblSlashComment d //形式的注释匹配对象
++-*/+-*/cppStyleComment d c++语言形式的注释匹配对象
++-*/+-*/javaStyleComment d java语言形式的注释匹配对象
++-*/+-*/pythonStyleComment d python语言形式的注释匹配对象
++-*/+-*/htmlComment d html形式的注释匹配对象 '<!--'-->',可以多行,不支持嵌套
++-*/+-*/commaSeparatedList d
+similar to delimitedList, except that the list expressions can be any text value, or a quoted string; quoted strings can safely include commas without incorrectly breaking the string into two tokens
++-*/+-*/lineStart d LineStart实例
++-*/+-*/lineEnd d LineEnd实例
++-*/+-*/stringStart d StringStart实例
++-*/+-*/stringEnd d StringEnd实例
++-*/+-*/commonHTMLEntity d &gt; &lt; &amp; &nbsp; &quot;
++-*/+-*/anyOpenTag d <..>xml形式的开头匹配对象
++-*/+-*/anyCloseTag d </..>xml形式的结尾匹配对象
+
+
22,552 dicts/python.stdlib.dict
22,552 additions, 0 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
23,677 dicts/python.stdlib.zh_CN.dict
23,677 additions, 0 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
1 dicts/python.vim
@@ -0,0 +1 @@
+let g:custom_python_dict_files = ['python.pyparsing.dict','python.stdlib.zh_CN.dict']
4 dicts/vim.vim
@@ -0,0 +1,4 @@
+let g:custom_vim_dict_files = ['vim.zh_CN.dict']
+let g:custom_vim_dict_modeline = ' '.'vim:tw=78:ts=8:ft=help:norl:'
+let g:custom_vim_dict_usemenu = 1
+let g:custom_vim_dict_complete_method = 'completefunc'
15,546 dicts/vim.zh_CN.dict
15,546 additions, 0 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
156 doc/custom_dict.txt
@@ -0,0 +1,156 @@
+*custom_dict.txt* 自定义补全字典 最近更新:2012年06月04日
+
+ *custom_dict_plugin*
+简介 |custom_dict_plugin_intro|
+相关文件 |custom_dict_plugin_files|
+使用方法 |custom_dict_plugin_usage|
+字典格式 |custom_dict_plugin_dict|
+参数说明 |custom_dict_plugin_setup|
+
+===========================================================================
+简介 *custom_dict_plugin_intro*
+
+一般的补全大多是直接由程序源码产生,字典则是只有单词,没什么解释等内容。通过
+一些简单的脚本把一些帮助文档转换成补全提示,在输入时会很有帮助。本插件规范的
+文本带有树状结构,这样补全提示的时候就有层次,对于遗忘的名称会更为方便的搜索
+到。
+
+
+===========================================================================
+相关文件 *custom_dict_plugin_files*
+
+plugin/custom_dict.vim 插件
+ftplugin/dict.vim dict文件相关的插件
+syntax/dict.vim dict文件相关的插件
+dicts/ 存放dict文件的目录
+dicts/XX.vim XX类型的设置
+doc/custom_dict.txt help文件
+
+如果没有编写某文件类型的设置,插件会自动查找 dicts/ 目录下的文件
+例如vim的文档只要命名为vim.dict并放入dicts/目录下,不需要相应的vim.vim也可以
+使用。文件名称遵从 $filetype...dict 格式,如vim.zh_CN.dict或vim.en.dict
+
+===========================================================================
+使用方法 *custom_dict_plugin_usage*
+
+以下按默认设置情况说明
+
+补全 *custom_dict_plugin_usage_complete*
+在插入模式下按<C-X><C-U>进入补全模式
+在补全模式下按<C-F>,补全菜单将按照同一类型显示,连续按<C-F>可切换遍历各种类
+型。按<C-H>进入层次模式显示,按<C-N>或<C-P>选择层次模式显示里类型标记为‣或>
+的词条,再按<C-L>将进入到该词条的下一层次里,再按<C-H>返回上一层次。
+
+字典文件 *custom_dict_plugin_usage_dict*
+编辑dict文件时,在词条行按+将增加层次深度,按-减少层次。可以用V模式选择多行
+同时操作。
+
+===========================================================================
+字典格式 *custom_dict_plugin_dict*
+
+样例~
+>
+ +-*/word1 c 这是词条行,类型为c
+ 更为详细的说明内容
+ ...
+ +-*/word2 C 这是词条行,类型为C,这一行的内容是短注释
+ 更为详细的说明内容
+ +-*/+-*/word3 _ 这是虚拟词条行,是word2的子层次
+ 更为详细的说明内容
+ +-*/+-*/+-*/word4 C 这是词条行,类型为C,是word3的子层次
+ 更为详细的说明内容
+ +-*/+-*/word5 这是词条行,没有类型,是word2的子层次
+ 更为详细的说明内容
+ /*-+ 这是注释行,通常用于说明类型的含义
+
+<
++-*/是标记词条的,每多一个就多一个层次,子层次的深度不能比父层次的深度多出超于
+一个的+-*/。在+-*/后紧跟的就是用于补全的单词,其后可以加上类型,用空白分割,类
+型只能是一个英文字符,如果是'_'类型则表示为虚拟的词条,只会出现在层次模式显示里
+。一般用于建立虚拟的划分层次。也可以没有类型,词条行的剩余内容为短注释,直接出
+现在补全菜单里。详细说明在使用<C-P>或<C-N>或<UP><DOWN>键选择到词条时会出现提示
+窗口里。详细内容说明可以按某种格式编写,如vim.dict里的内容都是按help文件格式编
+写的,这样通过设置|g:custom_vim_dict_modeline|可以使提示窗口里出现带有语法着色的
+提示内容。如果在一个文件里有多种风格的内容,可以在每一个内容后都加上一行对应的
+|modeline|来显示不同的风格。注释行通常来说明文档里各类型字符所代表的含义,通常
+使用的规范为 >
+ /*-+ c class
+ /*-+ m object method
+ /*-+ M class method
+ /*-+ d object data
+ /*-+ f function
+ /*-+ p module or pack
+<
+NOTE: +-*/和/*-+都要在行的开头才有效,前面不能有空白。同一子层次里带有孙层次的
+ 词条不能有重复的,如有重复的视为同一个。同一子层次里不能有同名同类型的
+ 词条。以下是错误样例 >
+ +-*/classA c
+ +-*/+-*/classB c
+ +-*/+-*/+-*/method1 m
+ +-*/+-*/+-*/method1 m 这是错误的行,不能同名同类型
+ +-*/+-*/classC c
+ +-*/+-*/+-*/method1 m 这是可以的,因为和以上的method1不是同一子层次
+ +-*/+-*/classB c 这里将该词条视为同第二行的词条
+ +-*/+-*/+-*/+-*/method2 m 这是错误行,子层次只能比父层次多一个+-*/
+
+===========================================================================
+参数说明 *custom_dict_plugin_setup*
+
+全局~
+通常写在vimrc配置里 >
+ let loaded_custom_dict = 1 "屏蔽此插件
+<
+
+某类型的设置~
+通常写在dicts/目录里XX.vim里
+这里用文件类型XX作例子 >
+
+ "该类型所使用到的字典文件,此参数是数组类型,每一项是dicts/目录里对应
+ "的一个文件
+ let g:custom_XX_dict_files = ['XX.1.dict','XX.2.dict']
+
+ "如果所有字典都是一种格式的注释,可以用这一项来标注提示窗口的modeline
+ "这一项的类型是字符串,注意modeline要以空白开始
+ let g:custom_XX_dict_modeline = ' '.'vim:tw=78:ts=8:ft=??:norl:'
+
+ "这一项指名在非层次模式显示里是否直接使用文档里词条行的短注释作提示
+ "一般有时会有多个同名的单词,如果将此项设为0,短注释里将用层次结构
+ "来代替,如classA.classB,设为1,将还是使用文档里原先的短注释
+ let g:custom_XX_dict_usemenu = 1
+
+ "这一项的值有两种,'free'或'completefunc'
+ "free将使用<C-T>来调出补全菜单,completefunc则是使用<C-X><C-U>补全方式
+ "两种略有不同,free调出的菜单一般只用于选择
+ "completefunc方式里可以通过键入字符来筛选
+ "不过本插件有对结果进行排序,在已键入的字符后面调出补全菜单时
+ "显示的内容会将相似的结果排在前面
+ let g:custom_XX_dict_complete_method = 'completefunc'
+
+ "这是在补全模式下用此键轮换不同类型,默认为<C-F>,注意字符串用单引号
+ let g:custom_XX_dict_complete_kind_key = '<C-F>'
+
+ "这是在补全模式下用此键调用层次模式显示或返回上一层次
+ "默认为<C-H>,注意字符串用单引号
+ let g:custom_XX_dict_complete_up_key = '<C-H>'
+
+ "这是在补全模式下用此键进入下一层或进入层次模式显示
+ "默认为<C-L>,注意字符串用单引号
+ let g:custom_XX_dict_complete_down_key = '<C-L>'
+
+ "这是free方式里调出补全菜单的快捷键,默认为<C-T>,注意字符串用单引号
+ let g:custom_XX_dict_complete_first_key = '<C-T>'
+<
+===========================================================================
+补充说明~
+
+已知此插件与dbext.vim插件有冲突,如装有dbext本插件可能不能正常使用。
+如果有用到提示窗口里的语法着色,在使用minibufexpl插件时需设置 >
+ let g:miniBufExplForceSyntaxEnable=1
+
+对于普通模式查看某单词注释,可自定义快捷键来实现此操作,如 >
+ nmap <F1> hea<C-X><C-U><C-N>
+不过由于词典里单词不一定全是字母形式,而且同名的可能会很多,所以需自行根据不同
+情况来实现此功能。
+
+
+ vim:tw=78:ts=8:ft=help:norl:
85 ftplugin/dict.vim
@@ -0,0 +1,85 @@
+if exists("b:dictdid_ftplugin")
+ finish
+endif
+let b:dictdid_ftplugin = 1
+
+function! g:Dict_fold_method() "{{{
+ if getline(v:lnum)[:3] == '+-*/'
+ return '>' . strlen(matchstr(getline(v:lnum),'^\(+-\*\/\)*'))/4
+ else
+ if v:lnum > 1
+ if getline(v:lnum-1)[:3] == '+-*/'
+ return strlen(matchstr(getline(v:lnum-1),'^\(+-\*\/\)*'))/4
+ " elseif getline(v:lnum+1)[:3] == '+-*/'
+ " return strlen(matchstr(getline(v:lnum+1),'^\(+-\*\/\)*'))/4
+ else
+ return '='
+ endif
+ else
+ return 0
+ endif
+ endif
+endfunc "}}}
+function! g:Dict_fold_text() "{{{
+ let width = winwidth(0) - 6 - &l:foldcolumn - (&l:number ? &l:numberwidth : 0) - 2
+ if width < 20 | return foldtext() | endif
+ let lines = substitute(printf('%6d',v:foldend - v:foldstart + 1),' ','-','g')
+ let line = getline(v:foldstart)
+ let swidth = strdisplaywidth(line)
+ if swidth < width
+ let line = line . repeat('-',width-swidth)
+ else
+ let line = printf('%.'.(width-4).'s',line)
+ let swidth = strdisplaywidth(line)
+ if swidth < width
+ let line = line . repeat('.',width-swidth-1) . '>'
+ else
+ " TODO ?
+ return foldtext()
+ endif
+ endif
+ return line . lines
+endfunc "}}}
+function! s:uplevel(...) "{{{
+ if a:0
+ let firstline = a:1
+ while firstline <= a:2
+ if getline(firstline)[:3] == '+-*/'
+ call setline(firstline,'+-*/'.getline(firstline))
+ endif
+ let firstline += 1
+ endwhile
+ else
+ call setline(line('.'),'+-*/'.getline(line('.')))
+ endif
+endfunc "}}}
+function! s:uplevel_v() range "{{{
+ call s:uplevel(a:firstline,a:lastline)
+endfunc "}}}
+function! s:downlevel(...) "{{{
+ if a:0
+ let firstline = a:1
+ while firstline <= a:2
+ if getline(firstline)[:3] == '+-*/'
+ call setline(firstline,getline(firstline)[4:])
+ endif
+ let firstline += 1
+ endwhile
+ else
+ if getline(line('.'))[:3] == '+-*/'
+ call setline(line('.'),getline(line('.'))[4:])
+ endif
+ endif
+endfunc "}}}
+function! s:downlevel_v() range "{{{
+ call s:downlevel(a:firstline,a:lastline)
+endfunc "}}}
+nnoremap <buffer> <silent> + :call <SID>uplevel()<CR>
+vnoremap <buffer> <silent> + :call <SID>uplevel_v()<CR>
+nnoremap <buffer> <silent> - :call <SID>downlevel()<CR>
+vnoremap <buffer> <silent> - :call <SID>downlevel_v()<CR>
+setlocal foldexpr=g:Dict_fold_method()
+setlocal foldmethod=expr
+setlocal foldtext=g:Dict_fold_text()
+ "let &l:commentstring='/*-+'
+
549 plugin/custom_dict.vim
@@ -0,0 +1,549 @@
+
+if exists('loaded_custom_dict') "{{{
+ finish
+endif
+let loaded_custom_dict = 1
+if v:version < 702
+ echoerr 'custom dict plugin requires vim7.2'
+ finish
+endif
+""ubuntu可以用这个
+"let s:DISPLAYCHILDKIND = "\u2023"
+let s:DISPLAYCHILDKIND = ">"
+let s:VIRTUALKIND='_'
+if v:lang =~ '^zh_CN' && &enc == 'utf-8'
+ let s:MESSAGE_NOFILE = "文件不存在"
+ let s:MESSAGE_CANTREADFILE = "无法读取文件"
+ let s:MESSAGE_WRONGLINE = "格式不对"
+ let s:MESSAGE_DUP_WORD_IS_IGNORE = "重复的词条"
+else
+ let s:MESSAGE_NOFILE = "NO FILE"
+ let s:MESSAGE_CANTREADFILE = "FILE READ ERROR"
+ let s:MESSAGE_WRONGLINE = "WRONG LINE"
+ let s:MESSAGE_DUP_WORD_IS_IGNORE = "DUP WORD"
+endif "}}}
+let s:DEBUG = 0
+function! s:find_rtp_file(filename, ...) "{{{
+ if s:DEBUG | echom 'infunc find_rtp_file' | endif
+ let files = split(globpath(&runtimepath,'dicts/' . a:filename),'\n')
+ if ! empty(files)
+ return files[0]
+ elseif filereadable(a:filename)
+ return a:filename
+ elseif a:0 && a:1 == 1
+ if a:0 == 2
+ throw a:2
+ else
+ throw s:MESSAGE_NOFILE . ':' . a:filename
+ endif
+ else
+ return ''
+ endif
+endfunc "}}}
+function! s:find_dict_files(filetype) "{{{
+ if s:DEBUG | echom 'infunc find_dict_files' | endif
+ let files = split(globpath(&runtimepath,'dicts/*.dict'),'\n')
+ let r = []
+ for filename in files
+ if fnamemodify(filename,':t:r') =~? '\(^\|\.\)'.a:filetype.'\A'
+ call add(r,filename)
+ endif
+ endfor
+ return r
+endfunc "}}}
+function! s:trim(str) "{{{
+ return substitute(substitute(a:str,'^[ \t\n\r]*','',''),'[ \t\n\r]*$','','')
+endfunc "}}}
+function! s:parse_line(line, wordline) "{{{
+ let s = matchstr(a:line, '^\(' . escape(a:wordline, '*') . '\)*')
+ let level = strlen(s) / strlen(a:wordline)
+ if level == 0 | return {'level':0} | endif
+ let word = matchstr(strpart(a:line,strlen(s)),'^\S*')
+ let other = s:trim(strpart(a:line,strlen(s)+strlen(word)))
+ " kind只有一个字符,如果在word后发现有一个字符,则这个字符是kind
+ if strlen(other) > 1
+ if other[1] == ' ' || other[1] == "\t"
+ let kind = other[0]
+ let menu = s:trim(strpart(other,1))
+ else
+ let kind = ''
+ let menu = other
+ endif
+ else
+ let kind = other
+ let menu = ''
+ endif
+ return {'level':level,'word':word,'kind':kind,'menu':menu}
+endfunc "}}}
+" config {{{
+let s:config_obj = {'filetype':'',
+ \'dictfiles':[],
+ \'modeline':'',
+ \'usemenu':0,
+ \'complete_method':'completefunc',
+ \'complete_kind_key':'<C-F>',
+ \'complete_up_key':'<C-H>',
+ \'complete_down_key':'<C-L>',
+ \'complete_first_key':'<C-T>',
+ \'WORDLINE':'+-*/',
+ \'COMMENTLINE':'/*-+',
+ \'DISPLAYSPLITSEP':'.'}
+function! s:config_obj.read_dict(lines,dictobj) dict "{{{
+ if s:DEBUG | echom 'infunc config_obj.read_dict' | endif
+ let number = 0
+ let lastword = {}
+ let infos = []
+ let father = a:dictobj.treeitems
+ let stacks = []
+ call add(a:lines,self.WORDLINE . 'end')
+ for line in a:lines
+ let number += 1
+ if stridx(line,self.COMMENTLINE) == 0 | continue | endif
+ let obj = s:parse_line(line,self.WORDLINE)
+ if obj.level == 0
+ call add(infos,line)
+ continue
+ endif
+ if obj.word == ''
+ throw s:MESSAGE_WRONGLINE . ':lineno:' . number
+ endif
+ if !empty(lastword)
+ " info
+ if self.modeline != '' | call add(infos,self.modeline) | endif
+ if !self.usemenu && lastword.menu != ''
+ call insert(infos,lastword.menu)
+ endif
+ let lastword.info = join(infos,"\n")
+ let infos = []
+ if lastword.level != len(stacks) + 1
+ call remove(stacks, lastword.level-1, -1)
+ let father = a:dictobj.treeitems
+ for name in stacks
+ let father = father.childs[name]
+ endfor
+ endif
+ let i = lastword.level - obj.level
+ if i == -1
+ " not isleaf "{{{
+ if has_key(father.childs, lastword.word)
+ let item = father.childs[lastword.word]
+ if item.menu == '' && lastword.menu != ''
+ let item.menu = lastword.menu
+ endif
+ if strlen(item.info) < strlen(lastword.info)
+ let item.info = lastword.info
+ endif
+ else
+ let item = {'word':lastword.word,'kind':s:DISPLAYCHILDKIND,'menu':lastword.menu,'items':[],'childs':{},'dup':1,'info':lastword.info}
+ let father.childs[lastword.word] = item
+ call add(father.items,item)
+ endif
+ let father = item
+ call add(stacks,father.word) "}}}
+ elseif i >= 0
+ " leaf "{{{
+ "check dup word
+ for item in father.items
+ if item.word ==# lastword.word && item.kind ==# lastword.kind
+ echoerr s:MESSAGE_DUP_WORD_IS_IGNORE . ':' item.word . '---' . item.kind
+ let lastword = obj
+ continue
+ endif
+ endfor
+ let item = {'word':lastword.word,'kind':lastword.kind,'menu':lastword.menu,'dup':1,'info':lastword.info}
+ call add(father.items,item) "}}}
+ else
+ throw s:MESSAGE_WRONGLINE . ':' . repeat(self.WORDLINE,lastword.level) . lastword.word
+ endif
+ if lastword.kind != s:VIRTUALKIND
+ call add(a:dictobj.allitems,
+ \{'word':item.word,'kind':lastword.kind,
+ \'menu':self.usemenu || empty(stacks) ? item.menu :
+ \join(stacks,self.DISPLAYSPLITSEP),
+ \'info':item.info,'dup':1})
+ endif
+ endif
+ let lastword = obj
+ endfor
+endfunc "}}}
+function! s:config_init() "{{{
+ if s:DEBUG | echom 'infunc config_init' | endif
+" return config_obj
+ if &l:filetype == '' | return {} | endif
+ let configfile = s:find_rtp_file(&l:filetype . '.vim')
+ if configfile != '' | execute 'source ' . fnameescape(configfile) | endif
+ if exists('g:custom_'.&l:filetype.'_dict_disable') | return {} | endif
+ let config = deepcopy(s:config_obj)
+ if !exists('g:custom_dict_pumheight')
+ let g:custom_dict_pumheight = 15
+ endif
+ if exists('g:custom_'.&l:filetype.'_dict_files')
+ for filename in g:custom_{&l:filetype}_dict_files
+ call add(config.dictfiles,s:find_rtp_file(filename,1))
+ endfor
+ endif
+ if exists('g:custom_'.&l:filetype.'_dict_modeline')
+ let config.modeline = g:custom_{&l:filetype}_dict_modeline
+ endif
+ if exists('g:custom_'.&l:filetype.'_dict_usemenu')
+ let config.usemenu = g:custom_{&l:filetype}_dict_usemenu == 1 ? 1 : 0
+ endif
+ if exists('g:custom_'.&l:filetype.'_dict_complete_method')
+ let config.complete_method = g:custom_{&l:filetype}_dict_complete_method == 'free' ? 'free' : 'completefunc'
+ endif
+ if exists('g:custom_'.&l:filetype.'_dict_complete_kind_key')
+ let config.complete_kind_key = g:custom_{&l:filetype}_dict_complete_kind_key
+ endif
+ if exists('g:custom_'.&l:filetype.'_dict_complete_up_key')
+ let config.complete_up_key = g:custom_{&l:filetype}_dict_complete_up_key
+ endif
+ if exists('g:custom_'.&l:filetype.'_dict_complete_down_key')
+ let config.complete_down_key = g:custom_{&l:filetype}_dict_complete_down_key
+ endif
+ if config.complete_method == 'free'
+ if exists('g:custom_'.&l:filetype.'_dict_complete_first_key')
+ let config.complete_first_key = g:custom_{&l:filetype}_dict_complete_first_key
+ endif
+ endif
+ if empty(config.dictfiles)
+ let config.dictfiles = s:find_dict_files(&l:filetype)
+ if empty(config.dictfiles)
+ return {}
+ endif
+ endif
+ let config.filetype = &l:filetype
+ return config
+endfunc "}}}
+"}}}
+" runtime {{{
+let s:dict_obj = {'filetype':'',
+ \'allitems':[],
+ \'treeitems':{'items':[],'childs':{}},
+ \'kinds':[],
+ \'linenr':0,
+ \'pos':0,
+ \'linestr':'',
+ \'word':'',
+ \'treestack':[],
+ \'lastkind':0,
+ \'status':'first'}
+function! s:sort_tree(x,y) "{{{
+ if a:x.kind == s:DISPLAYCHILDKIND && a:y.kind != s:DISPLAYCHILDKIND
+ return -1
+ elseif a:x.kind != s:DISPLAYCHILDKIND && a:y.kind == s:DISPLAYCHILDKIND
+ return 1
+ endif
+ let w1 = tr(a:x.word, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')
+ let w2 = tr(a:y.word, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')
+ return w1 ==# w2 ? 0 : w1 ># w2 ? 1 : -1
+endfunc "}}}
+function! s:sort_allitem(x,y) "{{{
+ if a:x.sortlevel > a:y.sortlevel
+ return 1
+ elseif a:x.sortlevel < a:y.sortlevel
+ return -1
+ endif
+ return a:x.word ==# a:y.word ? 0 : a:x.word ># a:y.word ? 1 : -1
+endfunc "}}}
+function! s:dict_obj.treesort(treeitems) dict "{{{
+ for x in items(a:treeitems.childs)
+ let a:treeitems.childs[x[0]] = self.treesort(x[1])
+ endfor
+ let a:treeitems.items = sort(a:treeitems.items,function('s:sort_tree'))
+ return a:treeitems
+endfunc "}}}
+function! s:dict_obj.sort() dict "{{{
+ if s:DEBUG | echom 'infunc dict_obj.sort' | endif
+ for item in self.allitems
+ if item.word =~ '^\A'
+ let item.sortlevel = 20
+ elseif item.word =~# '^[A-Z0-9_]\+$'
+ let item.sortlevel = 15
+ elseif item.word =~# '^[a-z0-9_]\+$'
+ let item.sortlevel = 0
+ elseif item.word =~# '^\l'
+ let item.sortlevel = 5
+ else
+ let item.sortlevel = 10
+ endif
+ endfor
+ let self.allitems = sort(self.allitems,function('s:sort_allitem'))
+endfunc "}}}
+function! s:dict_obj.process() dict "{{{
+ if s:DEBUG | echom 'infunc dict_obj.process' | endif
+ let kinds = {}
+ let emptykind = 0
+ for item in self.allitems
+ if item.kind == ''
+ let emptykind = 1
+ else
+ let kinds[item.kind] = 1
+ endif
+ endfor
+ let self.kinds = keys(kinds)
+ if emptykind | call add(self.kinds,'') | endif
+ if s:DEBUG | echom 'infunc dict_obj.treesort' | endif
+ let self.treeitems = self.treesort(self.treeitems)
+ call self.sort()
+endfunc "}}}
+function! s:dict_obj.get_by_kind(...) dict "{{{
+ if s:DEBUG | echom 'infunc dict_obj.get_by_kind' | endif
+ if a:0
+ if a:1 <= 0 || a:1 > len(self.kinds)
+ let self.lastkind = 0
+ else
+ let self.lastkind = a:1
+ endif
+ else
+ let self.lastkind += 1
+ if self.lastkind > len(self.kinds) | let self.lastkind = 0 | endif
+ endif
+ let self.treestack = []
+ if self.lastkind == 0 && self.word == '' | return self.allitems | endif
+ if self.lastkind | let kind = self.kinds[self.lastkind-1] | endif
+ let items = []
+ let items_startswith = []
+ let items_instr = []
+ let items_startswith_ignorecase = []
+ let items_instr_ignorecase = []
+ for item in self.allitems
+ if self.lastkind && item.kind !=# kind
+ continue
+ endif
+ if self.word == ''
+ call add(items,item)
+ continue
+ endif
+ let i = stridx(item.word,self.word)
+ if i == 0
+ call add(items_startswith,item)
+ elseif i > 0
+ call add(items_instr,item)
+ else
+ let i = stridx(tolower(item.word),tolower(self.word))
+ if i == 0
+ call add(items_startswith_ignorecase,item)
+ elseif i > 0
+ call add(items_instr_ignorecase,item)
+ else
+ call add(items,item)
+ endif
+ endif
+ endfor
+ return items_startswith + items_startswith_ignorecase + items_instr + items_instr_ignorecase + items
+endfunc "}}}
+function! s:dict_obj.get_by_tree(...) dict "{{{
+ if s:DEBUG | echom 'infunc dict_obj.get_by_tree' | endif
+ let self.lastkind = -1
+ if a:0 && !empty(self.treestack)
+ if has_key(self.treestack[-1].childs,a:1)
+ let item = self.treestack[-1].childs[a:1]
+ call add(self.treestack,item)
+ return item.items
+ else
+ return self.treestack[-1].items
+ endif
+ else
+ call add(self.treestack,self.treeitems)
+ return self.treeitems.items
+ endif
+endfunc "}}}
+function! s:dict_obj.get_up_tree() dict "{{{
+ if s:DEBUG | echom 'infunc dict_obj.get_up_tree' | endif
+ let self.lastkind = -1
+ if len(self.treestack) > 1
+ call remove(self.treestack, -1)
+ return self.treestack[-1].items
+ else
+ let self.treestack = [self.treeitems]
+ return self.treeitems.items
+ endif
+endfunc "}}}
+function! s:dict_obj.get_pos() dict "{{{
+ if s:DEBUG | echom 'infunc dict_obj.get_pos' | endif
+ let pos = col('.')
+ let line = getline('.')
+ while pos > 1 && line[pos-2] =~ '\k'
+ let pos -= 1
+ endwhile
+ let self.linenr = line('.')
+ let self.pos = pos
+ let self.linestr = pos > 1 ? line[:pos-2] : ''
+ let self.lastkind = -1
+ let self.treestack = []
+ return pos
+endfunc "}}}
+function! s:dict_obj.check_pos() dict "{{{
+ if pumvisible() && self.linenr == line('.') && self.pos <= col('.') &&
+ \ (self.pos > 1 ? getline('.')[:self.pos-2] : '') ==# self.linestr
+ return 1
+ else
+ if s:DEBUG
+ echom 'pos:' . string(self.pos)
+ echom 'linenr:' . string(self.linenr)
+ echom 'linestr:' . string(self.linestr)
+ echom 'word:' . string(self.word)
+ endif
+ return 0
+ endif
+endfunc "}}}
+function! s:dict_obj.get_base() dict "{{{
+ if col('.') > self.pos
+ return getline('.')[self.pos-1:col('.')-2]
+ else
+ return ''
+ endif
+endfunc "}}}
+function! s:dict_obj.complete_first() dict "{{{
+ let pos = self.get_pos()
+ let self.word = self.get_base()
+ let self.treestack = []
+ call complete(pos,self.get_by_kind(0))
+ return ''
+endfunc "}}}
+function! s:dict_obj.complete_kind() dict "{{{
+ if self.check_pos()
+ if self.complete_method == 'free'
+ call complete(self.pos,self.get_by_kind())
+ else
+ call feedkeys("\<C-X>\<C-U>",'n')
+ let self.status = 'kind'
+ endif
+ endif
+ return ''
+endfunc "}}}
+function! s:dict_obj.complete_up() dict "{{{
+ if self.check_pos()
+ if self.complete_method == 'free'
+ call complete(self.pos,self.get_up_tree())
+ else
+ call feedkeys("\<C-X>\<C-U>",'n')
+ let self.status = 'up'
+ endif
+ endif
+ return ''
+endfunc "}}}
+function! s:dict_obj.complete_down() dict "{{{
+ if self.check_pos()
+ if self.complete_method == 'free'
+ call complete(self.pos,self.get_by_tree(self.get_base()))
+ else
+ call feedkeys("\<C-Y>\<C-X>\<C-U>",'n')
+ let self.status = 'down'
+ endif
+ endif
+ return ''
+endfunc "}}}
+function! s:dict_init(config) "{{{
+ if s:DEBUG | echom 'infunc dict_init' | endif
+ let obj = deepcopy(s:dict_obj)
+ for filename in a:config.dictfiles
+ if filereadable(filename)
+ let lines = readfile(filename)
+ call map(lines,"iconv(v:val,'utf-8',&enc)")
+ try
+ call a:config.read_dict(lines,obj)
+ catch /.*/
+ throw filename . ':' . v:exception
+ endtry
+ else
+ throw s:MESSAGE_CANTREADFILE . ':' . filename
+ endif
+ endfor
+ if empty(obj.allitems) | return {} | endif
+ let obj.filetype = a:config.filetype
+ let obj.complete_method = a:config.complete_method
+ let obj.complete_kind_key = a:config.complete_kind_key
+ let obj.complete_up_key = a:config.complete_up_key
+ let obj.complete_down_key = a:config.complete_down_key
+ let obj.complete_first_key = a:config.complete_first_key
+ call obj.process()
+ return obj
+endfunc "}}}
+function! g:custom_dict_complete_func(findstart,base) "{{{
+ if a:findstart
+ if b:custom_dict.status == 'first'
+ call b:custom_dict.get_pos()
+ let b:custom_dict.treestack = []
+ endif
+ return b:custom_dict.pos-1
+ else
+ if b:custom_dict.status == 'first'
+ let b:custom_dict.word = a:base
+ let items = b:custom_dict.get_by_kind(0)
+ elseif b:custom_dict.status == 'kind'
+ let items = b:custom_dict.get_by_kind()
+ elseif b:custom_dict.status == 'up'
+ let items = b:custom_dict.get_up_tree()
+ elseif b:custom_dict.status == 'down'
+ let items = b:custom_dict.get_by_tree(a:base)
+ endif
+ let b:custom_dict.status = 'first'
+ return items
+ endif
+endfunc "}}}
+ "}}}
+function! s:setup_buff() "{{{
+ if s:DEBUG | echom 'infunc setup_buff' | endif
+ if exists('b:loaded_custom_dict') && b:loaded_custom_dict == &l:filetype
+ return
+ endif
+ let b:loaded_custom_dict = &l:filetype
+ if &l:filetype == '' || &l:filetype == 'help'|| &l:filetype == 'dict'
+ return
+ endif
+ if exists('b:custom_dict') && b:custom_dict.filetype == &l:filetype
+ return
+ endif
+ if exists('g:custom_' . &l:filetype . '_dict')
+ let b:custom_dict = g:custom_{&l:filetype}_dict
+ else
+ let config = s:config_init()
+ if config == {} | return | endif
+ " profile start /tmp/test.log
+ " profile func *
+ let dict = s:dict_init(config)
+ " profile pause
+ if dict == {} | return | endif
+ let g:custom_{&l:filetype}_dict = dict
+ let b:custom_dict = g:custom_{&l:filetype}_dict
+ if !s:DEBUG | echo ' ' | endif
+ endif
+ if ! exists('b:custom_dict_maped')
+ let &pumheight=g:custom_dict_pumheight
+ set completeopt=menuone,longest,preview
+ if b:custom_dict.complete_method == 'free'
+ call s:setup_map_free()
+ else
+ call s:setup_map_completefunc()
+ endif
+ let b:custom_dict_maped = 1
+ endif
+ if s:DEBUG
+ set verbose=14
+ endif
+endfunc "}}}
+function! s:setup_map_free() "{{{
+ if s:DEBUG | echom 'infunc setup_map_free' | endif
+ execute 'inoremap <buffer> <unique> <silent> ' . b:custom_dict.complete_first_key . ' <C-R>=b:custom_dict.complete_first()<CR>'
+ execute 'inoremap <buffer> <unique> <silent> ' . b:custom_dict.complete_kind_key . ' <C-R>=b:custom_dict.complete_kind()<CR>'
+ execute 'inoremap <buffer> <unique> <silent> ' . b:custom_dict.complete_up_key . ' <C-R>=b:custom_dict.complete_up()<CR>'
+ execute 'inoremap <buffer> <unique> <silent> ' . b:custom_dict.complete_down_key . ' <C-R>=b:custom_dict.complete_down()<CR>'
+ " inoremap <expr> <C-J> pumvisible()?"\<PageDown>":"\<C-X><C-O>"
+ " inoremap <expr> <C-K> pumvisible()?"\<PageUp>":"\<C-X><C-K>"
+endfunc "}}}
+function! s:setup_map_completefunc() "{{{
+ if s:DEBUG | echom 'infunc setup_map_completefunc' | endif
+ execute 'inoremap <buffer> <unique> <silent>' . b:custom_dict.complete_kind_key . ' <C-R>=b:custom_dict.complete_kind()<CR>'
+ execute 'inoremap <buffer> <unique> <silent>' . b:custom_dict.complete_up_key . ' <C-R>=b:custom_dict.complete_up()<CR>'
+ execute 'inoremap <buffer> <unique> <silent>' . b:custom_dict.complete_down_key . ' <C-R>=b:custom_dict.complete_down()<CR>'
+" inoremap <expr> <C-J> pumvisible()?"\<PageDown>":"\<C-X><C-O>"
+" inoremap <expr> <C-K> pumvisible()?"\<PageUp>":"\<C-X><C-K>"
+ setlocal completefunc=g:custom_dict_complete_func
+endfunc "}}}
+
+augroup filetypedetect
+ au! BufNewFile,BufRead *.dict setfiletype dict
+augroup END
+autocmd! FileType * call s:setup_buff()
+
22 syntax/dict.vim
@@ -0,0 +1,22 @@
+
+if exists('b:current_syntax') && b:current_syntax == 'dict'
+ finish
+endif
+
+syn match WordLine /^\(+-\*\/\)\+\S.*$/ contains=WordFlag,WordName,WordNoStandName,WordKind
+syn match WordFlag /^\(+-\*\/\)\+/ contained
+syn match WordName /\(^\(+-\*\/\)\+\)\@<=\S\+/ contained
+syn match WordKind /\(^\(+-\*\/\)\+\S\+\s\+\)\@<=\S\($\|\s\)\@=/ contained
+syn match DictComment /^\/\*-+.*$/
+syn match EnglishLine /^[^+\/][[:graph:] ]\+$/
+syn match WordTab /\t/
+
+hi def link DictComment Special
+hi def link WordTab Error
+hi def link EnglishLine Identifier
+hi def link WordLine Statement
+hi def link WordFlag Type
+hi def link WordName NonText
+hi def link WordKind VisualNOS
+
+let b:current_syntax = 'dict'

0 comments on commit d7e6974

Please sign in to comment.
Something went wrong with that request. Please try again.