Initial commit.

 - Lexer and Parser fully functional
 - Complex weighting not supported (eg referencing weights of nested lists)
 - Arithmetic weighting not supported
 - Leaderboards not implemented

Author: ExileLord

.gitignore

@@ -0,0 +1,15 @@
+*.opensdf
+*.opendb
+*.sdf
+*.suo
+*.log
+*.tlog
+*.lastbuildstate
+*.cache
+*.pdb
+*.obj
+*.aps
+/.vs
+/.vscode
+
+main.lua

NameList.lua

@@ -0,0 +1,120 @@
+require "NameList.Lexer"
+require "NameList.Parser"
+require "NameList.Entry"
+require "NameList.InnerList"
+
+
+NameList = NameList or {}
+MasterList = NameList.MasterList or {}
+
+local Parser = NameList.Parser
+local InnerList = NameList.InnerList
+local SimpleList = NameList.SimpleList
+local ComplexList = NameList.ComplexList
+local MasterList = NameList.MasterList
+
+
+
+
+
+
+--Checks for cycles in th
+function CycleCheck(list, checked)
+    checked = checked or {}
+end
+
+function NameList:AssertNoLoops()
+    for list, dependencies in pairs(self.complex_dependencies) do
+    end
+end
+
+--[[
+    The NameList, a random name generator
+--]]
+function NameList.new(o)
+    --List must have a name
+    if (o == nil or o.name == nil) then
+        error("NameList constructor called without a valid name parameter.")
+    end
+
+    --Name must be unique
+    --if (NameList.lists[o.name] ~= nil) then
+    --    error("A NameList must have a unique name.")
+    --end
+
+    setmetatable(o, {__index = NameList})
+
+    o.simple_list = SimpleList.new()
+    o.complex_list = ComplexList.new()
+    --o.dependents = {}
+
+    --NameList.lists[o.name] = o
+    return o
+end
+
+function NameList.repairMetatable(o)
+    if getmetatable(o) ~= nil then
+        return
+    end
+    setmetatable(o, {__index = NameList})
+    SimpleList.repairMetatable(o.simple_list)
+    ComplexList.repairMetatable(o.complex_list)
+end
+
+local function is_weight_complex(token_chain)
+    if token_chain == nil or type(token_chain) ~= "table" then
+        return false
+    end
+
+    for i, token in ipairs(token_chain) do
+        if token.type == Token.types.list_placeholder then
+            return true
+        end
+    end
+
+    return false
+end
+
+function NameList:recalculateWeight(o)
+    error("Not implemented yet.")
+end
+
+--Adds an entry to a name list with the given weight
+--(TODO) Weight should be a NameList expression
+function NameList:add(entry, weight)
+    weight = weight or 1
+    assert(weight > 0, "Weight must be greater than zero.")
+
+    if (is_weight_complex(weight)) then
+        self.complex_list:add(entry, weight)
+    else
+        self.simple_list:add(entry,weight)
+    end
+end
+
+--Returns a random name generated this name list based on the weights given to it
+--If this name list references any other lists in its entries, master_list is required or it will error
+function NameList:randomName(master_list)
+    local list
+
+    if self.complex_list:size() == 0 then
+        list = self.simple_list
+    else
+        local weight = math.random() * self.total_weight
+        if weight < self.simple_list.total_weight then
+            list = self.simple_list
+        else
+            list = self.complex_list
+        end
+    end
+
+    local entry = list:randomEntry()
+    local name = entry:toString(master_list)
+    return name
+end
+
+-- Parses a NameList text
+-- returns a MasterList
+function NameList.parse(text)
+    return Parser.parse(text)
+end

NameList/Entry.lua

