CLX

--# Main
-- CL Parser

src = {}
src.factorial = [[
    function factorial : num, cval {
        if $cval ~= 0 {
            if $num <= 1 {
                return $cval;
            } else {
                return factorial($num - 1, $cval * $num);
            };
        } else {
            return factorial($num - 1, $num);
        };
    };
    print(factorial(10,0));
]]

src.errors = [[
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;
]]
src.typetest = [[
type number : $value=0 {
    @mult : $num {
        return $value * $num;
    };
    @add : $num {
        return $value + $num;
    };
    @get : null {
        return $value;
    };
};
##doesn't work yet
type logger : $t=0 {
    @print : $title, $val {
        print($title, $t, $val);
    };
};

new logger: disp(": ");
logger > print("title", "val);

new number:zero();
print "0*10: " .. @zero>mult(10);

new number : three(3);
print "3*6: " .. @three>mult(6);
print "3+10: " .. @three > add (10);

print "Value of @three: " .. @three > get();
]]

-- Use this function to perform your initial setup
function setup()
    local t = os.clock()
    parse(src.typetest)
end

-- This function gets called once every frame
function draw()
    -- This sets a dark background color
    background(40, 40, 50)

    -- This sets the line thickness
    strokeWidth(5)

    -- Do your drawing here

end


--# StrOps
function getArgsFromString(argStr)
    local args = {}
    local aPos, aCount, aCurrent, aLevel, aLChar = 1, 1, "", 0, ""
    local aChars = {["("] = ")", ["{"] = "}"}
    local aStr = ""
    --print(argStr)
    while aPos <= #argStr do
        local cc = argStr:sub(aPos, aPos)
        aStr = aStr .. cc .. ": level " .. aLevel .. ", end " .. aLChar .. "\n"
        if cc == "(" or cc == "{" then
            aLevel = aLevel + 1
            aLChar = aChars[cc]
            aCurrent = aCurrent .. cc
        elseif cc == aLChar then
            aLevel = aLevel - 1
            aCurrent = aCurrent .. cc
            aLChar = ""
        elseif (cc == "," and aLevel == 0) or aPos >= #argStr then
            if aPos >= #argStr and cc ~= "," then
                aCurrent = aCurrent .. cc
            end
            table.insert(args, aCurrent)
            --print("Arg: ", aCurrent)
            aCurrent = ""
            aPos = aPos + 1
        else
            aCurrent = aCurrent .. cc
        end
        --print(cc)
        aPos = aPos + 1
    end
    return args
end

--# Parse
function trim(s)
    return (tostring(s):gsub("^%s*(.-)%s*$", "%1"))
end

local key, proc, rank = {}, {}, {}

local vars = {}

local types = {}

local objects = {}

-- for $varname : start, end, step { statement; };
key["for"] = "for%s-%$(%S+)%s-:%s-([^,]-),%s-([^,{]-),%s-([^{]-)%s-(%b{});"
proc["for"] = function(lvars, var, start, stop, step, src)
    lvars[var] = start
    while tonumber(lvars[var]) <= tonumber(stop) do
        parse(src:sub(2, -2), lvars)
        lvars[var] = lvars[var] + eval(step, lvars)
    end
end
rank["for"] = 0
-- while conditions { statement; };
key["while"] = "while%s-([^{]-)%s-(%b{});"
proc["while"] = function(lvars, conditions, src)
    --lvars[var] = start
    while isTrue(conditions, lvars) do
        parse(src:sub(2, -2), lvars)
    end
end
rank["while"] = 0

-- if conditions { statement; };
key["if"] = "if%s-([^{]-)%s-(%b{});"
proc["if"] = function(lvars, conditions, src)
    --lvars[var] = start
    if isTrue(conditions, lvars) then
        parse(src:sub(2, -2), lvars)
    end
end
rank["if"] = 0

key["if.-{.-}%s-else%s-%b{}"] = "if%s-([^{]-)%s-(%b{})%s-else%s-(%b{});"
proc["if.-{.-}%s-else%s-%b{}"] = function(lvars, conditions, src, src2)
    --lvars[var] = start
    if isTrue(conditions, lvars) then
        parse(src:sub(2, -2), lvars)
    else
        parse(src2:sub(2, -2), lvars)
    end
end
rank["if.-{.-}%s-else%s-%b{}"] = 1

key["if.-{.-}%s-elseif"] = "if%s-([^{]-)%s-(%b{})%s-(elseif%s-[^}]+%s-%b{}.-;~)"
proc["if.-{.-}%s-elseif"] = function(lvars, conditions, src, chunk2)
    --lvars[var] = start
    if isTrue(conditions, lvars) then
        parse(src:sub(2, -2), lvars)
    else
        parse(chunk2:sub(5, -1), lvars)
    end
end
rank["if.-{.-}%s-elseif"] = 2

key["return"] = "return(.-);"
proc["return"] = function(lvars, args)
    --print("Returning...")
    args = trim(args)
    --[[
    _RETURN = ""
    for arg in args:gmatch("([^,]-),") do
        _RETURN = eval(arg, lvars)
    end
    --]]
    _RETURN = eval(args, lvars)
    --print(_RETURN)
end
rank["return"] = 0

key["print"] = "print%s+(.-);"
proc["print"] = function(lvars, stuff)
    stuff = "," .. stuff .. ","
    for v in stuff:gmatch(",%s-(.-),") do
        print(eval(v, lvars))
    end
end
rank["print"] = 2

--[[
EXAMPLE TYPEDEF:
local name = {}
name.__src = {}
name.__run = {}
name.__src.method1 = {"$arg1, $arg2"}
name.__run.method1 = function(arg1, arg2) end
name.__args = "$parameter1=def_val"
name.__vars = {}
    name.__vars.parameter1 = "def_val"
types[tn] = name
--]]
key["type"] = "type%s+(%S-)%s-:%s-([^{]-)%s-(%b{});"
proc["type"]= function(lvars, name, vars, src)
    local t = {}
    t.__methods = {}
    t.__src = {}
    t.__vars = {}
    t.__args = vars
    t.__run = {}
    for v in (vars..","):gmatch("([^,]+)%s-,") do
        t.__vars[v:match("(%w+)%s-=%s-[^,+]")] = v:match("%w+%s-=%s-([^,-])")
    end
    for method, args, body in src:gmatch("@(%w+)%s-:%s-([^{]+)(%b{});") do
        t.__src[method] = {args, body:sub(2,-2)}
        t.__run[method] = function(self, arg) parse(self.__src[method][2], arg) end
    end
    types[name] = t
end
rank.typedef = 2

key["new"] = "new%s+([%w_]+)%s-:%s-([%w_]+)%s-(%b());"
proc["new"] = function(lvars, t, name, args)
    if types[t] then
        objects[name] = types[t]
        local arg = getArgsFromString(args:sub(2,-2))
        local a = 1
        for av in types[t].__args:gmatch("([%w_]+)") do
            arg[av] = arg[a]
            --print(av, arg[a])
            a = a + 1
        end
        for i, v in pairs(arg) do
            objects[name].__vars[i] = v
        end
        objects[name].__type = t
    else
        clError("new " .. t .. ":" .. name .. args, "Use of undeclared type " .. t)
    end
end

--@name>method(args);
--@[%w_]+%s-%>%s-[%w_]+%s-%b();
key["%@%s-[%w_]+%s->%s-[%w_]+%s-%b()"] = "%@%s-([%w_]+)%s->%s-([%w_]+)%s-(%b())"
proc["%@%s-[%w_]+%s->%s-[%w_]+%s-%b()"] = function(lvars, obj, method, args)
    if objects[obj] and objects[obj].__src[method] then
        local arg = getArgsFromString(args:sub(2,-2))
        local a = 1
        for i, v in ipairs(arg) do
            arg[i] = eval(v, lvars)
            --print(i, v)
        end
        for av in objects[obj].__src[method][1]:gmatch("([%w_]+)") do
            arg[av] = eval(arg[a], lvars)
            --print(av, arg[a])
            a = a + 1
        end
        for i, v in pairs(objects[obj].__vars) do
            arg[i] = eval(v, lvars)
        end
        objects[obj].__run[method](objects[obj], arg)
    elseif objects[obj] and not objects[obj].__src[method] then
        clError(
            obj..">"..method..args,
            "Attempt to call undefined method "..method.." of "..objects[obj].__type.." "..obj
        )
    else
        clError(obj..">"..method..args, "Attempt to call method "..method.." of null object")
    end
end
rank["%@%s-[%w_]+%s->%s-[%w_]+%s-%b()"] = 2

function runMethod(str, lvars)
    _RETURN = nil
    parse(str, lvars)
    return _RETURN
end

local ops, opProc = {}, {}

ops["="] = "$([%w_]+)%s-=%s-([^;]+);"
opProc["="] = function(lvars, var, val)
    vars[var] = eval(val, lvars)
end

ops["+="] = "$([%w_]+)%s-%+%s-=%s-([^;]+);"
opProc["+="] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var.."+="..val, "Operation on undefined variable "..var)
        return
    end
    local res = eval(val, lvars)
    if not(tonumber(res)) then
        clError("$"..var.."+="..val, "Operation on numeric $" .. var .. " using non-numeric value")
        return
    end
    vars[var] = vars[var] + eval(val, lvars)
