「モジュール:Convert」の版間の差分

local spell_module  -- name of module that can spell numbers

local function set_config(args)

text_module = "Module:Convert/text" .. sandbox

extra_module = "Module:Convert/extra" .. sandbox

spell_module = "Module:ConvertNumeric"

data_code = mw.loadData(data_module)

end

local title = mw.title.getCurrentTitle()

if title then

for _, v in ipairs(split(config.nscat or nsdefault, ',')) do

if namespace == tonumber(v) then

end

end

end

end

-- Return wikitext for an error message, including category if specified

-- for the message type.

-- mcode = numbered table specifying the message:

--    mcode[1] = 'cvt_xxx' (string used as a key to get message info)

if msg then

local parts = {}

append = '...'

end

else

s = '?'

end

end

local anchor = msg[4] or ''

end

return 'Convert internal error: unknown message'

function add_warning(parms, level, key, text1, text2)  -- for forward declaration above

-- If enabled, add a warning that will be displayed after the convert result.

-- To reduce output noise, only the first warning is displayed.

end

end

success, speller = pcall(get_speller, spell_module)

if not success or type(speller) ~= 'function' then

return nil

end

-- If no altitude given, use default (zero altitude = sea level).

-- Table gives speed of sound in miles per hour at various altitudes:

-- mach_table[a + 4] = s where

--  s = speed of sound (mph) at that altitude

-- LATER: Should calculate result from an interpolation between the next

660.1, 660.1, 660.1, 662.0, 664.3, 666.5, 668.9, 671.1, 673.4, 675.6,  -- 11 to 20

677.9, 683.7, 689.9, 696.0, 702.1, 708.1, 714.0, 719.9, 725.8, 731.6,  -- 21 to 30

695.0, 688.9, 682.8, 676.6, 670.4, 664.1, 657.8, 652.9, 648.3, 643.7,  -- 41 to 50

639.1, 634.4, 629.6, 624.8, 620.0, 615.2, 613.2, 613.2, 613.2, 613.5,  -- 51 to 60

}

altitude = altitude or 0

if a < -3 then

a = -3

end

return mach_table[a + 4] * 0.44704  -- mph converted to m/s

-- END: Code required only for built-in units.

------------------------------------------------------------------------

local function get_range(word)

-- This is never called to determine a unit name or link because per units

-- are handled as a special case.

__index = function (self, key)

local value

}

-- Return true, t where t is a per unit with unit codes expanded to unit tables,

-- or return false, t where t is an error message table.

override_from(result, unit_table, { 'invert', 'iscomplex', 'default', 'link', 'symbol', 'symlink' })

result.symbol_raw = (result.symbol or false)  -- to distinguish between a defined exception and a metatable calculation

-- Wikignomes may also put two spaces or "&nbsp;" in combinations, so

-- replace underscore, "&nbsp;", and multiple spaces with a single space.

fails = fails or {}

depth = depth and depth + 1 or 1

end

unitcode = unitcode:gsub('_', ' '):gsub('&nbsp;', ' '):gsub('  +', ' ')

local t = utable[unitcode]

if t then

end

if t.per then

end

local combo = t.combination  -- nil or a table of unitcodes

end

local result = shallow_copy(t)

if result.prefixes then

result.si_name = ''

if t and t.prefixes then

local result = shallow_copy(t)

result.si_name = parms.opt_sp_us and si.name_us or si.name

result.si_prefix = si.prefix or prefix

result.scale = t.scale * 10 ^ (si.exponent * t.prefixes)

return true, setmetatable(result, unit_prefixed_mt)

end

end

local err_is_fatal

local combo = collection()

err_is_fatal = true

for item in (unitcode .. '+'):gmatch('%s*(.-)%s*%+') do

end

end

-- If valid, create an automatic per unit for an "x/y" unit code.

-- The unitcode must not include extraneous spaces.

-- Engineering notation (apart from at start and which has been stripped before here),

-- is not supported so do not make a per unit if find text like 'e3' in unitcode.

if success then

return true, result

end

return sep .. id .. mid

end

-- When using gaps, they are inserted before and after the decimal mark.

-- Separators are inserted only before the decimal mark.

if #text < 4 or parms.opt_nocomma or numsep == '' then

return from_en(text)

local fracfmt = {

{ -- Like {{frac}} (fraction slash).

},

},

}

wholestr = nil

end

if do_spell then

if negative then

end

end

end

return wikitext

end

-- with the hands unit (not worth adding code to enforce that).

------------------------------------------------------------------------

local leading_plus, prefix, numstr, slashes, denstr =

text:match('^%s*(%+?)%s*(.-)%s*(%d+)%s*(/+)%s*(%d+)%s*$')

return nil

end

if prefix == '' then

wholestr = ''

-- Before processing, the input text is cleaned:

