Moduuli:fi-nom

Wikisanakirjasta

Moduulia käytetään fi-subs-valo-, fi-subs-palvelu-, ... -mallineista käsin (katso Suomen substantiivien mallineet).

Moduuli muotoilee taivutustaulukon solujen tekstin. Taivutustaulukon koodi on sivulla fi-nom/taulukko.

#invoke:lla kutsuttavat funktiot[muokkaa]

Taivutustaulukko[muokkaa]

Parametrit[muokkaa]

  • yks: viiva (-), jos yksikköä ei ole
  • mon: viiva (-), jos monikkoa ei ole
  • vokaalisointu: a tai ä sen mukaan kumpaa taivutusmuodoissa käytetään
  • tarkenne: taulukkoon liitettävä tarkennusteksti, jos osiossa on useita taulukoita, esim. taivutustyypin numero ja kirjain

Seuraaviille parametreille voi antaa useita arvoja käyttämällä niiden perässä numeroa (esim. y-gen1, y-gen2...).

  • y-nom: yksikön nominatiivi
  • y-gen: yksikön genetiivi
  • y-part: yksikön partitiivi
  • y-iness: yksikön inessiivi
  • y-elat: yksikön elatiivi
  • y-ill: yksikön illatiivi
  • y-adess: yksikön adessiivi
  • y-abl: yksikön ablatiivi
  • y-all: yksikön allatiivi
  • y-ess: yksikön essiivi
  • y-ess-vanha: sulkuihin tuleva yksikön essiivi
  • y-tr: yksikön translatiivi
  • y-abess: yksikön abessiivi
  • mon-nom: monikon nominatiivi
  • mon-gen: monikon genetiivi
  • mon-gen-vanha: sulkuihin tuleva monikon genetiivi
  • mon-part: monikon partitiivi
  • mon-part-vanha: sulkuihin tuleva monikon partitiivi
  • mon-iness: monikon inessiivi
  • mon-elat: monikon elatiivi
  • mon-ill: monikon illatiivi
  • mon-ill-vanha: sulkuihin tuleva monikon illatiivi
  • mon-adess: monikon adessiivi
  • mon-abl: monikon ablatiivi
  • mon-all: monikon allatiivi
  • mon-ess:monikon essiivi
  • mon-ess-vanha: sulkuihin tuleva monikon essiivi
  • mon-tr: monikon translatiivi
  • mon-abess: monikon abessiivi
  • mon-ins: monikon instruktiivi
  • mon-kom: monikon komitatiivi

local apu = require('Moduuli:Mallinetyokalut')
local kielilinkki = require("Moduuli:Kielilinkki")

local m = {}


-- Taulukon solun muotoilu (paitsi komitatiivi).
local function solu(piilota, args_t, muoto, pohja)
    if piilota then
        return "–"
    end
    
    local muodot = args_t[muoto]
    local vanhat_muodot = args_t[muoto .. '-vanha']
    local vanhat = ''
    local kuvaus
    
    if pohja then
        kuvaus = pohja
    else
        kuvaus = "tm/*/s/" .. muoto
    end
    
    if vanhat_muodot then
        local arr = apu.map(function (sana) return '(' .. kielilinkki.linkki{ kieli = "fi", kohde = sana, kuvaus = kuvaus } .. ')' end, vanhat_muodot)
        vanhat = '<br/>' .. mw.text.listToText( arr, '<br/>', '<br/>')
    end
    
    if muodot then
        local arr = apu.map(function (sana) return kielilinkki.linkki{ kieli = "fi", kohde = sana, kuvaus = kuvaus } end, muodot)
        return mw.text.listToText( arr, '<br/>', '<br/>') .. vanhat
    end
    return ''
end

-- Taulukon komitatiivin solun muotoilu.
local function solu_komitatiivi(piilota, args_t, muoto, vokaalisointu, pohja)
    if piilota then
        return "–"
    end
    
    local kuvaus
    
    if pohja then
        kuvaus = pohja
    else
        kuvaus = "tm/*/s/" .. muoto
    end
    
    if args_t[muoto] then
        local arr = apu.map(
            function (sana) 
                -- komitatiivi linkitetään yksikön 3. persoonan -een-muotoon
                local y3muoto = sana:gsub("-$", "en")
                
                return kielilinkki.linkki{ 
                    kieli  = "fi", 
                    kohde  = y3muoto,
                    teksti = sana, 
                    kuvaus = kuvaus,
                    ["kuvaus-param"] = { 
                        [5]  = y3muoto,
                        [8]  = sana:gsub("-$", ""), -- taivm-mon-kom-mallineen 3. parametri
                        [9] = vokaalisointu
                    }
                } 
            end, args_t[muoto])
        
        return mw.text.listToText( arr, '<br/>', '<br/>') .. '<br/>+ ' .. mw.getCurrentFrame():expandTemplate{ title = 'fi-om' }
    end

    return ''