end

ops["++"] = "$([%w_]+)%s-%+%s-%+%s-;"
opProc["++"] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var.."++", "Operation on undefined variable "..var)
        return
    elseif not tonumber(vars[var]) then
        clError("$"..var.."++", "Numeric operation on variable "..var .. " of non-numeric type " .. type(vars[var]))
        return
    end
    vars[var] = vars[var] + 1
end

ops["-="] = "$([%w_]+)%s-%-%s-=%s-([^;]+);"
opProc["-="] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var.."-="..val, "Operation on undefined variable "..var)
        return
    elseif not tonumber(vars[var]) then
        clError("$"..var.."+="..val, "Numeric operation on variable "..var .. " of non-numeric type " .. type(vars[var]))
        return
    end
    local res = eval(val, lvars)
    if not(tonumber(res)) then
        clError("$"..var.."-="..val, "Operation on numeric $" .. var .. " using non-numeric value")
        return
    end
    vars[var] = vars[var] + eval(val, lvars)
end

ops["--"] = "$([%w_]+)%s-%-%s-%-%s-;"
opProc["--"] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var.."--", "Operation on undefined variable "..var)
        return
    elseif not tonumber(vars[var]) then
        clError("$"..var.."++", "Numeric operation on variable "..var .. " of non-numeric type " .. type(vars[var]))
        return
    end
    vars[var] = vars[var] - 1
