Version 1.0.0. Published in Esolangs on December 12, 2015

Author: lmendo

MATL_spec.pdf

@@ -0,0 +1,54 @@
+function F = genFunDef(masterFileName, fileName)
+%
+% Generates function definition struct array "F" from tab-separated text
+% file, and saves it in file "funDef.mat"
+%
+% The tab-separated file has one or more lines for each function.
+% The first line for each function contains its source code in the first
+% column. If a function has the sixth column ("body") empty, the function
+% is considered to be undefined, and is not included in struct array "F".
+%
+% Wraps function body in a cell, even if it's a single string.
+% Function body in the text file may span several strings. This is defined
+% using subsequent lines with "source" column empty and "body" field
+% filled. In that case, this function collects all lines in a cell array of
+% strings.
+%
+% Luis Mendo.
+
+fieldNames = {'source' 'minIn' 'maxIn' 'defIn' 'minOut' 'maxOut' 'defOut' 'consumeInputs' 'wrap' 'body' 'comment' 'description'};
+fid = fopen(masterFileName, 'r');
+F = reshape(fread(fid,inf,'*char'),1,[]);
+fclose(fid);
+F = reshape(regexp(F, '[\r\n]+', 'split'),[],1);
+ind = cellfun(@(s) ~isempty(s)&&s(1)~='%', F);
+F = F(ind);
+F = regexp(F, ' *\t *', 'split');
+n = numel(fieldNames);
+F = cellfun(@(s) [ s(1:min(n,end)) repmat({''},1,max(n-numel(s),0)) ], F, 'uniform', 0); % fill if empty columns
+F = vertcat(F{:});
+F = F(~cellfun(@isempty, F(:,10)),:); % remove functions that have a line in
+% the file but are not actually defined. These are identified because "body"
+% column is empty.
+
+% Transform 'consumeInputs' and 'wrap' fields into logical values:
+for c = [8 9]
+    for r = 1:size(F,1)
+        F{r,c} = logical(str2num(F{r,c})); %#ok
+    end
+end
+
+% Join function body lines corresponding to the same function source into
+% a cell array of strings. Single lines are also wrapped into a cell array.
+d = [~cellfun('isempty', F(:,1)); true];
+starts = find(d(1:end-1));
+ends = find(d(2:end));
+for n = numel(starts):-1:1 % process from end because F will be shrunk along the way
+    F{starts(n),10} = F(starts(n):ends(n),10).';
+    F(starts(n)+1:ends(n),:) = [];
+end
+
+assert(numel(unique(F(:,1)))==numel(F(:,1)), 'MATL:compiler:internal', 'MATL internal error while reading function definition file: function names are not unique')
+
+F = cell2struct(F, fieldNames, 2);
+save(fileName, 'F')

funDef.mat