-- * Any thousand separators (valid or not) are removed.

--  That replaces Unicode minus with '-'.

-- If successful, the returned info table contains named fields:

while #remainder > 0 do

local ref, spaces

if ref then

table.insert(refs, ref)

local valstr

for _, prefix in ipairs({ '-', MINUS, '&minus;' }) do

local plen = #prefix

if clean:sub(1, plen) == prefix then

valstr = clean:sub(plen + 1)

break

end

end

end

if isnegative and (value ~= 0) then

value = -value

end

return true, {

value = value,

singular = singular,

clean = clean,

--  v = value of text (text is a number)

--  f = true if value is an integer

if text then

local number = tonumber(to_en(text))

if number then

return number, (fracpart == 0)

end

--    p2 is text to insert before the output unit

--    p1 or p2 may be nil to mean "no preunit"

end

end

end

end

preunit1 = preunit1 or ''

local trim1 = strip(preunit1)

return nil

end

end

preunit2 = preunit2 or ''

local trim2 = strip(preunit2)

end

preunit2 = nil

end

return preunit1, preunit2

end

-- Return before .. rtext .. after

-- where rtext is the text that separates two values in a range.

local rtext, adj_text, exception

if type(range) == 'table' then

-- Table must specify range text for ('off' and 'on') or ('input' and 'output'),

end

end

rtext = '&nbsp;– '

end

local function get_composite(parms, iparm, in_unit_table)

-- would result in a call to this function with

--  iparm = 3 (parms[iparm] = "2", just after the first unit)

kv_pairs.sing = nil

end

for loc_name, loc_value in pairs(kv_pairs) do

local en_name = text_code.en_option_name[loc_name]

if en_name then

if loc_value == '' then

add_warning(parms, 2, 'cvt_empty_option', loc_name)

else

local minimum

local number, is_integer = get_number(loc_value)

minimum = 2

if number and number < 0 then

end

else

end

if number and is_integer and number >= minimum then

en_value = number

else

end

end

else

if en_value and en_value:sub(-1) == '?' then

en_value = en_value:sub(1, -2)

end

if parms.abbr then

parms.abbr_org = parms.abbr  -- original abbr, before any flip

elseif parms.opt_hand_hh then

else

parms.abbr = 'out'  -- default is to abbreviate output only (use symbol, not name)

end

if parms.opt_spell_out and not abbr_entered then

local function simple_get_values(parms)

-- If input is like "{{convert|valid_value|valid_unit|...}}",

-- The valid_value is not negative and does not use a fraction, and

-- no options requiring further processing of the input are used.

-- Testing shows this function is successful for 96% of converts in articles,

-- and that on average it speeds up converts by 8%.

local clean = to_en(strip(parms[1] or ''), parms)

local value = tonumber(clean)

if not value then return end

end

--  parms is a table of all arguments passed to the template

--        converted to named arguments, and

--  unit is the input unit table;

-- or return false, t where t is an error message table.

-- The returned input unit table may be for a fake unit using the specified

-- unit code as the symbol and name, and with bad_mcode = message code table.

-- whitespace entered in the template, and whitespace is used by some

-- parameters (example: the numbered parameters associated with "disp=x").

local kv_pairs = {}  -- table of input key:value pairs where key is a name; needed because cannot iterate parms and add new fields to it

for k, v in pairs(args) do

kv_pairs[k] = v

end

end

local success, msg = translate_parms(parms, kv_pairs)

if not success then return false, msg end

local success, i, in_unit, in_unit_table = simple_get_values(parms)

if not success then

local valinfo

success, valinfo, i = get_values(parms)

success, in_unit_table = lookup(parms, in_unit, 'no_combination')

if not success then

if parms.opt_ignore_error then  -- display given unit code with no error (for use with {{val}})

in_unit_table = ''  -- suppress error message and prevent processing of output unit

end

end

in_unit_table.valinfo = valinfo

end

if in_unit_table.builtin == 'mach' then

if success then

i = i + 1

end

end

i = i + 1

local precision, is_bad_precision

end

end

if set_precision(strip(parms[i])) then

i = i + 1

end

if parms.opt_adj_mid then

i = i + 1

else

end

end

parms.precision = precision

end

end

local fudge = 1e-14  -- {{Order of magnitude}} adds this, so we do too

local prec, minprec, adjust

local subunit_ignore_trailing_zero

local subunit_more_precision  -- kludge for "in" used in input like "|2|ft|6|in"

end

if in_builtin == 'mach' or out_builtin == 'mach' then

if in_builtin == 'mach' then

end

return true, {

outvalue = invalue * (inscale / outscale),

end

local sortspan

sortspan = parms.opt_sortable_debug and

parms.join_before = sortspan

end

if parms.table_align then

local style = 'style="text-align:' .. parms.table_align .. ';'

local joins = {}

for i = 1, 2 do

--      is "1", or like "1.00", or is a fraction with value < 1;

--  (and more fields shown below, and a calculated 'absvalue' field).

-- or return false, t where t is an error message table.

-- Input info.clean uses en digits (it has been translated, if necessary).

-- Output show uses en or non-en digits as appropriate, or can be spelled.

if out_current.builtin == 'hand' then

return cvt_to_hand(parms, info, in_current, out_current)

end

local outvalue, extra = convert(parms, invalue, info, in_current, out_current)

if parms.need_table_or_sort then

outvalue = -outvalue

end

local denominator = out_current.frac

if denominator then

show = format('%.0f', floor((outvalue / n) + 0.5) * n)

end

else

local inclean = info.clean

local linked_pages  -- to record linked pages so will not link to the same page more than once

-- Return wikilink "[[link|id]]", possibly abbreviated as in examples:

--  [[Mile|mile]]  --> [[mile]]

-- * no link given (so caller does not need to check if a link was defined); or

-- * link has previously been used during the current convert (to avoid overlinking).

if not link or link == '' or linked_pages[link_key] then

return id

else

i = 3

end

vname = split(unit_table.varname, '!')[i]

local per = unit_table.per

if per then

local unit1 = per[1]  -- top unit_table, or nil

local unit2 = per[2]  -- bottom unit_table

return symbol  -- for exceptions that have the symbol built-in

end

end

end

unit_table.sep = ''

end

end

if multiplier then

local abbr_org = parms.abbr_org

local adjectival = parms.opt_adjectival

local lk = parms.lk

local want_link = (lk == 'on' or lk == inout)

local inout = unit_table.inout

local abbr = parms.abbr

info.show = info.show ..

elseif number_word then

local number_id

return  preunit .. id1

end

local join1 = parms.joins[1]

if join1 == ' (' or join1 == ' [' then

-- For simplicity and because more not needed, handle one range item only.

local prefix2 = make_id(parms, 2, first_unit) .. '&nbsp;'

end

return preunit .. result

local range = parms.range

if range and not add_unit then

end

local id = range and make_id(parms, range.n + 1, first_unit) or id1

-- Processing required for each output unit.

-- Return block of text to represent output (value/unit).

local id1, want_name = make_id(parms, 1, out_current)

local sep = out_current.sep  -- set by make_id

if range then

-- For simplicity and because more not needed, handle one range item only.

end

return preunit .. result

local range = parms.range

if range and not add_unit then

end

local id = range and make_id(parms, range.n + 1, out_current) or id1

if was_hyphenated then

add_unit = false

result = show

else

end

end

-- for a single output (which is not a combination or a multiple);

-- or return false, t where t is an error message table.

end

return true, process_one_output(parms, out_unit_table)

-- for an output which is a multiple (like 'ftin');

-- or return false, t where t is an error message table.

local multiple = out_unit_table.multiple  -- table of scaling factors (will not be nil)

local combos = out_unit_table.combination  -- table of unit tables (will not be nil)

local disp = parms.disp

local want_name = (abbr_org == nil and (disp == 'or' or disp == 'slash')) or

local mid = parms.opt_flip and parms.mid or ''

local sep1 = '&nbsp;'

local tfrac, thisvalue, strforce

local out_current = combos[i]

local scale = multiple[i]

if i == 1 then  -- least significant unit ('in' from 'ftin')

end

local strval

if strforce and outvalue == 0 then

sign = ''  -- any sign is in strforce

elseif tfrac then

local wholestr = (thisvalue > 0) and tostring(thisvalue) or nil

else

strval = (thisvalue == 0) and from_en('0') or with_separator(parms, format(fmt, thisvalue))

if do_spell then

end

end

local success, result2 = make_result(valinfo[i+1])

if not success then return false, result2 end

end

end

local function process(parms, in_unit_table, out_unit_table)

-- or return false, t where t is an error message table.

linked_pages = {}

local success, bad_output

local out_unit = parms.out_unit

if bad_input_mcode or parms.opt_input_unit_only then

bad_output = ''

else

parms.out_unit = out_unit

if not success then

end

end

local flipped = parms.opt_flip and not bad_input_mcode

end

end

end

end

end

end

else

end

end

end

if parms.join_before then

end

local wikitext

if bad_input_mcode then

if bad_input_mcode == '' then

else

end

elseif parms.table_joins then

else

end

if parms.warnings and not bad_input_mcode then

wikitext = wikitext .. parms.warnings

end

end

local function main_convert(frame)

-- Do convert, and if needed, do it again with higher default precision.

set_config(frame.args)

if success then

success, result, out_unit_table = process(parms, in_unit_table, out_unit_table)

if success and parms.do_convert_again then

end

end

end