end

ops[".="] = "$([%w_]+)%s-%.%s-=%s-([^;]+);"
opProc[".="] = function(lvars, var, val)
    if not vars[var] then
        clError("$"..var..".="..val, "Operation on undefined variable "..var)
        return
    end
    vars[var] = tostring(vars[var]) .. tostring(eval(val, lvars))
end

--[[
local preProc, preFunc = {}, {}
preProc.def = "def%s-(%S+)%s+([^\n]+)"
preFunc.def = function(src, n, v)
    return src:gsub("@" .. n, v)
end
]]

local func = {}
_RETURNSTACK ={}

key["function"] = "function%s-(%w-)%s-:%s-(.-)(%b{});"
proc["function"] = function(lvars, name, args, src)
    --print("Defining function " .. name)
    local s = "return function("
    args = trim(args:gsub("%s", "") .. ",")
    local a = {}
    for arg in args:gmatch("([^,]-),") do
        --s = s .. arg .. ","
        table.insert(a, arg)
    end
    s = s .. table.concat(a, ",") .. ")\nlocal lvars = {}\n"
    for i, v in ipairs(a) do
        s = s .. "lvars['" .. v .. "']=" .. v .. "\n"
    end
    s = s .. "parse([[" .. src:sub(2, -2) .. "]], lvars)\n return _RETURN end"
    --print(s)
    local f, err = loadstring(s)
    if f then
        func[name] = f()
        --print(name, func[name])
    else
        print(err)
    end