@@ -0,0 +1,194 @@
+function H = genHelp(F, L)
+%
+% Generates help struct array "H" from struct array "F" (functions) and
+% additional information coded directly here (non-functions), and saves it
+% in file "help.mat"
+%
+% Luis Mendo.
+
+
+N = 65; % characters per line
+
+% Non-functions. Changes done here should be don in `genHelp.m` too
+
+% Statements that are not functions. Changes done here to the comment field should be
+% done in `matl_disp.m` too.
+F(end+1).source = '"';
+F(end).comment = 'for';
+F(end).description = '\matlab+for+ (control flow: loop). \sa \matl+]+, \matl+@+, \matl+X}+, \matl+Y}+';
+
+F(end+1).source = '`';
+F(end).comment = 'do...while';
+F(end).description = 'do...while (control flow: loop). \sa \matl+X`+, \matl+]+, \matl+@+, \matl+X}+, \matl+Y}+';
+
+F(end+1).source = 'X`';
+F(end).comment = 'while';
+F(end).description = '\matlab+while+ (control flow: loop). \sa \matl+`+, \matl+]+, \matl+@+, \matl+X}+, \matl+Y}+';
+
+F(end+1).source = '?';
+F(end).comment = 'if';
+F(end).description = '\matlab+if+ (control flow: conditional branch). \sa \matl+]+, \matl+}+';
+
+F(end+1).source = '}';
+F(end).comment = 'else';
+F(end).description = '\matlab+else+ (control flow: conditional branch). \sa \matl+?+';
+
+F(end+1).source = '@';
+F(end).comment = 'for loop variable or do...while / while loop iteration index';
+F(end).description = 'for loop variable, do...while loop iteration index or while loop iteration index of innermost loop';
+
+F(end+1).source = ']';
+F(end).comment = 'end';
+F(end).description = '\matlab+end+ (control flow). End loop or conditional branch. \sa \matl+"+, \matl+`+, \matl+?+';
+
+F(end+1).source = '.';
+F(end).comment = 'conditional break';
+F(end).description = 'conditional \matlab+break+ (control flow: loop). Consume the top of the stack and, if it evaluates to ''true'' acccording to \matlab+if+ rules, terminate execution of innermost loop. \sa \matl+"+, \matl+`+';
+
+F(end+1).source = 'X.';
+F(end).comment = 'conditional continue';
+F(end).description = 'conditional \matlab+continue+ (control flow: loop). Consume the top of the stack and, if it evaluates to ''true'' acccording to \matlab+if+ rules, pass control to next iteration of innermost loop. \sa \matl+"+, \matl+`+';
+
+F(end+1).source = '''';
+F(end).comment = 'string delimiter';
+F(end).description = 'string delimiter. Should be doubled when used within a string';
+
+F(end+1).source = ',';
+F(end).comment = 'separator';
+F(end).description = 'separator. Space and newline can be used as separators too';
+
+F(end+1).source = '%';
+F(end).comment = 'comment';
+F(end).description = 'comment. The rest of the line is ignored';
+
+% Sort according to source
+[~, ind] = sort(cellfun(@(x) x(end:-1:1), {F.source}, 'UniformOutput', 0));
+F = F(ind);
+
+commFormatted = {F.comment};
+descrFormatted = {F.description};
+descrFormatted = regexprep(descrFormatted, '\\matlab(.)(.*?)(\1)', '<strong>$2</strong>');
+descrFormatted = regexprep(descrFormatted, '\\matl\+(.*?)\+', '<strong>$1</strong>'); %***make delimiter arbitrary her too
+descrFormatted = regexprep(descrFormatted, '\\comp{(.*?)}', '<strong>$1</strong>');
+descrFormatted = regexprep(descrFormatted, '\\sa', 'See also');
+descrFormatted = regexprep(descrFormatted, '\$(.*?)\$', '$1');
+descrPlain = cell(1,numel(descrFormatted));
+inFormatted = cell(1,numel(descrFormatted));
+outFormatted = cell(1,numel(descrFormatted));
+sourceFormatted = cell(1,numel(descrFormatted));
+sourcePlain = {F.source};
+
+for n = 1:numel(descrFormatted)
+    % Format source
+    sourceFormatted{n} = ['<strong>' F(n).source '</strong>'];
+    
+    % Add information on predefined literals, if applicable
+    if ~isempty(regexp(F(n).source,'[XYZ]\d','once')) && isfield(L, (F(n).source)) % X0...Z9 that are defined
+        aux = [num2cell(L.(F(n).source).key); L.(F(n).source).val];
+        descrFormatted{n} = [ descrFormatted{n} '. ' sprintf('%i: %s; ', aux{:})];
+    end        
+    
+    % Format description
+    descrFormatted{n}(end+1) = ' '; % needed so that the "find" line always finds last index
+    [s, e] = regexp(descrFormatted{n},'<strong>','start','end');
+    descrMask = true(1,numel(descrFormatted{n}));
+    descrSpace = false(1,numel(descrFormatted{n}));
+    for m = 1:numel(s)
+        descrMask(s(m):e(m)) = false;
+    end
+    [s, e] = regexp(descrFormatted{n},'</strong>','start','end');
+    for m = 1:numel(s)
+        descrMask(s(m):e(m)) = false;
+    end
+    descrPlain{n} = descrFormatted{n}(descrMask);
+    s = regexp(descrFormatted{n},'\s','start');
+    descrSpace(s) = true;
+    d = {};
+    while ~isempty(descrMask)
+        c = cumsum(descrMask);
+        ind = find((c<=N)& descrSpace, 1, 'last');
+        d{end+1} = descrFormatted{n}(1:ind);
+        descrFormatted{n}(1:ind) = [];
+        descrMask(1:ind) = [];
+        descrSpace(1:ind) = [];
+    end
+    % descrFormatted{n} = char(d); % gives a char 2D array. Bad for searching
+    d = sprintf('    %s\n', d{:}); % four spaces for left margin
+    descrFormatted{n} = d(1:end-1); % remove last '\n'
+    
+    % Format input spec:
+    minIn = str2double(F(n).minIn);
+    maxIn = str2double(F(n).maxIn);
+    defIn = str2double(F(n).defIn);
+    minOut = str2double(F(n).minOut);
+    maxOut = str2double(F(n).maxOut);
+    defOut = str2double(F(n).defOut);
+
+    if isnan(defIn) && ~isempty(F(n).defIn) % F(n).defIn contains a string that couldn't be converted to a number
+        switch F(n).defIn
+        case 'numel(STACK)'
+            defInStr = 'number of elements in stack';
+        otherwise
+            error('Unrecognized default number of inputs')
+        end
+    else
+        defInStr = sprintf('%i', defIn);
+    end
+    
+    if isempty(F(n).minIn) || isempty(F(n).maxIn)
+        inFormatted{n} = [];
+    elseif minIn ~= maxIn
+        if isfinite(maxIn)
+            inFormatted{n} = sprintf('%i--%i (%s)', minIn, maxIn, defInStr);
+        else
+            inFormatted{n} = sprintf('%i-- (%s)', minIn, defInStr);
+        end
+    else
+        if maxIn ~= defIn
+            error('Incorrect specification of number of inputs')
+        end
+        inFormatted{n} = sprintf('%i', defIn);
+    end
+
+    % Format output spec:
+    if isnan(defOut) && ~isempty(F(n).defOut) % F(n).defOut contains a string that couldn't be converted to a number
+        switch F(n).defOut
+        case {'numel(CB_H)' 'numel(CB_I)' 'numel(CB_J)' 'numel(CB_K)'}
+            defOutStr = 'number of elements in clipboard';
+        case 'numel(CB_L{in{1}})'
+            defOutStr = 'number of elements in clipboard level';
+        case 'numel(in{1})'
+            defOutStr = 'number of elements of first input';
+        otherwise
+            error('Unrecognized default number of outputs')
+        end
+    else
+        defOutStr = sprintf('%i', defOut);
+    end
+
+    if isempty(F(n).minOut) || isempty(F(n).maxOut)
+        outFormatted{n} = [];
+    elseif minOut ~= maxOut
+        if isfinite(maxOut)
+            outFormatted{n} = sprintf('%i--%i (%s)', minOut, maxOut, defOutStr);
+        else
+            outFormatted{n} = sprintf('%i-- (%s)', minOut, defOutStr);
+        end
+    else
+        if maxOut ~= defOut
+            error('Incorrect specification of number of inputs')
+        end
+        outFormatted{n} = sprintf('%i', defOut);
+    end
+end
+
+H.source = sourceFormatted;
+H.comm = commFormatted;
+H.descr = descrFormatted;
+H.in = inFormatted;
+H.out = outFormatted;
+H.sourcePlain = sourcePlain;
+H.descrPlain = descrPlain;
+save help H
+
+

funDef.txt

@@ -0,0 +1,27 @@
+function L = genPreLit(masterFileName, fileName)
+
+fid = fopen(masterFileName, 'r');
+p = reshape(fread(fid,inf,'*char'),1,[]);
+fclose(fid);
+p = regexp(p, '[\r\n]+', 'split');
+p = p(~cellfun(@isempty, p));
+funNamesInd = [ find(cellfun(@(x) isempty(regexp(x, '\t', 'once')), p)) numel(p)+1];
+for n = 1:numel(funNamesInd)-1
+    foundKeys = [];
+    for k = funNamesInd(n)+1:funNamesInd(n+1)-1
+        kv = regexp(p{k}, '\t+', 'split');
+        key = str2double(kv{1});
+        assert(~any(foundKeys==key), 'MATL:compiler:internal', 'MATL internal error while reading predefind literal file: key values are not unique')
+        val = kv{2};
+        foundKeys(end+1) = key;
+        c = numel(foundKeys);
+        L.(p{funNamesInd(n)}).key(c) = key;
+        L.(p{funNamesInd(n)}).val{c} = val;
+    end
+end
+
+save(fileName, 'L')
+
+
+
+