rouge-alda 3.3.0

data/lib/rouge/lexers/lasso.rb

@@ -0,0 +1,215 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Rouge
+  module Lexers
+    class Lasso < TemplateLexer
+      title "Lasso"
+      desc "The Lasso programming language (lassosoft.com)"
+      tag 'lasso'
+      aliases 'lassoscript'
+      filenames '*.lasso', '*.lasso[89]'
+      mimetypes 'text/x-lasso', 'text/html+lasso', 'application/x-httpd-lasso'
+
+      option :start_inline, 'Whether to start inline instead of requiring <?lasso or ['
+
+      def self.detect?(text)
+        return true if text.shebang?('lasso9')
+        return true if text =~ /\A.*?<\?(lasso(script)?|=)/
+      end
+
+      def initialize(*)
+        super
+
+        @start_inline = bool_option(:start_inline)
+      end
+
+      def start_inline?
+        @start_inline
+      end
+
+      start do
+        push :lasso if start_inline?
+      end
+
+      class << self
+        attr_reader :keywords
+      end
+
+      # Load Lasso keywords from separate YML file
+      @keywords = ::YAML.load_file(Pathname.new(__FILE__).dirname.join('lasso/keywords.yml')).tap do |h|
+        h.each do |k,v|
+          h[k] = Set.new v
+        end
+      end
+
+      id = /[a-z_][\w.]*/i
+
+      state :root do
+        rule /^#![ \S]+lasso9\b/, Comment::Preproc, :lasso
+        rule(/(?=\[|<)/) { push :delimiters }
+        rule /\s+/, Text::Whitespace
+        rule(//) { push :delimiters; push :lassofile }
+      end
+
+      state :delimiters do
+        rule /\[no_square_brackets\]/, Comment::Preproc, :nosquarebrackets
+        rule /\[noprocess\]/, Comment::Preproc, :noprocess
+        rule /\[/, Comment::Preproc, :squarebrackets
+        rule /<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
+        rule(/([^\[<]|<!--.*?-->|<(script|style).*?\2>|<(?!\?(lasso(script)?|=)))+/im) { delegate parent }
+      end
+
+      state :nosquarebrackets do
+        rule /\[noprocess\]/, Comment::Preproc, :noprocess
+        rule /<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
+        rule(/([^\[<]|<!--.*?-->|<(script|style).*?\2>|<(?!\?(lasso(script)?|=))|\[(?!noprocess))+/im) { delegate parent }
+      end
+
+      state :noprocess do
+        rule %r(\[/noprocess\]), Comment::Preproc, :pop!
+        rule(%r(([^\[]|\[(?!/noprocess))+)i) { delegate parent }
+      end
+
+      state :squarebrackets do
+        rule /\]/, Comment::Preproc, :pop!
+        mixin :lasso
+      end
+
+      state :anglebrackets do
+        rule /\?>/, Comment::Preproc, :pop!
+        mixin :lasso
+      end
+
+      state :lassofile do
+        rule /\]|\?>/, Comment::Preproc, :pop!
+        mixin :lasso
+      end
+
+      state :whitespacecomments do
+        rule /\s+/, Text
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/\*\*!.*?\*/)m, Comment::Doc
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+      end
+
+      state :lasso do
+        mixin :whitespacecomments
+
+        # literals
+        rule /\d*\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule /0x[\da-f]+/i, Num::Hex
+        rule /\d+/, Num::Integer
+        rule /(infinity|NaN)\b/i, Num
+        rule /'[^'\\]*(\\.[^'\\]*)*'/m, Str::Single
+        rule /"[^"\\]*(\\.[^"\\]*)*"/m, Str::Double
+        rule /`[^`]*`/m, Str::Backtick
+
+        # names
+        rule /\$#{id}/, Name::Variable
+        rule /#(#{id}|\d+\b)/, Name::Variable::Instance
+        rule /(\.\s*)('#{id}')/ do
+          groups Name::Builtin::Pseudo, Name::Variable::Class
+        end
+        rule /(self)(\s*->\s*)('#{id}')/i do
+          groups Name::Builtin::Pseudo, Operator, Name::Variable::Class
+        end
+        rule /(\.\.?\s*)(#{id}(=(?!=))?)/ do
+          groups Name::Builtin::Pseudo, Name::Other
+        end
+        rule /(->\\?\s*|&\s*)(#{id}(=(?!=))?)/ do
+          groups Operator, Name::Other
+        end
+        rule /(?<!->)(self|inherited|currentcapture|givenblock)\b/i, Name::Builtin::Pseudo
+        rule /-(?!infinity)#{id}/i, Name::Attribute
+        rule /::\s*#{id}/, Name::Label
+        rule /error_((code|msg)_\w+|adderror|columnrestriction|databaseconnectionunavailable|databasetimeout|deleteerror|fieldrestriction|filenotfound|invaliddatabase|invalidpassword|invalidusername|modulenotfound|noerror|nopermission|outofmemory|reqcolumnmissing|reqfieldmissing|requiredcolumnmissing|requiredfieldmissing|updateerror)/i, Name::Exception
+
+        # definitions
+        rule /(define)(\s+)(#{id})(\s*=>\s*)(type|trait|thread)\b/i do
+          groups Keyword::Declaration, Text, Name::Class, Operator, Keyword
+        end
+        rule %r((define)(\s+)(#{id})(\s*->\s*)(#{id}=?|[-+*/%]))i do
+          groups Keyword::Declaration, Text, Name::Class, Operator, Name::Function
+          push :signature
+        end
+        rule /(define)(\s+)(#{id})/i do
+          groups Keyword::Declaration, Text, Name::Function
+          push :signature
+        end
+        rule %r((public|protected|private|provide)(\s+)((#{id}=?|[-+*/%])(?=\s*\()))i do
+          groups Keyword, Text, Name::Function
+          push :signature
+        end
+        rule /(public|protected|private|provide)(\s+)(#{id})/i do
+          groups Keyword, Text, Name::Function
+        end
+
+        # keywords
+        rule /(true|false|none|minimal|full|all|void)\b/i, Keyword::Constant
+        rule /(local|var|variable|global|data(?=\s))\b/i, Keyword::Declaration
+        rule /(array|date|decimal|duration|integer|map|pair|string|tag|xml|null|boolean|bytes|keyword|list|locale|queue|set|stack|staticarray)\b/i, Keyword::Type
+        rule /(#{id})(\s+)(in)\b/i do
+          groups Name, Text, Keyword
+        end
+        rule /(let|into)(\s+)(#{id})/i do
+          groups Keyword, Text, Name
+        end
+
+        # other
+        rule /,/, Punctuation, :commamember
+        rule /(and|or|not)\b/i, Operator::Word
+        rule /(#{id})(\s*::\s*#{id})?(\s*=(?!=|>))/ do
+          groups Name, Name::Label, Operator
+        end
+
+        rule %r((/?)([\w.]+)) do |m|
+          name = m[2].downcase
+
+          if m[1] != ''
+            token Punctuation, m[1]
+          end
+
+          if name == 'namespace_using'
+            token Keyword::Namespace, m[2]
+          elsif self.class.keywords[:keywords].include? name
+            token Keyword, m[2]
+          elsif self.class.keywords[:types_traits].include? name
+            token Name::Builtin, m[2]
+          else
+            token Name::Other, m[2]
+          end
+        end
+
+        rule /(=)(n?bw|n?ew|n?cn|lte?|gte?|n?eq|n?rx|ft)\b/i do
+          groups Operator, Operator::Word
+        end
+        rule %r(:=|[-+*/%=<>&|!?\\]+), Operator
+        rule /[{}():;,@^]/, Punctuation
+      end
+
+      state :signature do
+        rule /\=>/, Operator, :pop!
+        rule /\)/, Punctuation, :pop!
+        rule /[(,]/, Punctuation, :parameter
+        mixin :lasso
+      end
+
+      state :parameter do
+        rule /\)/, Punctuation, :pop!
+        rule /-?#{id}/, Name::Attribute, :pop!
+        rule /\.\.\./, Name::Builtin::Pseudo
+        mixin :lasso
+      end
+
+      state :commamember do
+        rule %r((#{id}=?|[-+*/%])(?=\s*(\(([^()]*\([^()]*\))*[^\)]*\)\s*)?(::[\w.\s]+)?=>)), Name::Function, :signature
+        mixin :whitespacecomments
+        rule //, Text, :pop!
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/liquid.rb

@@ -0,0 +1,288 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Liquid < RegexLexer
+      title "Liquid"
+      desc 'Liquid is a templating engine for Ruby (liquidmarkup.org)'
+      tag 'liquid'
+      filenames '*.liquid'
+
+      state :root do
+        rule /[^\{]+/, Text
+
+        rule /(\{%)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :tag_or_block
+        end
+
+        rule /(\{\{)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :output
+        end
+
+        rule /\{/, Text
+      end
+
+      state :tag_or_block do
+        # builtin logic blocks
+        rule /(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
+
+        rule /(when)(\s+)/ do
+          groups Keyword::Reserved, Text::Whitespace
+          push :when
+        end
+
+        rule /(else)(\s*)(%\})/ do
+          groups Keyword::Reserved, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        # other builtin blocks
+        rule /(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
+          groups Name::Tag, Text::Whitespace, Name::Attribute, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        rule /(comment)(\s*)(%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
+          push :comment
+        end
+
+        rule /(raw)(\s*)(%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
+          push :raw
+        end
+
+        rule /assign/, Name::Tag, :assign
+        rule /include/, Name::Tag, :include
+
+        # end of block
+        rule /(end(case|unless|if))(\s*)(%\})/ do
+          groups Keyword::Reserved, nil, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        rule /(end([^\s%]+))(\s*)(%\})/ do
+          groups Name::Tag, nil, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        # builtin tags
+        rule /(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
+          token Name::Tag, m[1]
+          token Text::Whitespace, m[2]
+
+          if m[4] =~ /'[^']*'/
+            token Str::Single, m[4]
+          elsif m[4] =~ /"[^"]*"/
+            token Str::Double, m[4]
+          else
+            token Name::Attribute, m[4]
+          end
+
+          token Punctuation, m[5]
+          token Text::Whitespace, m[6]
+
+          push :variable_tag_markup
+        end
+
+        # other tags or blocks
+        rule /([^\s%]+)(\s*)/ do
+          groups Name::Tag, Text::Whitespace
+          push :tag_markup
+        end
+      end
+
+      state :output do
+        mixin :whitespace
+        mixin :generic
+
+        rule /\}\}/, Punctuation, :pop!
+        rule /\|/, Punctuation, :filters
+      end
+
+      state :filters do
+        mixin :whitespace
+
+        rule(/\}\}/) { token Punctuation; reset_stack }
+
+        rule /([^\s\|:]+)(:?)(\s*)/ do
+          groups Name::Function, Punctuation, Text::Whitespace
+          push :filter_markup
+        end
+      end
+
+      state :filter_markup do
+        rule /\|/, Punctuation, :pop!
+
+        mixin :end_of_tag
+        mixin :end_of_block
+        mixin :default_param_markup
+      end
+
+      state :condition do
+        mixin :end_of_block
+        mixin :whitespace
+
+        rule /([=!><]=?)/, Operator
+
+        rule /\b((!)|(not\b))/ do
+          groups nil, Operator, Operator::Word
+        end
+
+        rule /(contains)/, Operator::Word
+
+        mixin :generic
+        mixin :whitespace
+      end
+
+      state :when do
+        mixin :end_of_block
+        mixin :whitespace
+        mixin :generic
+      end
+
+      state :operator do
+        rule /(\s*)((=|!|>|<)=?)(\s*)/ do
+          groups Text::Whitespace, Operator, nil, Text::Whitespace
+          pop!
+        end
+
+        rule /(\s*)(\bcontains\b)(\s*)/ do
+          groups Text::Whitespace, Operator::Word, Text::Whitespace
+          pop!
+        end
+      end
+
+      state :end_of_tag do
+        rule(/\}\}/) { token Punctuation; reset_stack }
+      end
+
+      state :end_of_block do
+        rule(/%\}/) { token Punctuation; reset_stack }
+      end
+
+      # states for unknown markup
+      state :param_markup do
+        mixin :whitespace
+        mixin :string
+
+        rule /([^\s=:]+)(\s*)(=|:)/ do
+          groups Name::Attribute, Text::Whitespace, Operator
+        end
+
+        rule /(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
+          groups Punctuation, Text::Whitespace, nil, Text::Whitespace, Punctuation
+        end
+
+        mixin :number
+        mixin :keyword
+
+        rule /,/, Punctuation
+      end
+
+      state :default_param_markup do
+        mixin :param_markup
+        rule /./, Text
+      end
+
+      state :variable_param_markup do
+        mixin :param_markup
+        mixin :variable
+        rule /./, Text
+      end
+
+      state :tag_markup do
+        mixin :end_of_block
+        mixin :default_param_markup
+      end
+
+      state :variable_tag_markup do
+        mixin :end_of_block
+        mixin :variable_param_markup
+      end
+
+      # states for different values types
+      state :keyword do
+        rule /\b(false|true)\b/, Keyword::Constant
+      end
+
+      state :variable do
+        rule /\.(?=\w)/, Punctuation
+        rule /[a-zA-Z_]\w*\??/, Name::Variable
+      end
+
+      state :string do
+        rule /'[^']*'/, Str::Single
+        rule /"[^"]*"/, Str::Double
+      end
+
+      state :number do
+        rule /\d+\.\d+/, Num::Float
+        rule /\d+/, Num::Integer
+      end
+
+      state :array_index do
+        rule /\[/, Punctuation
+        rule /\]/, Punctuation
+      end
+
+      state :generic do
+        mixin :array_index
+        mixin :keyword
+        mixin :string
+        mixin :variable
+        mixin :number
+      end
+
+      state :whitespace do
+        rule /[ \t]+/, Text::Whitespace
+      end
+
+      state :comment do
+        rule /(\{%)(\s*)(endcomment)(\s*)(%\})/ do
+          groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
+          reset_stack
+        end
+
+        rule /./, Comment
+      end
+
+      state :raw do
+        rule /[^\{]+/, Text
+
+        rule /(\{%)(\s*)(endraw)(\s*)(%\})/ do
+          groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
+          reset_stack
+        end
+
+        rule /\{/, Text
+      end
+
+      state :assign do
+        mixin :whitespace
+        mixin :end_of_block
+
+        rule /(\s*)(=)(\s*)/ do
+          groups Text::Whitespace, Operator, Text::Whitespace
+        end
+
+        rule /\|/, Punctuation, :filters
+
+        mixin :generic
+      end
+
+      state :include do
+        mixin :whitespace
+
+        rule /([^\.]+)(\.)(html|liquid)/ do
+          groups Name::Attribute, Punctuation, Name::Attribute
+        end
+
+        mixin :variable_tag_markup
+      end
+    end
+  end
+end

data/lib/rouge/lexers/literate_coffeescript.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LiterateCoffeescript < RegexLexer
+      tag 'literate_coffeescript'
+      title "Literate CoffeeScript"
+      desc 'Literate coffeescript'
+      aliases 'litcoffee'
+      filenames '*.litcoffee'
+
+      def markdown
+        @markdown ||= Markdown.new(options)
+      end
+
+      def coffee
+        @coffee ||= Coffeescript.new(options)
+      end
+
+      start { markdown.reset!; coffee.reset! }
+
+      state :root do
+        rule /^(    .*?\n)+/m do
+          delegate coffee
+        end
+
+        rule /^([ ]{0,3}(\S.*?|)\n)*/m do
+          delegate markdown
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/literate_haskell.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LiterateHaskell < RegexLexer
+      title "Literate Haskell"
+      desc 'Literate haskell'
+      tag 'literate_haskell'
+      aliases 'lithaskell', 'lhaskell', 'lhs'
+      filenames '*.lhs'
+      mimetypes 'text/x-literate-haskell'
+
+      def haskell
+        @haskell ||= Haskell.new(options)
+      end
+
+      start { haskell.reset! }
+
+      # TODO: support TeX versions as well.
+      state :root do
+        rule /\s*?\n(?=>)/, Text, :code
+        rule /.*?\n/, Text
+        rule /.+\z/, Text
+      end
+
+      state :code do
+        rule /(>)( .*?(\n|\z))/ do |m|
+          token Name::Label, m[1]
+          delegate haskell, m[2]
+        end
+
+        rule /\s*\n(?=\s*[^>])/, Text, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/llvm.rb

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LLVM < RegexLexer
+      title "LLVM"
+      desc 'The LLVM Compiler Infrastructure (http://llvm.org/)'
+      tag 'llvm'
+
+      filenames '*.ll'
+      mimetypes 'text/x-llvm'
+
+      string = /"[^"]*?"/
+      identifier = /([-a-zA-Z$._][-a-zA-Z$._0-9]*|#{string})/
+
+      state :basic do
+        rule /;.*?$/, Comment::Single
+        rule /\s+/, Text
+
+        rule /#{identifier}\s*:/, Name::Label
+
+        rule /@(#{identifier}|\d+)/, Name::Variable::Global
+        rule /(%|!)#{identifier}/, Name::Variable
+        rule /(%|!)\d+/, Name::Variable
+
+        rule /c?#{string}/, Str
+
+        rule /0[xX][a-fA-F0-9]+/, Num
+        rule /-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
+
+        rule /[=<>{}\[\]()*.,!]|x/, Punctuation
+      end
+
+      builtin_types = %w(
+        void float double half x86_fp80 x86mmx fp128 ppc_fp128 label metadata
+      )
+
+      state :types do
+        rule /i[1-9]\d*/, Keyword::Type
+        rule /#{builtin_types.join('|')}/, Keyword::Type
+      end
+
+      builtin_keywords = %w(
+        begin end true false declare define global constant personality private
+        landingpad linker_private internal available_externally linkonce_odr
+        linkonce weak weak_odr appending dllimport dllexport common default
+        hidden protected extern_weak external thread_local zeroinitializer
+        undef null to tail target triple datalayout volatile nuw nsw nnan ninf
+        nsz arcp fast exact inbounds align addrspace section alias module asm
+        sideeffect gc dbg ccc fastcc coldcc x86_stdcallcc x86_fastcallcc
+        arm_apcscc arm_aapcscc arm_aapcs_vfpcc ptx_device ptx_kernel cc
+        c signext zeroext inreg sret nounwind noreturn noalias nocapture byval
+        nest readnone readonly inlinehint noinline alwaysinline optsize ssp
+        sspreq noredzone noimplicitfloat naked type opaque eq ne slt sgt sle
+        sge ult ugt ule uge oeq one olt ogt ole oge ord uno unnamed_addr ueq
+        une uwtable x
+      )
+
+      builtin_instructions = %w(
+        add fadd sub fsub mul fmul udiv sdiv fdiv urem srem frem shl lshr ashr
+        and or xor icmp fcmp phi call catch trunc zext sext fptrunc fpext
+        uitofp sitofp fptoui fptosi inttoptr ptrtoint bitcast select va_arg ret
+        br switch invoke unwind unreachable malloc alloca free load store
+        getelementptr extractelement insertelement shufflevector getresult
+        extractvalue insertvalue cleanup resume
+      )
+
+      state :keywords do
+        rule /#{builtin_instructions.join('|')}/, Keyword
+        rule /#{builtin_keywords.join('|')}/, Keyword
+      end
+
+      state :root do
+        mixin :basic
+        mixin :keywords
+        mixin :types
+      end
+    end
+  end
+end

data/lib/rouge/lexers/lua/builtins.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# automatically generated by `rake builtins:lua`
+module Rouge
+  module Lexers
+    class Lua
+      def self.builtins
+        @builtins ||= {}.tap do |b|
+          b["basic"] = Set.new %w(_G _VERSION assert collectgarbage dofile error getmetatable ipairs load loadfile next pairs pcall print rawequal rawget rawlen rawset select setmetatable tonumber tostring type xpcall file:close file:flush file:lines file:read file:seek file:setvbuf file:write LUA_CPATH LUA_CPATH_5_2 LUA_INIT LUA_INIT_5_2 LUA_PATH LUA_PATH_5_2 luaopen_base luaopen_bit32 luaopen_coroutine luaopen_debug luaopen_io luaopen_math luaopen_os luaopen_package luaopen_string luaopen_table LUA_ERRERR LUA_ERRFILE LUA_ERRGCMM LUA_ERRMEM LUA_ERRRUN LUA_ERRSYNTAX LUA_HOOKCALL LUA_HOOKCOUNT LUA_HOOKLINE LUA_HOOKRET LUA_HOOKTAILCALL LUA_MASKCALL LUA_MASKCOUNT LUA_MASKLINE LUA_MASKRET LUA_MINSTACK LUA_MULTRET LUA_NOREF LUA_OK LUA_OPADD LUA_OPDIV LUA_OPEQ LUA_OPLE LUA_OPLT LUA_OPMOD LUA_OPMUL LUA_OPPOW LUA_OPSUB LUA_OPUNM LUA_REFNIL LUA_REGISTRYINDEX LUA_RIDX_GLOBALS LUA_RIDX_MAINTHREAD LUA_TBOOLEAN LUA_TFUNCTION LUA_TLIGHTUSERDATA LUA_TNIL LUA_TNONE LUA_TNUMBER LUA_TSTRING LUA_TTABLE LUA_TTHREAD LUA_TUSERDATA LUA_USE_APICHECK LUA_YIELD LUAL_BUFFERSIZE)
+          b["modules"] = Set.new %w(require package.config package.cpath package.loaded package.loadlib package.path package.preload package.searchers package.searchpath)
+          b["bit32"] = Set.new %w(bit32.arshift bit32.band bit32.bnot bit32.bor bit32.btest bit32.bxor bit32.extract bit32.lrotate bit32.lshift bit32.replace bit32.rrotate bit32.rshift)
+          b["coroutine"] = Set.new %w(coroutine.create coroutine.resume coroutine.running coroutine.status coroutine.wrap coroutine.yield)
+          b["debug"] = Set.new %w(debug.debug debug.getuservalue debug.gethook debug.getinfo debug.getlocal debug.getmetatable debug.getregistry debug.getupvalue debug.setuservalue debug.sethook debug.setlocal debug.setmetatable debug.setupvalue debug.traceback debug.upvalueid debug.upvaluejoin)
+          b["io"] = Set.new %w(io.close io.flush io.input io.lines io.open io.output io.popen io.read io.stderr io.stdin io.stdout io.tmpfile io.type io.write)
+          b["math"] = Set.new %w(math.abs math.acos math.asin math.atan math.atan2 math.ceil math.cos math.cosh math.deg math.exp math.floor math.fmod math.frexp math.huge math.ldexp math.log math.max math.min math.modf math.pi math.pow math.rad math.random math.randomseed math.sin math.sinh math.sqrt math.tan math.tanh)
+          b["os"] = Set.new %w(os.clock os.date os.difftime os.execute os.exit os.getenv os.remove os.rename os.setlocale os.time os.tmpname)
+          b["string"] = Set.new %w(string.byte string.char string.dump string.find string.format string.gmatch string.gsub string.len string.lower string.match string.rep string.reverse string.sub string.upper)
+          b["table"] = Set.new %w(table.concat table.insert table.pack table.remove table.sort table.unpack)
+        end
+      end
+    end
+  end
+end