end

func.print = function(lvars, ...)
    local t = {}
    for i, v in ipairs{...} do
        table.insert(t, eval(v, lvars))
    end
    print(unpack(t))
end

func.set = function(lvars, name, val)
    vars[name] = val
end

func.lua = function(lvars, s) return loadstring(s:gsub("vars", "({...})[1]"))(vars) end

getFunc = function(n)
    --print(n, func[n])
    return func[n]
end

CL_LOC = ""

function clError(loc, msg)
    print('Error: ' .. loc .. '\n' .. msg)
end

function eval(statement, lvars)
    statement = tostring(statement)
    lvars = lvars or {}
    local value
    for i, v in pairs(lvars) do
        statement = statement:gsub("%$" .. tostring(i), trim(v))
    end
    for i, v in pairs(vars) do
        statement = statement:gsub("%$" .. tostring(i), trim(v))
    end
    --[[
    string.gsub(statement, "([%w_]+)%s-(%b%(%))", function(active, argStr)
        local args = {}
        for arg in argStr:gmatch("([^,]-),") do
            arg = trim(arg)
            arg = eval(arg, lvars) or arg
            table.insert(args, arg)
        end
        if func[active] then
            local r = func[active](unpack(args))
            return r or ""
        end
    end)
    --]]
    statement = statement:gsub("(%@%s-[%w_]+%s->%s-[%w_]+%s-%b())", "runMethod[[%1]]")
    for i, v in pairs(func) do
        statement = string.gsub(statement, i.."%s-(%b())", "(getFunc('"..i.."))%1")
    end
    local f, err = loadstring("return " .. statement)
    local s, val = pcall(f)
    if not err then value = val or statement else value = statement end
    return value
end

function isTrue(statement, lvars)
    statement = tostring(statement)
    lvars = lvars or {}
    local value
    for i, v in pairs(lvars) do
        statement = statement:gsub("%$" .. tostring(i), trim(v))
    end
    for i, v in pairs(vars) do
        statement = statement:gsub("%$" .. tostring(i), trim(v))
    end
    statement = statement:gsub("([%w_]-)%s-(%b%(%))", function(active, argStr)
        local args = {}
        for arg in argStr:gmatch("([^,]-),") do
            arg = trim(arg)
            arg = eval(arg, lvars) or arg
            table.insert(args, arg)
        end
        local r = func[active](unpack(args))
        return r or ""
    end)
    local f, err = loadstring("return " .. statement)
    if not err then value = f() else value = statement end
    return value, err
end

