LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-21 02:08:12 +03:00
Code Issues Packages Projects Releases Wiki Activity

IPCCompiler: Use GenericLexer

Browse Source 
No behavior change.
This commit is contained in:
Nico Weber 2020-08-21 09:18:10 -04:00 committed by Andreas Kling
parent d4bcc689fb
commit 0d52e7f6e3
Notes: sideshowbarker 2024-07-19 03:21:40 +09:00 
Author: https://github.com/nico
Commit: https://github.com/SerenityOS/serenity/commit/0d52e7f6e30
Pull-request: https://github.com/SerenityOS/serenity/pull/3242
Reviewed-by: https://github.com/awesomekling
Reviewed-by: https://github.com/predmond
1 changed files with 36 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
DevTools/IPCCompiler/main.cpp
View File

@ -25,6 +25,7 @@
*/ */
#include <AK/Function.h> #include <AK/Function.h>
#include <AK/GenericLexer.h>
#include <AK/HashMap.h> #include <AK/HashMap.h>
#include <AK/StringBuilder.h> #include <AK/StringBuilder.h>
#include <LibCore/File.h> #include <LibCore/File.h>
@ -74,86 +75,51 @@ int main(int argc, char** argv)
} }
auto file_contents = file->read_all(); auto file_contents = file->read_all();
GenericLexer lexer(file_contents);
Vector<Endpoint> endpoints; Vector<Endpoint> endpoints;
Vector<char> buffer; auto assert_specific = [&](char ch) {
if (lexer.peek() != ch)
size_t index = 0; warn() << "assert_specific: wanted '" << ch << "', but got '" << lexer.peek() << "' at index " << lexer.tell();
bool saw_expected = lexer.consume_specific(ch);
auto peek = [&](size_t offset = 0) -> char { ASSERT(saw_expected);
if ((index + offset) < file_contents.size())
return file_contents[index + offset];
return 0;
};
auto consume_one = [&]() -> char {
return file_contents[index++];
};
auto extract_while = [&](Function<bool(char)> condition) -> String {
StringBuilder builder;
while (condition(peek()))
builder.append(consume_one());
return builder.to_string();
};
auto consume_specific = [&](char ch) {
if (peek() != ch) {
warn() << "consume_specific: wanted '" << ch << "', but got '" << peek() << "' at index " << index;
}
ASSERT(peek() == ch);
++index;
return ch;
};
auto consume_string = [&](const char* str) {
for (size_t i = 0, length = strlen(str); i < length; ++i)
consume_specific(str[i]);
}; };
auto consume_whitespace = [&] { auto consume_whitespace = [&] {
while (isspace(peek())) lexer.ignore_while([](char ch) { return isspace(ch); });
++index; if (lexer.peek() == '/' && lexer.peek(1) == '/')
if (peek() == '/' && peek(1) == '/') { lexer.ignore_until([](char ch) { return ch == '\n'; });
while (peek() != '\n')
++index;
}
}; };
auto parse_parameter = [&](Vector<Parameter>& storage) { auto parse_parameter = [&](Vector<Parameter>& storage) {
for (;;) { for (;;) {
Parameter parameter; Parameter parameter;
consume_whitespace(); consume_whitespace();
if (peek() == ')') if (lexer.peek() == ')')
break; break;
if (peek() == '[') { if (lexer.consume_specific('[')) {
consume_one();
for (;;) { for (;;) {
if (peek() == ']') { if (lexer.consume_specific(']')) {
consume_one();
consume_whitespace(); consume_whitespace();
break; break;
} }
if (peek() == ',') { if (lexer.consume_specific(',')) {
consume_one();
consume_whitespace(); consume_whitespace();
} }
auto attribute = extract_while([](char ch) { return ch != ']' && ch != ','; }); auto attribute = lexer.consume_until([](char ch) { return ch == ']' || ch == ','; });
parameter.attributes.append(attribute); parameter.attributes.append(attribute);
consume_whitespace(); consume_whitespace();
} }
} }
parameter.type = extract_while([](char ch) { return !isspace(ch); }); parameter.type = lexer.consume_until([](char ch) { return isspace(ch); });
consume_whitespace(); consume_whitespace();
parameter.name = extract_while([](char ch) { return !isspace(ch) && ch != ',' && ch != ')'; }); parameter.name = lexer.consume_until([](char ch) { return isspace(ch) || ch == ',' || ch == ')'; });
consume_whitespace(); consume_whitespace();
storage.append(move(parameter)); storage.append(move(parameter));
if (peek() == ',') { if (lexer.consume_specific(','))
consume_one();
continue; continue;
} if (lexer.peek() == ')')
if (peek() == ')')
break; break;
} }
}; };
@ -163,11 +129,9 @@ int main(int argc, char** argv)
consume_whitespace(); consume_whitespace();
parse_parameter(storage); parse_parameter(storage);
consume_whitespace(); consume_whitespace();
if (peek() == ',') { if (lexer.consume_specific(','))
consume_one();
continue; continue;
} if (lexer.peek() == ')')
if (peek() == ')')
break; break;
} }
}; };
@ -175,18 +139,15 @@ int main(int argc, char** argv)
auto parse_message = [&] { auto parse_message = [&] {
Message message; Message message;
consume_whitespace(); consume_whitespace();
Vector<char> buffer; message.name = lexer.consume_until([](char ch) { return isspace(ch) || ch == '('; });
while (!isspace(peek()) && peek() != '(')
buffer.append(consume_one());
message.name = String::copy(buffer);
consume_whitespace(); consume_whitespace();
consume_specific('('); assert_specific('(');
parse_parameters(message.inputs); parse_parameters(message.inputs);
consume_specific(')'); assert_specific(')');
consume_whitespace(); consume_whitespace();
consume_specific('='); assert_specific('=');
auto type = consume_one(); auto type = lexer.consume();
if (type == '>') if (type == '>')
message.is_synchronous = true; message.is_synchronous = true;
else if (type == '|') else if (type == '|')
@ -197,9 +158,9 @@ int main(int argc, char** argv)
consume_whitespace(); consume_whitespace();
if (message.is_synchronous) { if (message.is_synchronous) {
consume_specific('('); assert_specific('(');
parse_parameters(message.outputs); parse_parameters(message.outputs);
consume_specific(')'); assert_specific(')');
} }
consume_whitespace(); consume_whitespace();
@ -212,7 +173,7 @@ int main(int argc, char** argv)
consume_whitespace(); consume_whitespace();
parse_message(); parse_message();
consume_whitespace(); consume_whitespace();
if (peek() == '}') if (lexer.peek() == '}')
break; break;
} }
}; };
@ -220,22 +181,22 @@ int main(int argc, char** argv)
auto parse_endpoint = [&] { auto parse_endpoint = [&] {
endpoints.empend(); endpoints.empend();
consume_whitespace(); consume_whitespace();
consume_string("endpoint"); lexer.consume_specific("endpoint");
consume_whitespace(); consume_whitespace();
endpoints.last().name = extract_while([](char ch) { return !isspace(ch); }); endpoints.last().name = lexer.consume_while([](char ch) { return !isspace(ch); });
consume_whitespace(); consume_whitespace();
consume_specific('='); assert_specific('=');
consume_whitespace(); consume_whitespace();
auto magic_string = extract_while([](char ch) { return !isspace(ch) && ch != '{'; }); auto magic_string = lexer.consume_while([](char ch) { return !isspace(ch) && ch != '{'; });
endpoints.last().magic = magic_string.to_int().value(); endpoints.last().magic = magic_string.to_int().value();
consume_whitespace(); consume_whitespace();
consume_specific('{'); assert_specific('{');
parse_messages(); parse_messages();
consume_specific('}'); assert_specific('}');
consume_whitespace(); consume_whitespace();
}; };
while (index < file_contents.size()) while (lexer.tell()< file_contents.size())
parse_endpoint(); parse_endpoint();
out() << "#pragma once"; out() << "#pragma once";