end


function m.Taivutustaulukko(frame)
    local args = frame.args
    local cur = frame
    
    if cur.args.frame == "+parent" then
        pframe = cur:getParent()
        args = apu.yhdista(args, pframe.args)
        cur = pframe
    end
    
    local otsikko
    if args.tarkenne then
        otsikko = "Taivutus (" .. args.tarkenne .. ") "
    else
        otsikko = "Taivutus "
    end
    
    local args_t = apu.numeroidut_parametrit(args, { 
                                                 'y-nom',
                                                 'y-gen',
                                                 'y-part',
                                                 'y-iness',
                                                 'y-elat',
                                                 'y-ill',
                                                 'y-adess',
                                                 'y-abl',
                                                 'y-all',
                                                 'y-ess', 'y-ess-vanha',
                                                 'y-tr',
                                                 'y-abess',
                                                 'mon-nom',
                                                 'mon-gen',  'mon-gen-vanha',
                                                 'mon-part', 'mon-part-vanha',
                                                 'mon-iness',
                                                 'mon-elat',
                                                 'mon-ill',  'mon-ill-vanha',
                                                 'mon-adess',
                                                 'mon-abl',
                                                 'mon-all',
                                                 'mon-ess',  'mon-ess-vanha',
                                                 'mon-tr',
                                                 'mon-abess',
                                                 'mon-ins',
                                                 'mon-kom'
    })
    
    local piilota_yks = (args.yks == "-")
    local piilota_mon = (args.mon == "-")
    
    local y_akk   = "–"
    local mon_akk = "–"
    
    if not piilota_yks then
        y_akk = (args['y-nom'] or "–") .. '; ' .. (args['y-gen'] or "–")
    end
    
    if not piilota_mon then
        mon_akk = apu.ensimmainen_ei_tyhja{args['mon-akk'], args['mon-nom']}
    end

    return frame:expandTemplate{
        title = "fi-nom/taulukko",
        args = {
            ['otsikko']  = otsikko,
            ['y-nom']     = solu(piilota_yks, args_t, 'y-nom'),
            ['y-gen']     = solu(piilota_yks, args_t, 'y-gen', 'tm/*/s/y-gen+y-akk'),
            ['y-part']    = solu(piilota_yks, args_t, 'y-part'),
            ['y-akk']     = y_akk,

            ['y-iness']   = solu(piilota_yks, args_t, 'y-iness'),
            ['y-elat']    = solu(piilota_yks, args_t, 'y-elat'),
            ['y-ill']     = solu(piilota_yks, args_t, 'y-ill'),

            ['y-adess']   = solu(piilota_yks, args_t, 'y-adess'),
            ['y-abl']     = solu(piilota_yks, args_t, 'y-abl'),
            ['y-all']     = solu(piilota_yks, args_t, 'y-all'),

            ['y-ess']     = solu(piilota_yks, args_t, 'y-ess'),
            ['y-tr']      = solu(piilota_yks, args_t, 'y-tr'),
            ['y-abess']   = solu(piilota_yks, args_t, 'y-abess'),

            ['mon-nom']   = solu(piilota_mon, args_t, 'mon-nom', 'tm/*/s/mon-nom+mon-akk'),
            ['mon-gen']   = solu(piilota_mon, args_t, 'mon-gen'),
            ['mon-part']  = solu(piilota_mon, args_t, 'mon-part'),
            ['mon-akk']   = mon_akk,

            ['mon-iness'] = solu(piilota_mon, args_t, 'mon-iness'),
            ['mon-elat']  = solu(piilota_mon, args_t, 'mon-elat'),
            ['mon-ill']   = solu(piilota_mon, args_t, 'mon-ill'),

            ['mon-adess'] = solu(piilota_mon, args_t, 'mon-adess'),
            ['mon-abl']   = solu(piilota_mon, args_t, 'mon-abl'),
            ['mon-all']   = solu(piilota_mon, args_t, 'mon-all'),

            ['mon-ess']   = solu(piilota_mon, args_t, 'mon-ess'),
            ['mon-tr']    = solu(piilota_mon, args_t, 'mon-tr'),
            ['mon-abess'] = solu(piilota_mon, args_t, 'mon-abess'),

            ['mon-ins']   = solu(piilota_mon, args_t, 'mon-ins'),
            ['mon-kom']   = solu_komitatiivi(piilota_mon, args_t, 'mon-kom', args.vokaalisointu),
        }
    }
end

return m