function parse(str, lvars)
    --[[
    for i, v in pairs(preProc) do
        --print(preFunc[i])
        str = str:gsub(v, preFunc[i])
    end
    --]]
    lvars = lvars or {}
    while str:match("  ") do
        str = str:gsub("  ", " ")
    end
    str = str:gsub("%[#.-#%]", "")
    str = str:gsub("##.-\n", "")
    local pos = 0
    local p = true
    while (pos < #str) and p do
        local active = str:sub(pos, str:find("[^%w_]", pos) -1)
        if str:sub(pos, pos+1):find("%s") then
            pos = pos + 1
        elseif str:sub(pos, pos) == "$" then
            for i, v in pairs(ops) do
                if str:find(v, pos) == pos then
                    local opStr = trim(str:sub(pos, str:find(";", pos + 1)))
                    opProc[i](lvars, opStr:match(ops[i]))
                    pos = str:find(";", pos + 1)
                end
            end
        elseif key[active] and str:find(key[active], pos-1) == pos then
            local b, e = str:find(key[active], pos-1)
            proc[active](lvars or {}, str:match(key[active], pos-1))
            pos = pos + e - b
        elseif func[active] then
            local argStr = (str:match("%b()", pos):sub(2, -2) .. ","):gsub(",%s+", ",")
            --[=[
            local args = {}
            local aPos, aCount, aCurrent, aLevel, aLChar = 1, 1, "", 0, ""
            local aChars = {["("] = ")", ["{"] = "}"}
            --[[
            for arg in argStr:gmatch("([^,]-),") do
                arg = trim(arg)
                arg = eval(arg, lvars) or arg
                table.insert(args, arg)
            end
            --[
            --]]
            local aStr = ""
            --print(argStr)
            while aPos <= #argStr do
                local cc = argStr:sub(aPos, aPos)
                aStr = aStr .. cc .. ": level " .. aLevel .. ", end " .. aLChar .. "\n"
                if cc == "(" or cc == "{" then
                    aLevel = aLevel + 1
                    aLChar = aChars[cc]
                    aCurrent = aCurrent .. cc
                elseif cc == aLChar then
                    aLevel = aLevel - 1
                    aCurrent = aCurrent .. cc
                    aLChar = ""
                elseif cc == "," and aLevel == 0 then
                    table.insert(args, aCurrent)
                    --print("Arg: ", aCurrent)
                    aCurrent = ""
                    aPos = aPos + 1
                else
                    aCurrent = aCurrent .. cc
                end
                --print(cc)
                aPos = aPos + 1

            end
            --print(aStr)
            --print(table.concat(args, "; "))
            --]=]
            local args = getArgsFromString(argStr)
            func[active](lvars, unpack(args))
            pos = str:find("%)%s-;", pos+1) + 1
        else
            local r, match = -1, ""
            for i, v in pairs(key) do
                local b, e = str:find(v, pos-1)
                if (b == pos) and e then
                    if rank[i] > r then
                        r = rank[i]
                        match = i
                    end
                end
            end
            if r == -1 then
                pos = pos + 1
            else
                --print("match")
                local b, e = str:find(key[match], pos-1)
                proc[match](lvars or {}, str:match(key[match], pos-1))
                pos = pos + e - b
                match = true
            end
        end
        --[[
        _LOG = (_LOG or "") .. str:sub(1, pos-1) .. "#" .. str:sub(pos+1, -1) .. "\n" .. ("-"):rep(50) .. "\n"
        saveProjectTab("Log", "--[=[" .. _LOG .. "--]=]")
        --]]
    end
end

--[[
local LuaChunk = {}
LuaChunk.__src = {}
LuaChunk.__run = {}
LuaChunk.__src.run = {"$arg1"}
LuaChunk.__run.run = function(self, arg1) print(arg1[1], self.__vars.parameter1) end
LuaChunk.__args = "$parameter1=def_val"
LuaChunk.__vars = {}
    LuaChunk.__vars.parameter1 = "def_val"
types["LuaChunk"] = LuaChunk
--]]
--# Log
--[=[#nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1#

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;#
$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;
#
$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};ł
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;
 #$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

#nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1#
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;#$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
#nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test"#

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";#
$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";
#
$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";
 #$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

#str = "string";
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string"#
$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";#$str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
#str++;

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++#

new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;#
new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;
#new not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

#ew not_type : test ("type_args");

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args")#

typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");#
typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");
#typedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

#ypedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

t#pedef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

ty#edef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typ#def testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

type#ef testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typed#f testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typede# testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef#testType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef #estType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef t#stType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef te#tType : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef tes#Type : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef test#ype : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testT#pe : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testTy#e : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testTyp# : $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType#: $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
$nd += 1;

$nd = 1;
$nd += "test";

$str = "string";
$str++;

new not_type : test ("type_args");

typedef testType # $testvar {
 @printstuff : none {
 print($testvar);
 };
};
new testType:typetest(10);
@testType>printstuff();
@stuff > stuff(stuff);

--------------------------------------------------
--]=]