MathML::LaTeX::BuiltinEnvironments

     # File lib/math_ml/latex.rb, line 941
941:                         def initialize
942:                                 add_environment("array", "matrix")
943: 
944:                                 super
945:                         end

      # File lib/math_ml/latex.rb, line 947
 947:                         def env_array
 948:                                 layout = @scanner.scan_block ? @scanner.matched : @scanner.scan(/./)
 949:                                 l = Scanner.new(layout=~RE::BLOCK ? layout[RE::BLOCK, 1] : layout)
 950:                                 t = Table.new
 951:                                 aligns = Array.new
 952:                                 vlines = Array.new
 953:                                 vlined = l.check(/\|/)
 954:                                 columned = false
 955:                                 until l.eos?
 956:                                         c = l.scan_any
 957:                                         raise ParseError.new("Syntax error.", layout[/\A.*(#{Regexp.escape(c+l.rest)}.*\z)/, 1]) unless c=~/[clr\|@]/
 958: 
 959:                                         if c=='|'
 960:                                                 aligns << Align::CENTER if vlined
 961:                                                 vlines << Line::SOLID
 962:                                                 vlined = true
 963:                                                 columned = false
 964:                                         else
 965:                                                 vlines << Line::NONE if columned
 966:                                                 vlined = false
 967:                                                 columned = true
 968:                                                 case c
 969:                                                 when 'l'
 970:                                                         aligns << Align::LEFT
 971:                                                 when 'c'
 972:                                                         aligns << Align::CENTER
 973:                                                 when 'r'
 974:                                                         aligns << Align::RIGHT
 975:                                                 when '@'
 976:                                                         aligns << Align::CENTER
 977:                                                         l.scan_any
 978:                                                 end
 979:                                         end
 980:                                 end
 981:                                 t.aligns = aligns
 982:                                 t.vlines = vlines
 983: 
 984:                                 layout = layout[RE::BLOCK, 1] if layout=~RE::BLOCK
 985:                                 raise ParseError.new('Need parameter here.') if layout==""
 986: 
 987:                                 hlines = Array.new
 988:                                 row_parsed = false
 989:                                 hlined = false
 990:                                 until @scanner.peek_command=="end"
 991:                                         raise ParseError.new('Matching \end not exist.') if @scanner.eos?
 992:                                         if @scanner.peek_command=="hline"
 993:                                                 @scanner.scan_command
 994:                                                 t << Tr.new unless row_parsed
 995:                                                 hlines << Line::SOLID
 996:                                                 row_parsed = false
 997:                                                 hlined = true
 998:                                         else
 999:                                                 hlines << Line::NONE if row_parsed
1000:                                                 t << env_array_row(l.string)
1001:                                                 @scanner.scan(RE::WBSLASH)
1002:                                                 row_parsed = true
1003:                                                 hlined = false
1004:                                         end
1005:                                 end
1006:                                 t.hlines = hlines
1007: 
1008:                                 if hlined
1009:                                         tr = Tr.new
1010:                                         (0..vlines.size).each {|i| tr << Td.new}
1011:                                         t << tr
1012:                                 end
1013: 
1014:                                 @scanner.scan_command
1015:                                 raise ParseError.new("Environment mismatched.") unless @scanner.check_block && @scanner[1]=="array"
1016:                                 @scanner.scan_block
1017:                                 t
1018:                         end

      # File lib/math_ml/latex.rb, line 1020
1020:                         def env_array_row(layout)
1021:                                 l = Scanner.new(layout)
1022:                                 r = Tr.new
1023:                                 first_column = true
1024:                                 vlined = l.check(/\|/)
1025:                                 until l.eos?
1026:                                         c = l.scan(/./)
1027:                                         if c=='|'
1028:                                                 r << Td.new if vlined
1029:                                                 vlined = true
1030:                                                 next
1031:                                         else
1032:                                                 vlined = false
1033:                                                 case c
1034:                                                 when 'r', 'l', 'c'
1035:                                                 when '@'
1036:                                                         r << parse_into(l.scan_any, Td.new)
1037:                                                         next
1038:                                                 end
1039:                                                 if first_column
1040:                                                         first_column = false
1041:                                                 else
1042:                                                         raise ParseError.new("Need more column.", @scanner.matched.to_s) unless @scanner.scan(/&/)
1043:                                                 end
1044:                                                 r << push_container(Td.new) do |td|
1045:                                                         td << parse_to_element(true) until @scanner.peek_command=="end" || @scanner.check(/(&|\\\\)/) || @scanner.eos?
1046:                                                 end
1047:                                         end
1048:                                 end
1049:                                 r << Td.new if vlined
1050:                                 raise ParseError.new("Too many column.") if @scanner.check(/&/)
1051:                                 r
1052:                         end

      # File lib/math_ml/latex.rb, line 1054
1054:                         def env_matrix
1055:                                 t = Table.new
1056:                                 hlines = Array.new
1057:                                 hlined = false
1058:                                 row_parsed = false
1059:                                 until @scanner.peek_command=="end"
1060:                                         raise ParseError.new('Matching \end not exist.') if @scanner.eos?
1061:                                         if @scanner.peek_command=="hline"
1062:                                                 @scanner.scan_command
1063:                                                 t << Tr.new unless row_parsed
1064:                                                 hlines << Line::SOLID
1065:                                                 row_parsed = false
1066:                                                 hlined = true
1067:                                         else
1068:                                                 hlines << Line::NONE if row_parsed
1069:                                                 t << (r = Tr.new)
1070:                                                 r << (td=Td.new)
1071:                                                 until @scanner.check(RE::WBSLASH) || @scanner.peek_command=="end" || @scanner.eos?
1072:                                                         push_container(td) do |e|
1073:                                                                 e << parse_to_element(true) until @scanner.peek_command=="end" || @scanner.check(/(&|\\\\)/) || @scanner.eos?
1074:                                                         end
1075:                                                         r << (td=Td.new) if @scanner.scan(/&/)
1076:                                                 end
1077:                                                 @scanner.scan(RE::WBSLASH)
1078:                                                 row_parsed = true
1079:                                                 hlined = false
1080:                                         end
1081:                                 end
1082:                                 t.hlines = hlines
1083: 
1084:                                 t << Tr.new if hlined
1085: 
1086:                                 raise ParseError.new("Need \\end{array}.") unless @scanner.peek_command=="end"
1087:                                 @scanner.scan_command
1088:                                 raise ParseError.new("Environment mismatched.") unless @scanner.check_block && @scanner[1]=="matrix"
1089:                                 @scanner.scan_block
1090:                                 t
1091:                         end

      # File lib/math_ml/latex.rb, line 1093
1093:                         def env_matrix_row
1094:                                 r = Tr.new
1095:                                 until @scanner.check(RE::WBSLASH) || @scanner.peek_command=="end"
1096:                                         r << push_container(Td.new) do |td|
1097:                                                 td << parse_to_element(true) until @scanner.peek_command=="end" || @scanner.check(/(&|\\\\)/) || @scanner.eos?
1098:                                         end
1099:                                 end
1100:                         end