370919 | 2002-03-20 | Martin Nilsson | | #pike __REAL_VERSION__
|
35eee7 | 2001-01-08 | David Norlin | |
inherit .PikeObjects;
|
d47c32 | 2001-03-06 | David Norlin | | #include "./debug.h"
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | class MetaData {
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | string type;
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
string name;
|
35eee7 | 2001-01-08 | David Norlin | | array(PikeObject) decls = ({});
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | string belongs = 0;
string appears = 0;
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
d5297c | 2004-03-02 | Martin Nilsson | | array(PikeObject) inherits = ({});
|
35eee7 | 2001-01-08 | David Norlin | | }
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | constant EOF = .PikeParser.EOF;
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
enum DocTokenType {
METAKEYWORD = 1,
BRACEKEYWORD = 2,
DELIMITERKEYWORD = 3,
CONTAINERKEYWORD = 4,
|
0f5cea | 2012-03-05 | Henrik Grubbström (Grubba) | | SINGLEKEYWORD = 5,
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | | ENDKEYWORD = 6,
ERRORKEYWORD = 7,
|
35eee7 | 2001-01-08 | David Norlin | |
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | | TEXTTOKEN = 8,
ENDTOKEN = 9,
};
|
35eee7 | 2001-01-08 | David Norlin | |
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
mapping(string : DocTokenType) keywordtype =
|
35eee7 | 2001-01-08 | David Norlin | | ([
"appears" : METAKEYWORD,
"belongs" : METAKEYWORD,
"class" : METAKEYWORD,
|
ce8f3e | 2011-12-18 | Henrik Grubbström (Grubba) | | "global" : METAKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | "endclass" : METAKEYWORD,
"module" : METAKEYWORD,
"endmodule" : METAKEYWORD,
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | "namespace" : METAKEYWORD,
"endnamespace" : METAKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | "decl" : METAKEYWORD,
|
211069 | 2012-02-05 | Henrik Grubbström (Grubba) | | "directive" : METAKEYWORD,
|
d5297c | 2004-03-02 | Martin Nilsson | | "inherit" : METAKEYWORD,
|
7dc698 | 2003-11-08 | Henrik Grubbström (Grubba) | | "enum" : METAKEYWORD,
"endenum" : METAKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | |
|
ecba37 | 2001-05-15 | David Norlin | | "b" : BRACEKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | "i" : BRACEKEYWORD,
|
90cb47 | 2001-05-15 | David Norlin | | "u" : BRACEKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | "tt" : BRACEKEYWORD,
|
a380f8 | 2001-05-29 | David Norlin | | "url" : BRACEKEYWORD,
|
cc33b1 | 2001-07-17 | Martin Nilsson | | "pre" : BRACEKEYWORD,
|
8ee3df | 2004-03-02 | Martin Nilsson | | "sub" : BRACEKEYWORD,
"sup" : BRACEKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | "ref" : BRACEKEYWORD,
|
f99546 | 2015-08-21 | Henrik Grubbström (Grubba) | | "rfc" : BRACEKEYWORD,
|
90cb47 | 2001-05-15 | David Norlin | | "xml" : BRACEKEYWORD,
|
3821e5 | 2002-05-30 | Martin Nilsson | | "expr" : BRACEKEYWORD,
|
7c1411 | 2001-05-09 | David Norlin | | "image" : BRACEKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | |
|
0f5cea | 2012-03-05 | Henrik Grubbström (Grubba) | | "deprecated" : DELIMITERKEYWORD,
"obsolete" : DELIMITERKEYWORD,
|
2e0d13 | 2001-02-05 | David Norlin | |
|
5dc7ca | 2003-04-01 | Martin Nilsson | | "bugs" : DELIMITERKEYWORD,
|
28d4fc | 2011-12-03 | Henrik Grubbström (Grubba) | | "copyright" : DELIMITERKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | "example" : DELIMITERKEYWORD,
|
5dc7ca | 2003-04-01 | Martin Nilsson | | "fixme" : DELIMITERKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | "note" : DELIMITERKEYWORD,
"param" : DELIMITERKEYWORD,
|
5dc7ca | 2003-04-01 | Martin Nilsson | | "returns" : DELIMITERKEYWORD,
|
46b75b | 2001-01-08 | Henrik Grubbström (Grubba) | | "seealso" : DELIMITERKEYWORD,
|
28d4fc | 2011-12-03 | Henrik Grubbström (Grubba) | | "thanks" : DELIMITERKEYWORD,
|
5dc7ca | 2003-04-01 | Martin Nilsson | | "throws" : DELIMITERKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | |
|
5dc7ca | 2003-04-01 | Martin Nilsson | | "code" : CONTAINERKEYWORD,
|
fd033d | 2001-02-06 | David Norlin | | "section" : CONTAINERKEYWORD,
|
3f97b3 | 2001-04-11 | David Norlin | | "constant" : DELIMITERKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | "mapping" : CONTAINERKEYWORD, "member" : DELIMITERKEYWORD,
"multiset" : CONTAINERKEYWORD, "index" : DELIMITERKEYWORD,
"array" : CONTAINERKEYWORD, "elem" : DELIMITERKEYWORD,
|
141bba | 2001-02-06 | Henrik Grubbström (Grubba) | | "int" : CONTAINERKEYWORD, "value" : DELIMITERKEYWORD,
|
57add7 | 2001-02-14 | Henrik Grubbström (Grubba) | | "string" : CONTAINERKEYWORD,
|
141bba | 2001-02-06 | Henrik Grubbström (Grubba) | | "mixed" : CONTAINERKEYWORD, "type" : DELIMITERKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | |
"dl" : CONTAINERKEYWORD, "item" : DELIMITERKEYWORD,
|
bbab33 | 2001-08-20 | Martin Nilsson | | "ol" : CONTAINERKEYWORD,
"ul" : CONTAINERKEYWORD,
|
35eee7 | 2001-01-08 | David Norlin | | ]);
mapping(string : array(string)) attributenames =
([
"item" : ({ "name" }),
"param" : ({ "name" }),
"mapping" : ({ "name" }),
"array" : ({ "name" }),
"multiset" : ({ "name" }),
|
141bba | 2001-02-06 | Henrik Grubbström (Grubba) | | "int" : ({ "name" }),
|
57add7 | 2001-02-14 | Henrik Grubbström (Grubba) | | "string" : ({ "name" }),
|
141bba | 2001-02-06 | Henrik Grubbström (Grubba) | | "mixed" : ({ "name" }),
|
3f97b3 | 2001-04-11 | David Norlin | | "constant" : ({ "name" }),
|
9b77a9 | 2002-11-25 | Henrik Grubbström (Grubba) | | "typedef" : ({ "name" }),
"enum" : ({ "name" }),
|
35eee7 | 2001-01-08 | David Norlin | | ]);
|
523923 | 2002-12-07 | Henrik Grubbström (Grubba) | | mapping(string:array(string)) required_attributes =
([
"param" : ({ "name" }),
|
352471 | 2015-05-26 | Martin Nilsson | | ]);
|
523923 | 2002-12-07 | Henrik Grubbström (Grubba) | |
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected constant standard = (<
|
28d4fc | 2011-12-03 | Henrik Grubbström (Grubba) | | "note", "bugs", "example", "seealso", "deprecated", "fixme", "code",
|
e93135 | 2012-01-24 | Henrik Grubbström (Grubba) | | "copyright", "thanks", "obsolete",
|
0d10ab | 2001-04-26 | Henrik Grubbström (Grubba) | | >);
|
35eee7 | 2001-01-08 | David Norlin | |
mapping(string : multiset(string)) allowedChildren =
(["_general" : standard,
|
0d10ab | 2001-04-26 | Henrik Grubbström (Grubba) | | "_method" : (< "param", "returns", "throws" >) + standard,
|
8575a0 | 2001-02-06 | David Norlin | | "_variable": standard,
"_inherit" : standard,
|
3def6b | 2003-09-01 | Martin Nilsson | | "_class" : (< "param" >) + standard,
|
ade4e1 | 2002-12-23 | Henrik Grubbström (Grubba) | | "_namespace" : standard,
|
9b1ad3 | 2001-02-06 | David Norlin | | "_module" : standard,
"_constant" : standard,
|
3f97b3 | 2001-04-11 | David Norlin | | "_enum" : (< "constant" >) + standard,
|
9b77a9 | 2002-11-25 | Henrik Grubbström (Grubba) | | "_typedef" : standard,
|
fd567c | 2012-02-15 | Henrik Grubbström (Grubba) | | "_directive" : standard,
|
35eee7 | 2001-01-08 | David Norlin | | "mapping" : (< "member" >),
"multiset": (< "index" >),
"array" : (< "elem" >),
|
141bba | 2001-02-06 | Henrik Grubbström (Grubba) | | "int" : (< "value" >),
|
57add7 | 2001-02-14 | Henrik Grubbström (Grubba) | | "string" : (< "value" >),
|
141bba | 2001-02-06 | Henrik Grubbström (Grubba) | | "mixed" : (< "type" >),
|
35eee7 | 2001-01-08 | David Norlin | | "dl" : (< "item" >),
|
bbab33 | 2001-08-20 | Martin Nilsson | | "ol" : (< "item" >),
"ul" : (< "item" >),
|
35eee7 | 2001-01-08 | David Norlin | | ]);
|
2e0d13 | 2001-02-05 | David Norlin | | mapping(string : multiset(string)) allowGrouping =
(["param" : (< "param" >),
|
d47c32 | 2001-03-06 | David Norlin | | "index" : (< "index" >),
|
8a6cdd | 2001-02-06 | Henrik Grubbström (Grubba) | | "member" : (< "member" >),
|
161f1d | 2001-02-09 | Henrik Grubbström (Grubba) | | "type" : (< "type" >),
|
57add7 | 2001-02-14 | Henrik Grubbström (Grubba) | | "value" : (< "value" >),
|
3f97b3 | 2001-04-11 | David Norlin | | "constant" : (< "constant" >),
|
ecba37 | 2001-05-15 | David Norlin | | "item" : (< "item" >),
|
2e0d13 | 2001-02-05 | David Norlin | | ]);
|
35eee7 | 2001-01-08 | David Norlin | |
|
3f97b3 | 2001-04-11 | David Norlin | | multiset(string) allowOnlyOne =
(< "seealso",
"returns",
|
0d10ab | 2001-04-26 | Henrik Grubbström (Grubba) | | "throws",
|
3f97b3 | 2001-04-11 | David Norlin | | "deprecated",
>);
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected int getKeywordType(string keyword) {
|
35eee7 | 2001-01-08 | David Norlin | | if (keywordtype[keyword])
return keywordtype[keyword];
|
ead972 | 2003-01-20 | Martin Nilsson | | if (sizeof(keyword) > 3 && keyword[0..2] == "end")
|
35eee7 | 2001-01-08 | David Norlin | | return ENDKEYWORD;
return ERRORKEYWORD;
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected int getTokenType(array(string) | string token) {
|
35eee7 | 2001-01-08 | David Norlin | | if (arrayp(token))
return getKeywordType(token[0]);
if (!token)
return ENDTOKEN;
return TEXTTOKEN;
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected int isSpaceChar(int char) {
|
35eee7 | 2001-01-08 | David Norlin | | return (< '\t', '\n', ' ' >) [char];
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected int isKeywordChar(int char) {
|
35eee7 | 2001-01-08 | David Norlin | | return char >= 'a' && char <= 'z';
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected array(string) extractKeyword(string line) {
|
35eee7 | 2001-01-08 | David Norlin | | line += "\0";
int i = 0;
|
ead972 | 2003-01-20 | Martin Nilsson | | while (i < sizeof(line) && isSpaceChar(line[i]))
|
35eee7 | 2001-01-08 | David Norlin | | ++i;
if (line[i++] != '@')
return 0;
int keywordstart = i;
while (isKeywordChar(line[i]))
++i;
if (i == keywordstart || line[i] && !isSpaceChar(line[i]))
return 0;
string keyword = line[keywordstart .. i - 1];
|
ead972 | 2003-01-20 | Martin Nilsson | | return ({ keyword, line[i .. sizeof(line) - 2] });
|
35eee7 | 2001-01-08 | David Norlin | | }
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected int allSpaces(string s) {
|
ead972 | 2003-01-20 | Martin Nilsson | | for (int i = sizeof(s) - 1; i >= 0; --i)
|
35eee7 | 2001-01-08 | David Norlin | | if (s[i] != ' ' && s[i] != '\t')
return 0;
return 1;
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected private class Token (
|
d47c32 | 2001-03-06 | David Norlin | | int type,
string keyword,
string arg,
string text,
SourcePosition position,
) {
|
4507e9 | 2002-11-29 | Martin Nilsson | | string _sprintf(int t) {
return t=='O' && sprintf("%O(%d, %O, %O, %O, %O)", this_program, type,
keyword, arg, text, position);
|
d47c32 | 2001-03-06 | David Norlin | | }
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected array(Token) split(string s, SourcePosition pos) {
|
d47c32 | 2001-03-06 | David Norlin | | s = s - "\r";
s = replace(s, "@\n", "@\r");
array(string) lines = s / "\n";
array(int) counts = allocate(sizeof(lines));
for(int i = 0; i < sizeof(lines); ++i) {
array(string) a = lines[i] / "@\r";
counts[i] = sizeof(a);
lines[i] = a * "";
}
array(Token) res = ({ });
string filename = pos->filename;
string text = 0;
int textFirstLine;
int textLastLine;
int curLine = pos->firstline;
for(int i = 0; i < sizeof(lines); ++i) {
string line = lines[i];
array(string) extr = extractKeyword(line);
if (extr) {
if (text)
res += ({
Token(TEXTTOKEN, 0, 0, text,
SourcePosition(filename, textFirstLine, textLastLine))
});
text = 0;
res += ({
Token(getKeywordType(extr[0]), extr[0], extr[1], 0,
SourcePosition(filename, curLine, curLine + counts[i] - 1))
});
|
35eee7 | 2001-01-08 | David Norlin | | }
else {
if (allSpaces(line))
|
d47c32 | 2001-03-06 | David Norlin | | line = "";
if (!text) {
text = "";
textFirstLine = curLine;
}
text += line + "\n";
textLastLine = curLine;
|
35eee7 | 2001-01-08 | David Norlin | | }
|
d47c32 | 2001-03-06 | David Norlin | | curLine += counts[i];
|
35eee7 | 2001-01-08 | David Norlin | | }
|
d47c32 | 2001-03-06 | David Norlin | | if (text)
res += ({ Token(TEXTTOKEN, 0, 0, text,
SourcePosition(filename, textFirstLine, textLastLine))
});
|
35eee7 | 2001-01-08 | David Norlin | | return res;
}
|
352471 | 2015-05-26 | Martin Nilsson | |
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected class DocParserClass {
|
35eee7 | 2001-01-08 | David Norlin | |
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
ca8e25 | 2002-10-01 | Martin Nilsson | | SourcePosition currentPosition = 0;
|
d47c32 | 2001-03-06 | David Norlin | |
|
40ae6f | 2011-12-04 | Henrik Grubbström (Grubba) | | .Flags flags = .FLAG_NORMAL;
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected void parseError(string s, mixed ... args) {
|
d47c32 | 2001-03-06 | David Norlin | | s = sprintf(s, @args);
|
fe97f9 | 2011-11-18 | Henrik Grubbström (Grubba) | | if (currentPosition->lastline) {
werror("%s:%d..%d: DocParser error: %s\n",
currentPosition->filename, currentPosition->firstline,
currentPosition->lastline, s);
} else {
werror("%s:%d: DocParser error: %s\n",
currentPosition->filename, currentPosition->firstline, s);
}
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (flags & .FLAG_KEEP_GOING) return;
|
d47c32 | 2001-03-06 | David Norlin | | throw (AutoDocError(currentPosition, "DocParser", s));
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected array(Token) tokenArr = 0;
protected Token peekToken() {
|
d47c32 | 2001-03-06 | David Norlin | | Token t = tokenArr[0];
currentPosition = t->position || currentPosition;
return t;
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected Token readToken() {
|
d47c32 | 2001-03-06 | David Norlin | | Token t = peekToken();
tokenArr = tokenArr[1..];
return t;
}
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
d47c32 | 2001-03-06 | David Norlin | | mapping(string : function(string, string : string)
| function(string, string : mapping(string : string))) argHandlers =
([
"member" : memberArgHandler,
"elem" : elemArgHandler,
"index" : indexArgHandler,
"deprecated" : deprArgHandler,
|
e93135 | 2012-01-24 | Henrik Grubbström (Grubba) | | "obsolete" : deprArgHandler,
|
d47c32 | 2001-03-06 | David Norlin | | "section" : sectionArgHandler,
"type" : typeArgHandler,
"value" : valueArgHandler,
|
5ae246 | 2011-03-07 | Martin Stjernholm | | "item": itemArgHandler,
|
d47c32 | 2001-03-06 | David Norlin | | ]);
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string memberArgHandler(string keyword, string arg) {
|
d47c32 | 2001-03-06 | David Norlin | |
.PikeParser parser = .PikeParser(arg, currentPosition);
Type t = parser->parseOrType();
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (!t) {
|
d47c32 | 2001-03-06 | David Norlin | | parseError("@member: expected type, got %O", arg);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | t = MixedType();
}
|
d47c32 | 2001-03-06 | David Norlin | |
string s = parser->parseLiteral() || parser->parseIdents();
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (!s) {
|
4eef66 | 2012-01-24 | Henrik Grubbström (Grubba) | | parseError("@member: expected type followed by identifier or literal constant, got %O", arg);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | s = "";
}
|
d47c32 | 2001-03-06 | David Norlin | | parser->eat(EOF);
return xmltag("type", t->xml())
+ xmltag("index", xmlquote(s));
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string elemArgHandler(string keyword, string arg) {
|
d47c32 | 2001-03-06 | David Norlin | |
.PikeParser parser = .PikeParser(arg, currentPosition);
Type t = parser->parseOrType();
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (!t) {
|
d47c32 | 2001-03-06 | David Norlin | | parseError("@elem: expected type, got %O", arg);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | t = MixedType();
}
|
d47c32 | 2001-03-06 | David Norlin | | if (parser->peekToken() == "...") {
t = VarargsType(t);
parser->eat("...");
}
string s = parser->parseLiteral() || parser->parseIdents();
string s2 = 0;
int dots = 0;
if (parser->peekToken() == "..") {
dots = 1;
parser->readToken();
s2 = parser->parseLiteral() || parser->parseIdents();
}
parser->eat(EOF);
|
a32a5f | 2001-06-14 | David Norlin | | string type = xmltag("type", t->xml());
|
d47c32 | 2001-03-06 | David Norlin | | if (s)
if (s2)
|
a32a5f | 2001-06-14 | David Norlin | | return type + xmltag("minindex", xmlquote(s))
|
d47c32 | 2001-03-06 | David Norlin | | + xmltag("maxindex", xmlquote(s2));
else
|
a32a5f | 2001-06-14 | David Norlin | | return type + xmltag(dots ? "minindex" : "index", xmlquote(s));
|
d47c32 | 2001-03-06 | David Norlin | | else
if (s2)
|
a32a5f | 2001-06-14 | David Norlin | | return type + xmltag("maxindex", xmlquote(s2));
|
d47c32 | 2001-03-06 | David Norlin | | else
parseError("@elem: expected identifier or literal");
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | return type;
|
d47c32 | 2001-03-06 | David Norlin | | }
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string indexArgHandler(string keyword, string arg) {
|
d47c32 | 2001-03-06 | David Norlin | |
.PikeParser parser = .PikeParser(arg, currentPosition);
string s = parser->parseLiteral();
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (!s) {
|
d47c32 | 2001-03-06 | David Norlin | | parseError("@index: expected identifier, got %O", arg);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | s = "";
}
|
d47c32 | 2001-03-06 | David Norlin | | parser->eat(EOF);
return xmltag("value", xmlquote(s));
}
|
e93135 | 2012-01-24 | Henrik Grubbström (Grubba) | | protected string deprArgHandler(string keyword, string arg)
{
if (keyword != "deprecated") {
parseError("Illegal keyword: @%s, did you mean @deprecated?");
}
|
d47c32 | 2001-03-06 | David Norlin | | .PikeParser parser = .PikeParser(arg, currentPosition);
if (parser->peekToken() == EOF)
return "";
string res = "";
for (;;) {
string s = parser->parseIdents();
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (!s) {
|
d47c32 | 2001-03-06 | David Norlin | | parseError("@deprecated: expected list identifier, got %O", arg);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (parser->peekToken() != ",") return res;
} else
res += xmltag("name", xmltag("ref", s));
|
d47c32 | 2001-03-06 | David Norlin | | if (parser->peekToken() == EOF)
return res;
parser->eat(",");
}
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected mapping(string : string) sectionArgHandler(string keyword, string arg) {
|
8ff89d | 2016-07-04 | Martin Nilsson | | return ([ "title" : String.trim (arg) ]);
|
d47c32 | 2001-03-06 | David Norlin | | }
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string typeArgHandler(string keyword, string arg) {
|
d47c32 | 2001-03-06 | David Norlin | |
.PikeParser parser = .PikeParser(arg, currentPosition);
Type t = parser->parseOrType();
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (!t) {
|
d47c32 | 2001-03-06 | David Norlin | | parseError("@member: expected type, got %O", arg);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | t = MixedType();
}
|
d47c32 | 2001-03-06 | David Norlin | |
parser->eat(EOF);
|
a20f85 | 2001-07-26 | David Norlin | | return t->xml();
|
d47c32 | 2001-03-06 | David Norlin | | }
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string valueArgHandler(string keyword, string arg) {
|
a20f85 | 2001-07-26 | David Norlin | |
|
d47c32 | 2001-03-06 | David Norlin | | .PikeParser parser = .PikeParser(arg, currentPosition);
string s = parser->parseLiteral() || parser->parseIdents();
|
3d7c7c | 2001-04-26 | David Norlin | | string s2 = 0;
int dots = 0;
if (parser->peekToken() == "..") {
dots = 1;
parser->readToken();
s2 = parser->parseLiteral() || parser->parseIdents();
}
|
d47c32 | 2001-03-06 | David Norlin | | parser->eat(EOF);
|
3d7c7c | 2001-04-26 | David Norlin | | if (s)
if (s2)
return xmltag("minvalue", xmlquote(s))
+ xmltag("maxvalue", xmlquote(s2));
else
|
a20f85 | 2001-07-26 | David Norlin | | return dots ? xmltag("minvalue", xmlquote(s)) : xmlquote(s);
|
3d7c7c | 2001-04-26 | David Norlin | | else
if (s2)
return xmltag("maxvalue", xmlquote(s2));
else
|
4eef66 | 2012-01-24 | Henrik Grubbström (Grubba) | | parseError("@value: expected identifier or literal constant, got %O", arg);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | return "";
|
d47c32 | 2001-03-06 | David Norlin | | }
|
923b70 | 2014-04-02 | Henrik Grubbström (Grubba) | | protected string|mapping(string:string) itemArgHandler(string keyword, string arg)
|
5ae246 | 2011-03-07 | Martin Stjernholm | | {
|
8ff89d | 2016-07-04 | Martin Nilsson | | arg = String.trim(arg);
|
4e7de0 | 2014-04-02 | Henrik Grubbström (Grubba) | | if (arg == "") return "";
|
923b70 | 2014-04-02 | Henrik Grubbström (Grubba) | | if (!has_value(arg, "@")) return ([ "name":arg ]);
|
4e7de0 | 2014-04-02 | Henrik Grubbström (Grubba) | | return xmlNode(arg);
|
5ae246 | 2011-03-07 | Martin Stjernholm | | }
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected mapping(string : string) standardArgHandler(string keyword, string arg)
|
d47c32 | 2001-03-06 | David Norlin | | {
array(string) args = ({});
arg += "\0";
int i = 0;
for (;;) {
while (isSpaceChar(arg[i]))
|
35eee7 | 2001-01-08 | David Norlin | | ++i;
|
d47c32 | 2001-03-06 | David Norlin | | if (!arg[i])
break;
if (arg[i] == '"' || arg[i] == '\'') {
int quotechar = arg[i];
|
35eee7 | 2001-01-08 | David Norlin | | ++i;
int start = i;
|
d47c32 | 2001-03-06 | David Norlin | | while(arg[i]) {
if (arg[i] == quotechar)
if (arg[i + 1] == quotechar)
++i;
else
break;
++i;
}
if (!arg[i])
parseError("keyword parameter is unterminated string constant");
|
35eee7 | 2001-01-08 | David Norlin | | else
|
d47c32 | 2001-03-06 | David Norlin | | ++i;
string s = arg[start .. i - 2];
array(string) replacefrom = ({ quotechar == '"' ? "\"\"" : "''" });
array(string) replaceto = ({ quotechar == '"' ? "\"" : "'" });
s = replace(s,replacefrom, replaceto);
args += ({ s });
|
35eee7 | 2001-01-08 | David Norlin | | }
|
d47c32 | 2001-03-06 | David Norlin | | else {
|
a0238e | 2004-11-26 | Martin Nilsson | | String.Buffer out = String.Buffer();
int quote = 0;
while (arg[i] && (!isSpaceChar(arg[i]) || quote) ) {
if(arg[i]=='@') {
switch(arg[i+1]) {
case '@':
out->putchar( '@' );
break;
case '{':
quote++;
break;
case '}':
quote--;
if(quote<0)
parseError(sprintf("@%s with too many @}.\n", keyword));
break;
case 0:
default:
parseError("Illegal @ statement.\n");
}
}
else
out->putchar(arg[i]);
|
35eee7 | 2001-01-08 | David Norlin | | ++i;
|
a0238e | 2004-11-26 | Martin Nilsson | | }
args += ({ (string)out });
|
35eee7 | 2001-01-08 | David Norlin | | }
}
|
d47c32 | 2001-03-06 | David Norlin | |
mapping(string:string) res = ([]);
array(string) attrnames = attributenames[keyword];
int attrcount = sizeof(attrnames || ({}) );
|
2e52c9 | 2012-02-15 | Henrik Grubbström (Grubba) | | if (attrcount < sizeof(args)) {
|
d47c32 | 2001-03-06 | David Norlin | | parseError(sprintf("@%s with too many parameters", keyword));
|
2e52c9 | 2012-02-15 | Henrik Grubbström (Grubba) | | args = args[..attrcount-1];
}
|
d47c32 | 2001-03-06 | David Norlin | | for (int i = 0; i < sizeof(args); ++i)
res[attrnames[i]] = attributequote(args[i]);
|
b96f9a | 2002-12-07 | Henrik Grubbström (Grubba) | | foreach(required_attributes[keyword]||({}), string attrname) {
|
523923 | 2002-12-07 | Henrik Grubbström (Grubba) | | if (!res[attrname]) {
parseError(sprintf("@%s lacking required parameter %s",
keyword, attrname));
}
}
|
d47c32 | 2001-03-06 | David Norlin | | return res;
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string|mapping(string:string) getArgs(string keyword, string arg) {
|
d47c32 | 2001-03-06 | David Norlin | | return (argHandlers[keyword] || standardArgHandler)(keyword, arg);
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string xmlNode(string s) {
|
d47c32 | 2001-03-06 | David Norlin | | s += "\0";
string res = "";
int i = 0;
array(string) tagstack = ({ });
int inXML = 0;
while (s[i] == '\n')
|
35eee7 | 2001-01-08 | David Norlin | | ++i;
|
d47c32 | 2001-03-06 | David Norlin | | while (s[i]) {
if (s[i] == '@') {
++i;
if (s[i] == '@') {
res += "@";
++i;
}
else if (s[i] == '[') {
int j = ++i;
multiset(int) forbidden = (<'@','\n'>);
int level = 1;
while (s[j] && level && !forbidden[s[j]] ) {
if (s[j] == ']') {
level--;
} else if (s[j] == '[') {
level++;
}
++j;
}
if (level) {
if (forbidden[s[j]]) {
parseError("forbidden character inside @[...]: %O", s[i-2..j]);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | } else {
parseError("@[ without matching ]");
j++;
}
|
d47c32 | 2001-03-06 | David Norlin | | }
res += xmltag("ref", xmlquote(s[i .. j - 2]));
i = j;
}
else if (s[i] == '}') {
if (!sizeof(tagstack)) {
werror("///\n%O\n///\n", s);
parseError("closing @} without corresponding @keyword{");
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | } else {
if (tagstack[0] == "xml")
--inXML;
else
res += closetag(tagstack[0]);
tagstack = tagstack[1..];
}
|
d47c32 | 2001-03-06 | David Norlin | | ++i;
}
else if (isKeywordChar(s[i])) {
int start = i;
while (isKeywordChar(s[++i]))
;
string keyword = s[start .. i - 1];
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (s[i] != '{') {
|
d47c32 | 2001-03-06 | David Norlin | | parseError("expected @keyword{, got %O", s[start .. i]);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | i--;
}
if (getKeywordType(keyword) != BRACEKEYWORD) {
|
61c081 | 2001-05-09 | David Norlin | | parseError("@%s cannot be used like this: @%s{ ... @}",
keyword, keyword);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (keyword == "code") {
parseError("Converted @code{ to @expr{.");
keyword = "expr";
}
}
|
d47c32 | 2001-03-06 | David Norlin | | ++i;
tagstack = ({ keyword }) + tagstack;
if (keyword == "xml")
++inXML;
else
res += opentag(keyword);
}
else
parseError("expected @keyword{ or @}, got \"" + s[i-1 .. i+4] + "\"");
}
else if (s[i] == '\n' && !sizeof(tagstack)) {
if (s[++i] == '\n') {
while (s[i] == '\n')
++i;
if (s[i])
res += "</p>\n<p>";
}
else
res += "\n";
}
else {
string add = s[i..i];
if (inXML == 0)
add = replace(add, ({ "<", ">", "&" }),
({ "<", ">", "&" }) );
res += add;
++i;
}
|
35eee7 | 2001-01-08 | David Norlin | | }
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | while (sizeof(tagstack)) {
|
d47c32 | 2001-03-06 | David Norlin | | parseError("@" + tagstack[0] + "{ without matching @}");
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (tagstack[0] == "xml")
--inXML;
else
res += closetag(tagstack[0]);
tagstack = tagstack[1..];
}
|
8ff89d | 2016-07-04 | Martin Nilsson | | res = String.trim(res-"<p></p>");
|
43037f | 2001-10-03 | Martin Nilsson | | if(!sizeof(res)) return "\n";
return "<p>" + res + "</p>\n";
|
35eee7 | 2001-01-08 | David Norlin | | }
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string xmlText() {
|
35eee7 | 2001-01-08 | David Norlin | | string res = "";
for (;;) {
|
d47c32 | 2001-03-06 | David Norlin | | Token token = peekToken();
switch (token->type) {
|
35eee7 | 2001-01-08 | David Norlin | | case TEXTTOKEN:
|
d47c32 | 2001-03-06 | David Norlin | | res += xmlNode(token->text);
readToken();
|
35eee7 | 2001-01-08 | David Norlin | | break;
case CONTAINERKEYWORD:
|
d47c32 | 2001-03-06 | David Norlin | | string keyword = token->keyword;
string arg = token->arg;
|
35eee7 | 2001-01-08 | David Norlin | |
res += "<" + keyword;
string|mapping(string:string) args = getArgs(keyword, arg);
if (mappingp(args))
foreach(indices(args), string s)
|
61ee48 | 2009-04-07 | Henrik Grubbström (Grubba) | | res += " " + s +
"=\"" + Parser.encode_html_entities(args[s]) + "\"";
|
35eee7 | 2001-01-08 | David Norlin | | res += ">";
if (stringp(args))
res += args;
|
d47c32 | 2001-03-06 | David Norlin | | readToken();
|
35eee7 | 2001-01-08 | David Norlin | | res += xmlContainerContents(keyword);
|
d47c32 | 2001-03-06 | David Norlin | | if (!(peekToken()->type == ENDKEYWORD
&& peekToken()->keyword == "end" + keyword))
|
1cd471 | 2001-02-06 | Henrik Grubbström (Grubba) | | parseError(sprintf("@%s without matching @end%s",
keyword, keyword));
|
35eee7 | 2001-01-08 | David Norlin | | res += closetag(keyword);
|
d47c32 | 2001-03-06 | David Norlin | | readToken();
|
35eee7 | 2001-01-08 | David Norlin | | break;
default:
return res;
}
}
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected string xmlContainerContents(string container) {
|
35eee7 | 2001-01-08 | David Norlin | | string res = "";
|
d47c32 | 2001-03-06 | David Norlin | | Token token = peekToken();
switch(token->type) {
|
35eee7 | 2001-01-08 | David Norlin | | case ENDTOKEN:
return "";
case TEXTTOKEN:
{
|
d47c32 | 2001-03-06 | David Norlin | | string text = token->text;
|
35eee7 | 2001-01-08 | David Norlin | | if (text - "\n" - "\t" - " " == "") {
|
d47c32 | 2001-03-06 | David Norlin | | readToken();
|
35eee7 | 2001-01-08 | David Norlin | | break;
}
else
;
}
case CONTAINERKEYWORD:
res += opentag("text") + xmlText() + closetag("text");
break;
case ERRORKEYWORD:
|
2e0d13 | 2001-02-05 | David Norlin | |
|
d47c32 | 2001-03-06 | David Norlin | | parseError("unknown keyword: @" + token->keyword);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | readToken();
return xmlContainerContents(container);
|
35eee7 | 2001-01-08 | David Norlin | | }
for (;;) {
|
d47c32 | 2001-03-06 | David Norlin | | token = peekToken();
if (! (<SINGLEKEYWORD, DELIMITERKEYWORD>) [token->type] )
|
35eee7 | 2001-01-08 | David Norlin | | return res;
|
2e0d13 | 2001-02-05 | David Norlin | |
string single = 0;
array(string) keywords = ({});
|
35eee7 | 2001-01-08 | David Norlin | | res += opentag("group");
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | group:
|
d47c32 | 2001-03-06 | David Norlin | | while ( (<SINGLEKEYWORD, DELIMITERKEYWORD>) [token->type] ) {
string keyword = token->keyword;
single = single || (token->type == SINGLEKEYWORD && keyword);
|
35eee7 | 2001-01-08 | David Norlin | | multiset(string) allow = allowedChildren[container];
|
cdec89 | 2001-07-16 | David Norlin | | if (!allow || !allow[keyword]) {
string e = sprintf("@%s is not allowed inside @%s",
keyword, container);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (allow) {
|
cdec89 | 2001-07-16 | David Norlin | | e += sprintf(" (allowed children are:%{ @%s%})", indices(allow));
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | } else
|
cdec89 | 2001-07-16 | David Norlin | | e += " (no children are allowed)";
parseError(e);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (allow && sizeof(allow) == 1) {
parseError("Rewriting @%s to @%s.", keyword, indices(allow)[0]);
token->keyword = indices(allow)[0];
continue;
}
readToken();
token = peekToken();
break;
|
cdec89 | 2001-07-16 | David Norlin | | }
|
35eee7 | 2001-01-08 | David Norlin | |
|
2e0d13 | 2001-02-05 | David Norlin | | multiset(string) allowGroup = allowGrouping[keyword] || ([]);
foreach (keywords, string k)
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | if (!allowGroup[k]) {
|
2e0d13 | 2001-02-05 | David Norlin | | parseError("@" + keyword + " may not be grouped together with @" + k);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | break group;
}
|
2e0d13 | 2001-02-05 | David Norlin | | keywords += ({ keyword });
|
d47c32 | 2001-03-06 | David Norlin | | string arg = token->arg;
|
35eee7 | 2001-01-08 | David Norlin | | res += "<" + keyword;
string|mapping(string:string) args = getArgs(keyword, arg);
if (mappingp(args)) {
foreach(indices(args), string s)
|
61ee48 | 2009-04-07 | Henrik Grubbström (Grubba) | | res += " " + s +
"=\"" + Parser.encode_html_entities(args[s]) + "\"";
|
35eee7 | 2001-01-08 | David Norlin | | res += "/>";
}
else if (stringp(args))
res += ">" + args + "</" + keyword + ">";
else
res += "/>";
|
d47c32 | 2001-03-06 | David Norlin | | readToken();
token = peekToken();
|
35eee7 | 2001-01-08 | David Norlin | | }
|
d47c32 | 2001-03-06 | David Norlin | | switch(token->type) {
|
35eee7 | 2001-01-08 | David Norlin | | case TEXTTOKEN:
|
d47c32 | 2001-03-06 | David Norlin | |
|
35eee7 | 2001-01-08 | David Norlin | | {
|
d47c32 | 2001-03-06 | David Norlin | | string text = token->text;
|
35eee7 | 2001-01-08 | David Norlin | | if (text - "\n" - "\t" - " " == "") {
|
d47c32 | 2001-03-06 | David Norlin | | readToken();
|
35eee7 | 2001-01-08 | David Norlin | | break;
}
else
;
}
case CONTAINERKEYWORD:
|
2e0d13 | 2001-02-05 | David Norlin | | if (single)
parseError("cannot have text after @" + single);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | else
res += opentag("text") + xmlText() + closetag("text");
|
35eee7 | 2001-01-08 | David Norlin | | }
res += closetag("group");
}
}
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected void create(string | array(Token) s,
|
40ae6f | 2011-12-04 | Henrik Grubbström (Grubba) | | SourcePosition|void position,
.Flags|void flags)
|
d47c32 | 2001-03-06 | David Norlin | | {
|
65340d | 2014-08-15 | Martin Nilsson | | if (undefinedp(flags)) flags = .FLAG_NORMAL;
|
40ae6f | 2011-12-04 | Henrik Grubbström (Grubba) | |
|
8e06a3 | 2014-09-30 | Martin Nilsson | | this::flags = flags;
|
40ae6f | 2011-12-04 | Henrik Grubbström (Grubba) | |
|
d47c32 | 2001-03-06 | David Norlin | | if (arrayp(s)) {
tokenArr = s;
}
else {
|
f67101 | 2014-08-12 | Per Hedbor | | if (!position) error("position == 0");
|
d47c32 | 2001-03-06 | David Norlin | | tokenArr = split(s, position);
}
tokenArr += ({ Token(ENDTOKEN, 0, 0, 0, 0) });
|
35eee7 | 2001-01-08 | David Norlin | | }
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | MetaData getMetaData() {
MetaData meta = MetaData();
|
f4c6ad | 2001-02-09 | David Norlin | | string scopeModule = 0;
|
d47c32 | 2001-03-06 | David Norlin | | while(peekToken()->type == METAKEYWORD) {
Token token = readToken();
string keyword = token->keyword;
string arg = token->arg;
string endkeyword = 0;
|
35eee7 | 2001-01-08 | David Norlin | | switch (keyword) {
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | case "namespace":
|
46a28a | 2016-08-04 | Henrik Grubbström (Grubba) | | case "enum":
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | case "class":
case "module":
{
|
d47c32 | 2001-03-06 | David Norlin | | if (endkeyword)
parseError("@%s must stand alone", endkeyword);
|
35eee7 | 2001-01-08 | David Norlin | | if (meta->appears)
parseError("@appears before @%s", keyword);
if (meta->belongs)
parseError("@belongs before @%s", keyword);
if (meta->type)
parseError("@%s can not be combined with @%s", keyword, meta->type);
meta->type = keyword;
|
d47c32 | 2001-03-06 | David Norlin | | .PikeParser nameparser = .PikeParser(arg, currentPosition);
|
2e0d13 | 2001-02-05 | David Norlin | | string s = nameparser->readToken();
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | if (!isIdent(s)) {
|
ade4e1 | 2002-12-23 | Henrik Grubbström (Grubba) | | if (keyword == "namespace") {
if (s == "::") {
s = "";
} else if (!isFloat(s)) {
parseError("@%s: expected %s name, got %O",
keyword, keyword, s);
}
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | } else {
parseError("@%s: expected %s name, got %O", keyword, keyword, s);
}
|
ade4e1 | 2002-12-23 | Henrik Grubbström (Grubba) | | }
if (nameparser->peekToken() == "::") {
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | nameparser->readToken();
if (keyword != "namespace")
parseError("@%s: '%s::' only allowed as @namespace name",
keyword, s);
}
|
ad6662 | 2001-02-08 | David Norlin | | if (nameparser->peekToken() != EOF)
|
2a139d | 2001-02-15 | David Norlin | | parseError("@%s: expected %s name, got %O", keyword, keyword, arg);
|
35eee7 | 2001-01-08 | David Norlin | | meta->name = s;
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | }
break;
|
35eee7 | 2001-01-08 | David Norlin | |
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | case "endnamespace":
|
46a28a | 2016-08-04 | Henrik Grubbström (Grubba) | | case "endenum":
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | case "endclass":
case "endmodule":
{
if (meta->type || meta->belongs || meta->appears || endkeyword)
parseError("@%s must stand alone", keyword);
meta->type = endkeyword = keyword;
.PikeParser nameparser = .PikeParser(arg, currentPosition);
while (nameparser->peekToken() != EOF)
meta->name = (meta->name || "") + nameparser->readToken();
}
break;
case "decl":
{
|
d47c32 | 2001-03-06 | David Norlin | | if (endkeyword)
parseError("@%s must stand alone", endkeyword);
|
f4c6ad | 2001-02-09 | David Norlin | | int first = !meta->type;
|
35eee7 | 2001-01-08 | David Norlin | | if (!meta->type)
meta->type = "decl";
else if (meta->type != "decl")
parseError("@decl can not be combined with @%s", meta->type);
if (meta->appears)
parseError("@appears before @decl");
if (meta->belongs)
parseError("@belongs before @decl");
meta->type = "decl";
|
d47c32 | 2001-03-06 | David Norlin | | .PikeParser declparser = .PikeParser(arg, currentPosition);
|
c74838 | 2001-01-11 | David Norlin | | PikeObject p = declparser->parseDecl(
|
f4c6ad | 2001-02-09 | David Norlin | | ([ "allowArgListLiterals" : 1,
"allowScopePrefix" : 1 ]) );
|
35eee7 | 2001-01-08 | David Norlin | | string s = declparser->peekToken();
if (s != ";" && s != EOF)
|
2a139d | 2001-02-15 | David Norlin | | parseError("@decl: expected end of line, got %O", s);
|
66f31b | 2003-11-11 | Henrik Grubbström (Grubba) | | int i = search(p->name||"", "::");
|
f4c6ad | 2001-02-09 | David Norlin | | if (i >= 0) {
string scope = p->name[0 .. i + 1];
p->name = p->name[i + 2 ..];
if (!first && scopeModule != scope)
|
2a139d | 2001-02-15 | David Norlin | | parseError("@decl's must have identical 'scope::' prefix");
|
f4c6ad | 2001-02-09 | David Norlin | | scopeModule = scope;
}
else if (!first && scopeModule)
|
2a139d | 2001-02-15 | David Norlin | | parseError("@decl's must have identical 'scope::' prefix");
|
35eee7 | 2001-01-08 | David Norlin | | meta->decls += ({ p });
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | }
break;
|
35eee7 | 2001-01-08 | David Norlin | |
|
d5297c | 2004-03-02 | Martin Nilsson | | case "inherit":
{
if (endkeyword)
parseError("@%s must stand alone", endkeyword);
string s = .PikeParser(arg, currentPosition)->parseIdents();
if (!s)
parseError("@inherits: expected identifier, got %O", arg);
Inherit i = .PikeObjects.Inherit();
i->name = s;
i->classname = s;
meta->inherits += ({ i });
}
break;
|
211069 | 2012-02-05 | Henrik Grubbström (Grubba) | | case "directive":
{
if (endkeyword)
parseError("@%s must stand alone", endkeyword);
int first = !meta->type;
if (!meta->type)
meta->type = "decl";
else if (meta->type != "decl")
parseError("@directive can not be combined with @%s", meta->type);
if (meta->appears)
parseError("@appears before @directive");
if (meta->belongs)
parseError("@belongs before @directive");
meta->type = "decl";
|
8ff89d | 2016-07-04 | Martin Nilsson | | string s = String.trim(arg);
|
211069 | 2012-02-05 | Henrik Grubbström (Grubba) | | meta->decls += ({ .PikeObjects.CppDirective(s) });
}
break;
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | case "appears":
{
|
d47c32 | 2001-03-06 | David Norlin | | if (endkeyword)
parseError("@%s must stand alone", endkeyword);
|
35eee7 | 2001-01-08 | David Norlin | | if (meta->type == "class" || meta->type == "decl"
|| meta->type == "module" || !meta->type)
{
if (meta->appears)
parseError("duplicate @appears");
if (meta->belongs)
parseError("both @appears and @belongs");
|
f4c6ad | 2001-02-09 | David Norlin | | if (scopeModule)
|
2a139d | 2001-02-15 | David Norlin | | parseError("both 'scope::' and @appears");
|
d47c32 | 2001-03-06 | David Norlin | | .PikeParser idparser = .PikeParser(arg, currentPosition);
|
35eee7 | 2001-01-08 | David Norlin | | string s = idparser->parseIdents();
if (!s)
|
2a139d | 2001-02-15 | David Norlin | | parseError("@appears: expected identifier, got %O", arg);
|
1e2295 | 2011-12-19 | Henrik Grubbström (Grubba) | | else
meta->appears = s;
|
35eee7 | 2001-01-08 | David Norlin | | }
else
parseError("@appears not allowed here");
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | }
break;
|
35eee7 | 2001-01-08 | David Norlin | |
|
ce8f3e | 2011-12-18 | Henrik Grubbström (Grubba) | | case "global":
{
parseError("The @global keyword is obsolete. "
"Use @belongs predef:: instead.");
if (meta->type == "class" || meta->type == "decl"
|| meta->type == "module" || !meta->type)
{
if (meta->belongs)
parseError("duplicate @belongs/@global");
if (meta->appears)
parseError("both @appears and @belongs/@global");
if (scopeModule)
parseError("both 'scope::' and @belongs/@global");
meta->belongs = "predef::";
}
}
break;
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | case "belongs":
{
|
d47c32 | 2001-03-06 | David Norlin | | if (endkeyword)
parseError("@%s must stand alone", endkeyword);
|
35eee7 | 2001-01-08 | David Norlin | | if (meta->type == "class" || meta->type == "decl"
|
d47c32 | 2001-03-06 | David Norlin | | || meta->type == "module" || !meta->type)
|
35eee7 | 2001-01-08 | David Norlin | | {
if (meta->belongs)
parseError("duplicate @belongs");
if (meta->appears)
parseError("both @appears and @belongs");
|
f4c6ad | 2001-02-09 | David Norlin | | if (scopeModule)
|
2a139d | 2001-02-15 | David Norlin | | parseError("both 'scope::' and @belongs");
|
d47c32 | 2001-03-06 | David Norlin | | .PikeParser idparser = .PikeParser(arg, currentPosition);
|
35eee7 | 2001-01-08 | David Norlin | | string s = idparser->parseIdents();
if (!s && idparser->peekToken() != EOF)
|
2a139d | 2001-02-15 | David Norlin | | parseError("@belongs: expected identifier or blank, got %O", arg);
|
35eee7 | 2001-01-08 | David Norlin | | meta->belongs = s || "";
}
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | }
break;
|
35eee7 | 2001-01-08 | David Norlin | |
|
9ba9e4 | 2002-12-11 | Henrik Grubbström (Grubba) | | default:
parseError("illegal keyword: @%s", keyword);
|
35eee7 | 2001-01-08 | David Norlin | | }
|
d47c32 | 2001-03-06 | David Norlin | | }
|
f4c6ad | 2001-02-09 | David Norlin | | if (scopeModule)
meta->belongs = scopeModule;
|
35eee7 | 2001-01-08 | David Norlin | | return meta;
}
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | string getDoc(string context) {
string xml = xmlContainerContents(context);
|
d47c32 | 2001-03-06 | David Norlin | | switch (peekToken()->type) {
|
35eee7 | 2001-01-08 | David Norlin | | case ENDTOKEN:
break;
case ERRORKEYWORD:
|
d47c32 | 2001-03-06 | David Norlin | | parseError("illegal keyword: @"+ peekToken()->keyword);
|
35eee7 | 2001-01-08 | David Norlin | | default:
parseError("expected end of doc comment");
}
return xml;
}
}
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
d47c32 | 2001-03-06 | David Norlin | | array(array(Token)) splitDocBlock(string block, SourcePosition position) {
array(Token) tokens = split(block, position);
array(Token) current = ({ });
array(array(Token)) result = ({ });
|
955639 | 2001-01-18 | David Norlin | | int prevMeta = 0;
|
d47c32 | 2001-03-06 | David Norlin | | foreach (tokens, Token token) {
int meta = token->type == METAKEYWORD;
|
955639 | 2001-01-18 | David Norlin | | if (meta && !prevMeta && sizeof(current)) {
result += ({ current });
current = ({ });
}
prevMeta = meta;
current += ({ token });
}
result += ({ current });
return result;
}
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | class Parse {
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | inherit DocParserClass;
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
9eaf1d | 2008-06-28 | Martin Nilsson | | protected int state;
protected MetaData mMetaData = 0;
protected string mDoc = 0;
protected string mContext = 0;
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
40ae6f | 2011-12-04 | Henrik Grubbström (Grubba) | | void create(string | array(Token) s, SourcePosition|void sp,
.Flags|void flags) {
::create(s, sp, flags);
|
dd2d3b | 2001-01-09 | David Norlin | | state = 0;
}
|
35eee7 | 2001-01-08 | David Norlin | |
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | MetaData metadata() {
|
d47c32 | 2001-03-06 | David Norlin | | if (state == 0) {
++state;
mMetaData = ::getMetaData();
}
return mMetaData;
|
35eee7 | 2001-01-08 | David Norlin | | }
|
1e72ec | 2010-08-29 | Henrik Grubbström (Grubba) | |
|
35eee7 | 2001-01-08 | David Norlin | | string doc(string context) {
|
d47c32 | 2001-03-06 | David Norlin | | if (state == 1) {
++state;
mContext == context;
mDoc = ::getDoc(context);
}
else if (state == 0 || state > 1 && mContext != context)
return 0;
return mDoc;
|
35eee7 | 2001-01-08 | David Norlin | | }
}
|