@@ -0,0 +1,142 @@
+require "NameList.Lexer"
+
+NameList = NameList or {}
+NameList.Entry = NameList.Entry or {}
+
+local Lexer = NameList.Lexer
+local Entry = NameList.Entry
+local EntryPiece = {}
+
+function EntryPiece.new(o)
+    o = o or {}
+    setmetatable(o, {__index = EntryPiece})
+    --is_list
+    --text
+    return o
+end
+
+function EntryPiece:toList(master_list)
+    assert(self.is_list, "Attempted to convert non-list name entry piece into a list.")
+    return master_list:get(self.text)
+end
+
+function Entry.new(o)
+    o = o or {}
+    o.entries = o.entries or {} --List of EntryPiece objects to construct a string with
+    o.references = o.references or {} --Table of with list names as key and number of references as value
+    setmetatable(o, {__index = Entry} )
+
+    if o.text ~= nil then
+        o:parse(o.text)
+    end
+
+    return o
+end
+
+function Entry.repairMetatable(o)
+    setmetatable(o, {__index = Entry})
+    for k, piece in pairs(o.entries) do
+        setmetatable(piece, {__index = EntryPiece})
+    end
+end
+
+local replacement_sequence_table =
+{
+    ["\\"] = "\\",
+    ["{"] = "{",
+    ["}"] = "}",
+    ["\""] = "\"",
+}
+
+local function replace_escape_sequences(s)
+    local sb = {}
+    local next_index = 1
+    while true do
+        local escape_index = string.find(s, "\\", next_index)
+        if escape_index ~= nil then
+            local c = string.sub(s, escape_index+1, escape_index+1)
+            assert(c ~= nil, "Unmatched escape sequence found at end of line")
+            local replacement = replacement_sequence_table[c]
+            assert(replacement ~= nil, "Invalid escape sequence")
+
+            table.insert(sb, string.sub(s, next_index, escape_index-1))
+            table.insert(sb, replacement)
+            next_index = escape_index + 2
+        else
+            table.insert(sb, string.sub(s, next_index))
+            break
+        end
+    end
+
+    local new_string = table.concat(sb)
+    return new_string
+end
+
+function Entry:parse(str)
+
+    local next_index = 1
+    while true do
+        list_open_index = Lexer.findUnescaped(str, "{", next_index)
+        list_close_index = Lexer.findUnescaped(str, "}", next_index)
+
+        --Ensure all lists references are well formed
+        if  list_close_index ~= nil and (list_open_index > list_close_index) then
+            error("Unmatched \"}\" found in name list entry.")
+        end
+
+        if (list_open_index~=nil) ~= (list_close_index~=nil) then
+            if list_open_index ~= nil then
+                error("Unmatched \"{\" found in name list entry.")
+            else
+                error("Unmatched \"}\" found in name list entry.")
+            end
+        end
+
+        --[[if list_open_index ~= nil and (list_close_index - list_open_index == 1) then
+            error("A list reference can't be empty!")
+        end--]]
+        
+        --Extract the currently parsed chunks.
+        local textChunk, listChunk
+        if list_open_index ~= nil then
+            textChunk = string.sub(str, next_index, list_open_index-1)
+            listChunk = string.sub(str, list_open_index+1, list_close_index-1)
+        else
+            textChunk = string.sub(str, next_index)
+        end
+
+        --Insert text chunk
+        if textChunk:len() > 0 then
+            textChunk = replace_escape_sequences(textChunk)
+            local piece = EntryPiece.new{text=textChunk, is_list=false}
+            table.insert(self.entries, piece)
+        end
+
+        --Insert list chunk
+        if listChunk ~= nil then
+            listChunk = replace_escape_sequences(listChunk)
+            local piece = EntryPiece.new{text=listChunk, is_list=true}
+            table.insert(self.entries, piece)
+            self.references[listChunk] = (self.references[listChunk] or 0) + 1
+        end
+        
+        if list_close_index==nil then
+            return
+        end
+        next_index = list_close_index + 1
+    end
+end
+
+function Entry:toString(master_list)
+    local s = ""
+
+    for i, entry in ipairs(self.entries) do
+        if (entry.is_list) then
+            s = s .. entry:toList(master_list):randomName(master_list)
+        else
+            s = s .. entry.text
+        end
+    end
+
+    return s
+end

NameList/Expression.lua

@@ -0,0 +1,6 @@
+--Not supported yet sorry
+
+--Todo: reverse polish notation and shunting-yard algorithm
+
+NameList = NameList or {}
+NameList.Expression = NameList.Expression or {}