void
EmsMessage::parseRCWWOpmodeMessage()
{
parseBool(0, 1, EmsValue::EigenesProgrammAktiv, EmsValue::WW);
parseBool(1, 1, EmsValue::EigenesProgrammAktiv, EmsValue::Zirkulation);
parseEnum(2, EmsValue::Betriebsart, EmsValue::WW);
parseEnum(3, EmsValue::Betriebsart, EmsValue::Zirkulation);
parseBool(4, 1, EmsValue::Desinfektion, EmsValue::WW);
parseEnum(5, EmsValue::DesinfektionTag, EmsValue::WW);
parseInteger(6, 1, EmsValue::DesinfektionStunde, EmsValue::WW);
parseNumeric(8, 1, 1, EmsValue::MaxTemp, EmsValue::WW);
parseBool(9 ,1, EmsValue::EinmalLadungsLED, EmsValue::WW);
}
void
EmsMessage::parseRCSystemParameterMessage()
{
parseNumeric(5, 1, 1, EmsValue::MinTemp, EmsValue::Aussen);
parseEnum(6, EmsValue::GebaeudeArt, EmsValue::None);
parseBool(21, 1, EmsValue::ATDaempfung, EmsValue::None);
}
void
EmsMessage::parseUBAParameterWWMessage()
{
parseBool(1, 0, EmsValue::KesselSchalter, EmsValue::WW);
parseNumeric(2, 1, 1, EmsValue::SetTemp, EmsValue::WW);
parseNumeric(8, 1, 1, EmsValue::DesinfektionsTemp, EmsValue::WW);
parseEnum(7,EmsValue::Schaltpunkte, EmsValue::Zirkulation);
}
void
EmsMessage::parseRCHKOpmodeMessage(EmsValue::SubType subtype)
{
parseEnum(0, EmsValue::HeizArt, subtype);
parseNumeric(1, 1, 2, EmsValue::NachtTemp, subtype);
parseNumeric(2, 1, 2, EmsValue::TagTemp, subtype);
parseNumeric(3, 1, 2, EmsValue::UrlaubTemp, subtype);
parseNumeric(4, 1, 2, EmsValue::RaumEinfluss, subtype);
parseNumeric(6, 1, 2, EmsValue::RaumOffset, subtype);
parseEnum(7, EmsValue::Betriebsart, subtype);
parseNumeric(16, 1, 1, EmsValue::MinTemp, subtype);
parseNumeric(35, 1, 1, EmsValue::MaxTemp, subtype);
parseBool(19, 1, EmsValue::SchaltzeitOptimierung, subtype);
parseNumeric(22, 1, 1, EmsValue::SchwelleSommerWinter, subtype);
parseNumeric(23, 1, 1, EmsValue::FrostSchutzTemp, subtype);
parseEnum(25, EmsValue::RegelungsArt, subtype);
parseEnum(28, EmsValue::Frostschutz, subtype);
parseEnum(32, EmsValue::HeizSystem, subtype);
parseEnum(33, EmsValue::FuehrungsGroesse, subtype);
parseNumeric(36, 1, 1, EmsValue::AuslegungsTemp, subtype);
parseNumeric(37, 1, 2, EmsValue::RaumUebersteuerTemp, subtype);
parseNumeric(38, 1, 1, EmsValue::AbsenkungsAbbruchTemp, subtype);
parseNumeric(39, 1, 1, EmsValue::AbsenkungsSchwellenTemp, subtype);
parseNumeric(40, 1, 1, EmsValue::UrlaubAbsenkungsSchwellenTemp, subtype);
parseEnum(41, EmsValue::UrlaubAbsenkungsArt, subtype);
}
void
EmsMessage::parseUBAMaintenanceSettingsMessage()
{
parseEnum(0,EmsValue::Wartungsmeldungen, EmsValue::Kessel);
parseInteger(1, 1, EmsValue::HektoStundenVorWartung, EmsValue::Kessel);
if (canAccess(2, sizeof(EmsProto::DateRecord))) {
EmsProto::DateRecord *record = (EmsProto::DateRecord *) &m_data.at(2 - m_offset);
m_valueHandler(EmsValue(EmsValue::Wartungstermin, EmsValue::Kessel, *record));
}
}
void
EmsMessage::parseUBAMonitorWWMessage()
{
parseNumeric(0, 1, 1, EmsValue::SollTemp, EmsValue::WW);
parseNumeric(1, 2, 10, EmsValue::IstTemp, EmsValue::WW);
parseInteger(10, 3, EmsValue::WarmwasserbereitungsZeit, EmsValue::None);
parseInteger(13, 3, EmsValue::WarmwasserBereitungen, EmsValue::None);
parseBool(5, 0, EmsValue::Tagbetrieb, EmsValue::WW);
parseBool(5, 1, EmsValue::EinmalLadungAktiv, EmsValue::WW);
parseBool(5, 2, EmsValue::DesinfektionAktiv, EmsValue::WW);
parseBool(5, 3, EmsValue::WarmwasserBereitung, EmsValue::None);
parseBool(5, 4, EmsValue::NachladungAktiv, EmsValue::WW);
parseBool(5, 5, EmsValue::WarmwasserTempOK, EmsValue::None);
parseBool(7, 0, EmsValue::Tagbetrieb, EmsValue::Zirkulation);
parseBool(7, 2, EmsValue::ZirkulationAktiv, EmsValue::None);
parseEnum(8, EmsValue::WWSystemType, EmsValue::None);
}
void UnwrappedLineParser::parseStructuralElement() {
assert(!FormatTok->Tok.is(tok::l_brace));
switch (FormatTok->Tok.getKind()) {
case tok::at:
nextToken();
if (FormatTok->Tok.is(tok::l_brace)) {
parseBracedList();
break;
}
switch (FormatTok->Tok.getObjCKeywordID()) {
case tok::objc_public:
case tok::objc_protected:
case tok::objc_package:
case tok::objc_private:
return parseAccessSpecifier();
case tok::objc_interface:
case tok::objc_implementation:
return parseObjCInterfaceOrImplementation();
case tok::objc_protocol:
return parseObjCProtocol();
case tok::objc_end:
return; // Handled by the caller.
case tok::objc_optional:
case tok::objc_required:
nextToken();
addUnwrappedLine();
return;
default:
break;
}
break;
case tok::kw_namespace:
parseNamespace();
return;
case tok::kw_inline:
nextToken();
if (FormatTok->Tok.is(tok::kw_namespace)) {
parseNamespace();
return;
}
break;
case tok::kw_public:
case tok::kw_protected:
case tok::kw_private:
parseAccessSpecifier();
return;
case tok::kw_if:
parseIfThenElse();
return;
case tok::kw_for:
case tok::kw_while:
parseForOrWhileLoop();
return;
case tok::kw_do:
parseDoWhile();
return;
case tok::kw_switch:
parseSwitch();
return;
case tok::kw_default:
nextToken();
parseLabel();
return;
case tok::kw_case:
parseCaseLabel();
return;
case tok::kw_try:
parseTryCatch();
return;
case tok::kw_extern:
nextToken();
if (FormatTok->Tok.is(tok::string_literal)) {
nextToken();
if (FormatTok->Tok.is(tok::l_brace)) {
parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/false);
addUnwrappedLine();
return;
}
}
break;
case tok::identifier:
if (FormatTok->IsForEachMacro) {
parseForOrWhileLoop();
return;
}
// In all other cases, parse the declaration.
break;
default:
break;
}
do {
switch (FormatTok->Tok.getKind()) {
case tok::at:
nextToken();
if (FormatTok->Tok.is(tok::l_brace))
parseBracedList();
break;
case tok::kw_enum:
parseEnum();
break;
case tok::kw_typedef:
nextToken();
// FIXME: Use the IdentifierTable instead.
if (FormatTok->TokenText == "NS_ENUM")
parseEnum();
break;
case tok::kw_struct:
case tok::kw_union:
case tok::kw_class:
parseRecord();
// A record declaration or definition is always the start of a structural
// element.
break;
case tok::semi:
nextToken();
addUnwrappedLine();
return;
case tok::r_brace:
addUnwrappedLine();
return;
case tok::l_paren:
parseParens();
break;
case tok::caret:
nextToken();
if (FormatTok->Tok.isAnyIdentifier() ||
FormatTok->isSimpleTypeSpecifier())
nextToken();
if (FormatTok->is(tok::l_paren))
parseParens();
if (FormatTok->is(tok::l_brace))
parseChildBlock();
break;
case tok::l_brace:
if (!tryToParseBracedList()) {
// A block outside of parentheses must be the last part of a
// structural element.
// FIXME: Figure out cases where this is not true, and add projections
// for them (the one we know is missing are lambdas).
if (Style.BreakBeforeBraces != FormatStyle::BS_Attach)
addUnwrappedLine();
FormatTok->Type = TT_FunctionLBrace;
parseBlock(/*MustBeDeclaration=*/false);
addUnwrappedLine();
return;
}
// Otherwise this was a braced init list, and the structural
// element continues.
break;
case tok::kw_try:
// We arrive here when parsing function-try blocks.
parseTryCatch();
return;
case tok::identifier: {
StringRef Text = FormatTok->TokenText;
if (Style.Language == FormatStyle::LK_JavaScript && Text == "function") {
tryToParseJSFunction();
break;
}
nextToken();
if (Line->Tokens.size() == 1) {
if (FormatTok->Tok.is(tok::colon)) {
parseLabel();
return;
}
// Recognize function-like macro usages without trailing semicolon.
if (FormatTok->Tok.is(tok::l_paren)) {
parseParens();
if (FormatTok->NewlinesBefore > 0 &&
tokenCanStartNewLine(FormatTok->Tok) && Text == Text.upper()) {
addUnwrappedLine();
return;
}
} else if (FormatTok->HasUnescapedNewline && Text.size() >= 5 &&
Text == Text.upper()) {
// Recognize free-standing macros like Q_OBJECT.
addUnwrappedLine();
return;
}
}
break;
}
case tok::equal:
nextToken();
if (FormatTok->Tok.is(tok::l_brace)) {
parseBracedList();
}
break;
case tok::l_square:
parseSquare();
break;
default:
nextToken();
break;
}
} while (!eof());
}
void Moc::parse()
{
QList<NamespaceDef> namespaceList;
bool templateClass = false;
while (hasNext()) {
Token t = next();
switch (t) {
case NAMESPACE: {
int rewind = index;
if (test(IDENTIFIER)) {
if (test(EQ)) {
// namespace Foo = Bar::Baz;
until(SEMIC);
} else if (!test(SEMIC)) {
NamespaceDef def;
def.name = lexem();
next(LBRACE);
def.begin = index - 1;
until(RBRACE);
def.end = index;
index = def.begin + 1;
namespaceList += def;
index = rewind;
}
}
break;
}
case SEMIC:
case RBRACE:
templateClass = false;
break;
case TEMPLATE:
templateClass = true;
break;
case MOC_INCLUDE_BEGIN:
currentFilenames.push(symbol().unquotedLexem());
break;
case MOC_INCLUDE_END:
currentFilenames.pop();
break;
case Q_DECLARE_INTERFACE_TOKEN:
parseDeclareInterface();
break;
case Q_DECLARE_METATYPE_TOKEN:
parseDeclareMetatype();
break;
case USING:
if (test(NAMESPACE)) {
while (test(SCOPE) || test(IDENTIFIER))
;
next(SEMIC);
}
break;
case CLASS:
case STRUCT: {
if (currentFilenames.size() <= 1)
break;
ClassDef def;
if (!parseClassHead(&def))
continue;
while (inClass(&def) && hasNext()) {
if (next() == Q_OBJECT_TOKEN) {
def.hasQObject = true;
break;
}
}
if (!def.hasQObject)
continue;
for (int i = namespaceList.size() - 1; i >= 0; --i)
if (inNamespace(&namespaceList.at(i)))
def.qualified.prepend(namespaceList.at(i).name + "::");
knownQObjectClasses.insert(def.classname);
knownQObjectClasses.insert(def.qualified);
continue; }
default: break;
}
if ((t != CLASS && t != STRUCT)|| currentFilenames.size() > 1)
continue;
ClassDef def;
if (parseClassHead(&def)) {
FunctionDef::Access access = FunctionDef::Private;
for (int i = namespaceList.size() - 1; i >= 0; --i)
if (inNamespace(&namespaceList.at(i)))
def.qualified.prepend(namespaceList.at(i).name + "::");
while (inClass(&def) && hasNext()) {
switch ((t = next())) {
case PRIVATE:
access = FunctionDef::Private;
if (test(Q_SIGNALS_TOKEN))
error("Signals cannot have access specifier");
break;
case PROTECTED:
access = FunctionDef::Protected;
if (test(Q_SIGNALS_TOKEN))
error("Signals cannot have access specifier");
break;
case PUBLIC:
access = FunctionDef::Public;
if (test(Q_SIGNALS_TOKEN))
error("Signals cannot have access specifier");
break;
case CLASS: {
ClassDef nestedDef;
if (parseClassHead(&nestedDef)) {
while (inClass(&nestedDef) && inClass(&def)) {
t = next();
if (t >= Q_META_TOKEN_BEGIN && t < Q_META_TOKEN_END)
error("Meta object features not supported for nested classes");
}
}
} break;
case Q_SIGNALS_TOKEN:
parseSignals(&def);
break;
case Q_SLOTS_TOKEN:
switch (lookup(-1)) {
case PUBLIC:
case PROTECTED:
case PRIVATE:
parseSlots(&def, access);
break;
default:
error("Missing access specifier for slots");
}
break;
case Q_OBJECT_TOKEN:
def.hasQObject = true;
if (templateClass)
error("Template classes not supported by Q_OBJECT");
if (def.classname != "Qt" && def.classname != "QObject" && def.superclassList.isEmpty())
error("Class contains Q_OBJECT macro but does not inherit from QObject");
break;
case Q_GADGET_TOKEN:
def.hasQGadget = true;
if (templateClass)
error("Template classes not supported by Q_GADGET");
break;
case Q_PROPERTY_TOKEN:
parseProperty(&def);
break;
case Q_ENUMS_TOKEN:
parseEnumOrFlag(&def, false);
break;
case Q_FLAGS_TOKEN:
parseEnumOrFlag(&def, true);
break;
case Q_DECLARE_FLAGS_TOKEN:
parseFlag(&def);
break;
case Q_CLASSINFO_TOKEN:
parseClassInfo(&def);
break;
case Q_INTERFACES_TOKEN:
parseInterfaces(&def);
break;
case Q_PRIVATE_SLOT_TOKEN:
parseSlotInPrivate(&def, access);
break;
case Q_PRIVATE_PROPERTY_TOKEN:
parsePrivateProperty(&def);
break;
case ENUM: {
EnumDef enumDef;
if (parseEnum(&enumDef))
def.enumList += enumDef;
} break;
default:
FunctionDef funcDef;
funcDef.access = access;
int rewind = index;
if (parseMaybeFunction(&def, &funcDef)) {
if (funcDef.isConstructor) {
if ((access == FunctionDef::Public) && funcDef.isInvokable) {
def.constructorList += funcDef;
while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
funcDef.wasCloned = true;
funcDef.arguments.removeLast();
def.constructorList += funcDef;
}
}
} else if (funcDef.isDestructor) {
// don't care about destructors
} else {
if (access == FunctionDef::Public)
def.publicList += funcDef;
if (funcDef.isSlot) {
def.slotList += funcDef;
while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
funcDef.wasCloned = true;
funcDef.arguments.removeLast();
def.slotList += funcDef;
}
} else if (funcDef.isSignal) {
def.signalList += funcDef;
while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
funcDef.wasCloned = true;
funcDef.arguments.removeLast();
def.signalList += funcDef;
}
} else if (funcDef.isInvokable) {
def.methodList += funcDef;
while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
funcDef.wasCloned = true;
funcDef.arguments.removeLast();
def.methodList += funcDef;
}
}
}
} else {
index = rewind;
}
}
}
next(RBRACE);
if (!def.hasQObject && !def.hasQGadget && def.signalList.isEmpty() && def.slotList.isEmpty()
&& def.propertyList.isEmpty() && def.enumDeclarations.isEmpty())
continue; // no meta object code required
if (!def.hasQObject && !def.hasQGadget)
error("Class declarations lacks Q_OBJECT macro.");
checkSuperClasses(&def);
checkProperties(&def);
classList += def;
knownQObjectClasses.insert(def.classname);
knownQObjectClasses.insert(def.qualified);
}
}
}
int main(int argc, char **argv)
{
usb_dev_handle *handle = NULL;
int opt, len, action, argcnt;
char *myName = argv[0], *s, *rxBuffer = NULL;
FILE *fp;
while((opt = getopt(argc, argv, "?hv:p:V:P:S:d:D:O:e:n:tbw")) != -1){
switch(opt){
case 'h':
case '?': /* -h or -? (print this help and exit) */
usage(myName);
exit(1);
case 'v': /* -v <vendor-id> (defaults to 0x%x, can be '*' for any VID) */
vendorID = myAtoi(optarg);
break;
case 'p': /* -p <product-id> (defaults to 0x%x, can be '*' for any PID) */
productID = myAtoi(optarg);
break;
case 'V': /* -V <vendor-name-pattern> (shell style matching, defaults to '*') */
vendorNamePattern = optarg;
break;
case 'P': /* -P <product-name-pattern> (shell style matching, defaults to '*') */
productNamePattern = optarg;
break;
case 'S': /* -S <serial-pattern> (shell style matching, defaults to '*') */
serialPattern = optarg;
break;
case 'd': /* -d <databytes> (data bytes for requests given on command line) */
while((s = strtok(optarg, ", ")) != NULL){
optarg = NULL;
if(sendBytes != NULL){
sendBytes = realloc(sendBytes, sendByteCount + 1);
}else{
sendBytes = malloc(sendByteCount + 1);
}
sendBytes[sendByteCount++] = myAtoi(s);
}
break;
case 'D': /* -D <file> (data bytes for request taken from file) */
if((fp = fopen(optarg, "rb")) == NULL){
fprintf(stderr, "error opening %s: %s\n", optarg, strerror(errno));
exit(1);
}
fseek(fp, 0, SEEK_END);
len = ftell(fp);
fseek(fp, 0, SEEK_SET);
if(sendBytes != NULL){
sendBytes = realloc(sendBytes, sendByteCount + len);
}else{
sendBytes = malloc(sendByteCount + len);
}
fread(sendBytes + sendByteCount, 1, len, fp); /* would need error checking */
sendByteCount += len;
fclose(fp);
break;
case 'O': /* -O <file> (write received data bytes to file) */
outputFile = optarg;
break;
case 'e': /* -e <endpoint> (specify endpoint for some commands) */
endpoint = myAtoi(optarg);
break;
case 't': /* -t <timeout> (specify USB timeout in milliseconds) */
usbTimeout = myAtoi(optarg);
break;
case 'b': /* -b (binary output format, default is hex) */
outputFormatIsBinary = 1;
break;
case 'n': /* -n <count> (maximum number of bytes to receive) */
usbCount = myAtoi(optarg);
break;
case 'c': /* -c <configuration> (device configuration to choose) */
usbConfiguration = myAtoi(optarg);
break;
case 'i': /* -i <interface> (configuration interface to claim) */
usbInterface = myAtoi(optarg);
break;
case 'w': /* -w (suppress USB warnings, default is verbose) */
showWarnings = 0;
break;
default:
fprintf(stderr, "Option -%c unknown\n", opt);
exit(1);
}
}
argc -= optind;
argv += optind;
if(argc < 1){
usage(myName);
exit(1);
}
argcnt = 2;
if(strcasecmp(argv[0], "list") == 0){
action = ACTION_LIST;
argcnt = 1;
}else if(strcasecmp(argv[0], "control") == 0){
action = ACTION_CONTROL;
argcnt = 7;
}else if(strcasecmp(argv[0], "interrupt") == 0){
action = ACTION_INTERRUPT;
}else if(strcasecmp(argv[0], "bulk") == 0){
action = ACTION_BULK;
}else{
fprintf(stderr, "command %s not known\n", argv[0]);
usage(myName);
exit(1);
}
if(argc < argcnt){
fprintf(stderr, "Not enough arguments.\n");
usage(myName);
exit(1);
}
if(argc > argcnt){
fprintf(stderr, "Warning: only %d arguments expected, rest ignored.\n", argcnt);
}
usb_init();
if(usbOpenDevice(&handle, vendorID, vendorNamePattern, productID, productNamePattern, serialPattern, action == ACTION_LIST ? stdout : NULL, showWarnings ? stderr : NULL) != 0){
fprintf(stderr, "Could not find USB device with VID=0x%x PID=0x%x Vname=%s Pname=%s Serial=%s\n", vendorID, productID, vendorNamePattern, productNamePattern, serialPattern);
exit(1);
}
if(action == ACTION_LIST)
exit(0); /* we've done what we were asked to do already */
usbDirection = parseEnum(argv[1], "out", "in", NULL);
if(usbDirection){ /* IN transfer */
rxBuffer = malloc(usbCount);
}
if(action == ACTION_CONTROL){
int requestType;
usbType = parseEnum(argv[2], "standard", "class", "vendor", "reserved", NULL);
usbRecipient = parseEnum(argv[3], "device", "interface", "endpoint", "other", NULL);
usbRequest = myAtoi(argv[4]);
usbValue = myAtoi(argv[5]);
usbIndex = myAtoi(argv[6]);
requestType = ((usbDirection & 1) << 7) | ((usbType & 3) << 5) | (usbRecipient & 0x1f);
if(usbDirection){ /* IN transfer */
len = usb_control_msg(handle, requestType, usbRequest, usbValue, usbIndex, rxBuffer, usbCount, usbTimeout);
}else{ /* OUT transfer */
len = usb_control_msg(handle, requestType, usbRequest, usbValue, usbIndex, sendBytes, sendByteCount, usbTimeout);
}
}else{ /* must be ACTION_INTERRUPT or ACTION_BULK */
int retries = 1;
if(usb_set_configuration(handle, usbConfiguration) && showWarnings){
fprintf(stderr, "Warning: could not set configuration: %s\n", usb_strerror());
}
/* now try to claim the interface and detach the kernel HID driver on
* linux and other operating systems which support the call.
*/
while((len = usb_claim_interface(handle, usbInterface)) != 0 && retries-- > 0){
#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
if(usb_detach_kernel_driver_np(handle, 0) < 0 && showWarnings){
fprintf(stderr, "Warning: could not detach kernel driver: %s\n", usb_strerror());
}
#endif
}
if(len != 0 && showWarnings)
fprintf(stderr, "Warning: could not claim interface: %s\n", usb_strerror());
if(action == ACTION_INTERRUPT){
if(usbDirection){ /* IN transfer */
len = usb_interrupt_read(handle, endpoint, rxBuffer, usbCount, usbTimeout);
}else{
len = usb_interrupt_write(handle, endpoint, sendBytes, sendByteCount, usbTimeout);
}
}else{
if(usbDirection){ /* IN transfer */
len = usb_bulk_read(handle, endpoint, rxBuffer, usbCount, usbTimeout);
}else{
len = usb_bulk_write(handle, endpoint, sendBytes, sendByteCount, usbTimeout);
}
}
}
if(len < 0){
fprintf(stderr, "USB error: %s\n", usb_strerror());
exit(1);
}
if(usbDirection == 0) /* OUT */
printf("%d bytes sent.\n", len);
if(rxBuffer != NULL){
FILE *fp = stdout;
if(outputFile != NULL){
fp = fopen(outputFile, outputFormatIsBinary ? "wb" : "w");
if(fp == NULL){
fprintf(stderr, "Error writing \"%s\": %s\n", outputFile, strerror(errno));
exit(1);
}
}
if(outputFormatIsBinary){
fwrite(rxBuffer, 1, len, fp);
}else{
int i;
for(i = 0; i < len; i++){
if(i != 0){
if(i % 16 == 0){
fprintf(fp, "\n");
}else{
fprintf(fp, " ");
}
}
fprintf(fp, "0x%02x", rxBuffer[i] & 0xff);
}
if(i != 0)
fprintf(fp, "\n");
}
}
usb_close(handle);
if(rxBuffer != NULL)
free(rxBuffer);
return 0;
}
bool ClassParser::parseHeader(const char *strHeader, const char *strHeaderFullFilePath)
{
unsigned int i;
unsigned int iCount = strlen(strHeader);
int iSquareBracketsOfClassIndex = 0;
unsigned int iPosition;
bool bIsParsed;
EParseAction eAction = PARSE_ACTION_NOTHING;
EParseActionSecondary eSecondaryAction = PARSE_ACTION_SECONDARY_NOTHING;
for (i=0; i<iCount; i++) {
switch (eAction) {
case PARSE_ACTION_NOTHING:
if (strncmp(strHeader+i, "/*", 2) == 0) {
eAction = PARSE_ACTION_COMMENTS_OUT_MULTI_LINE;
i++;
if (ClassParserFind::findToNextChar(strHeader+i+1, "*/", &iPosition)) {
i+=iPosition+2;
eAction = PARSE_ACTION_NOTHING;
}
}
else if (strncmp(strHeader+i, "//", 2) == 0) {
eAction = PARSE_ACTION_COMMENTS_OUT_SINGLE_LINE;
i++;
if (ClassParserFind::findToNextChar(strHeader+i+1, "\n", &iPosition)) {
i+=iPosition+1;
eAction = PARSE_ACTION_NOTHING;
}
}
else {
if (eSecondaryAction != PARSE_ACTION_SECONDARY_NOTHING &&
eSecondaryAction != PARSE_ACTION_SECONDARY_IN_CLASS_BEGIN &&
eSecondaryAction != PARSE_ACTION_SECONDARY_IN_GOT_CLASS_NAME)
{
if (strHeader[i] == '{') {
iSquareBracketsOfClassIndex++;
}
else if (strHeader[i] == '}') {
iSquareBracketsOfClassIndex--;
if (iSquareBracketsOfClassIndex == 0) {
eSecondaryAction = PARSE_ACTION_SECONDARY_NOTHING;
if (ClassParserFind::findToNextChar(strHeader+i, ";", &iPosition)) {
i+=iPosition;
}
}
}
}
switch (eSecondaryAction) {
case PARSE_ACTION_SECONDARY_NOTHING:
if (strncmp(strHeader+i, "class", 5) == 0) {
ClassParserInformation s;
s.m_strClassType = "class";
s.m_strFromHeaderFile = strHeaderFullFilePath;
m_listClassInformation.append(s);
i += 5;
i += parseClass(strHeader+i, m_listClassInformation.size()-1);
}
else if (strncmp(strHeader+i, "struct", 6) == 0) {
ClassParserInformation s;
s.m_strClassType = "struct";
s.m_strFromHeaderFile = strHeaderFullFilePath;
m_listClassInformation.append(s);
i += 6;
i += parseClass(strHeader+i, m_listClassInformation.size()-1);
}
else if (strncmp(strHeader+i, "enum", 4) == 0) {
ClassParserInformation s;
s.m_strClassType = "enum";
s.m_strFromHeaderFile = strHeaderFullFilePath;
m_listClassInformation.append(s);
i += 4;
i += parseEnum(strHeader+i, m_listClassInformation.size()-1);
}
else if (strncmp(strHeader+i, "typedef", 7) == 0) {
ClassParserInformation s;
s.m_strClassType = "typedef";
s.m_strFromHeaderFile = strHeaderFullFilePath;
m_listClassInformation.append(s);
i += 7;
i += parseTypedef(strHeader+i, m_listClassInformation.size()-1);
}
else if (strncmp(strHeader+i, "template", 8) == 0) {
ClassParserInformation s;
s.m_strClassType = "template";
s.m_strFromHeaderFile = strHeaderFullFilePath;
i += 8;
i += ClassParserFind::parseTemplate(strHeader+i, &s);
m_listClassInformation.append(s);
}
else if (strncmp(strHeader+i, "union", 5) == 0) {
ClassParserInformation s;
s.m_strClassType = "union";
s.m_strFromHeaderFile = strHeaderFullFilePath;
i += 5;
i += ClassParserFind::parseTemplate(strHeader+i, &s);
m_listClassInformation.append(s);
}
else if (strncmp(strHeader+i, "#define", 7) == 0) {
i += 7;
i += ClassParserFind::parseDefine(strHeader+i, this);
}
else if (strncmp(strHeader+i, "#include", 8) == 0) {
bool bInPublicIncludeFolders;
QString strInclude = ClassParserFind::getIncludeHeader(strHeader+i+8, &iPosition, &bInPublicIncludeFolders);
if (strInclude.length() != 0) {
i+=8+iPosition;
ClassParserIncludeHeaderInformation s;
s.m_bInPublicIncludeFolders = bInPublicIncludeFolders;
s.m_strIncludeHeader = strInclude;
s.m_strIncludeHeaderWithFullFilePath = findFullFilePathForHeaderInformation(&s, strHeaderFullFilePath);
bIsParsed = isIncludeHeaderParsed(&s);
m_listIncludeHeader.append(s);
if (bIsParsed == false && s.m_strIncludeHeaderWithFullFilePath.length() != 0) {
QByteArray ba = s.m_strIncludeHeaderWithFullFilePath.toLatin1();
parse(ba.data());
}
}
}
else if (ClassParserFind::skipThisLine(strHeader, i, &iPosition) ) {
i=iPosition;
}
else {
i+= ClassParserFind::parsePossibleFunctionFromThisLine(strHeader+i);
}
break;
default:
break;
}
}
break;
case PARSE_ACTION_COMMENTS_OUT_MULTI_LINE:
if (strncmp(strHeader+i, "*/", 2) == 0) {
eAction = PARSE_ACTION_NOTHING;
i++;
}
break;
case PARSE_ACTION_COMMENTS_OUT_SINGLE_LINE:
if (strncmp(strHeader+i, "\n", 1) == 0) {
eAction = PARSE_ACTION_NOTHING;
i++;
}
break;
}
}
return false;
}
unsigned int ClassParser::parseClass(const char *strHeader, int iClassIndex) {
unsigned int i;
unsigned int iCount = strlen(strHeader);
unsigned int iPreviousImportantActionIndex = 0;
int iSquareBracketsIndex = 0;
int iSquareBracketsOfClassIndex = 0;
int iBracketsIndex = 0;
unsigned int iPosition;
unsigned int iPositionAdd;
int iMacroIndex;
bool bInTheQuotes = false;
EParseAction eAction = PARSE_ACTION_NOTHING;
EParseActionSecondary eSecondaryAction = PARSE_ACTION_SECONDARY_IN_CLASS_BEGIN;
EClassParserMemberType eFunctionType = FUNCTION_TYPE_PRIVATE;
EClassParserMemberType eMemberType;
for (i=0; i<iCount; i++) {
switch (eAction) {
case PARSE_ACTION_NOTHING:
if (bInTheQuotes == false && strncmp(strHeader+i, "/*", 2) == 0) {
eAction = PARSE_ACTION_COMMENTS_OUT_MULTI_LINE;
i++;
if (ClassParserFind::findToNextChar(strHeader+i+1, "*/", &iPosition)) {
i+=iPosition+2;
eAction = PARSE_ACTION_NOTHING;
}
}
else if (bInTheQuotes == false && strncmp(strHeader+i, "//", 2) == 0) {
eAction = PARSE_ACTION_COMMENTS_OUT_SINGLE_LINE;
i++;
if (ClassParserFind::findToNextChar(strHeader+i+1, "\n", &iPosition)) {
i+=iPosition+1;
eAction = PARSE_ACTION_NOTHING;
}
}
else {
if (eSecondaryAction != PARSE_ACTION_SECONDARY_NOTHING &&
eSecondaryAction != PARSE_ACTION_SECONDARY_IN_CLASS_BEGIN &&
eSecondaryAction != PARSE_ACTION_SECONDARY_IN_GOT_CLASS_NAME)
{
if (strHeader[i] == '{') {
iSquareBracketsOfClassIndex++;
}
else if (strHeader[i] == '}') {
iSquareBracketsOfClassIndex--;
if (iSquareBracketsOfClassIndex == 0) {
eSecondaryAction = PARSE_ACTION_SECONDARY_NOTHING;
if (ClassParserFind::findToNextChar(strHeader+i, ";", &iPosition)) {
i+=iPosition;
return i;
}
}
}
}
if (bInTheQuotes == false) {
if (strHeader[i] == '\"') {
bInTheQuotes = true;
continue;
}
}
else {
if (i == 0 && strHeader[i] == '\"') {
bInTheQuotes = false;
continue;
}
else if (i != 0 && strHeader[i-1] != '\\' && strHeader[i] == '\"') {
bInTheQuotes = false;
continue;
}
}
if (bInTheQuotes == false) {
switch (eSecondaryAction) {
case PARSE_ACTION_SECONDARY_NOTHING:
break;
case PARSE_ACTION_SECONDARY_IN_CLASS_BEGIN:
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_GOT_CLASS_NAME;
iPreviousImportantActionIndex = i;
i += ClassParserFind::parseClassName(strHeader+i, &m_listClassInformation[iClassIndex]);
if (strHeader[i] == ';') {
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
return i;
}
else {
if (strHeader[i] == '{') {
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
eFunctionType = FUNCTION_TYPE_PRIVATE;
iSquareBracketsOfClassIndex++;
}
}
break;
case PARSE_ACTION_SECONDARY_IN_GOT_CLASS_NAME:
if (strHeader[i] == '{') {
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
eFunctionType = FUNCTION_TYPE_PRIVATE;
iSquareBracketsOfClassIndex++;
}
break;
case PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING:
case PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FIRST_HAND_INFO:
case PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_BRACETS_OUT:
if ( !ClassParserFind::isThisEqualToSpace(strHeader[i]) &&
iSquareBracketsIndex == 0 && iBracketsIndex == 0 &&
strHeader[i] != '(' && strHeader[i] != '{' &&
strHeader[i] != ';' &&
strHeader[i] != ')' && strHeader[i] != '}' && strHeader[i] != '=') {
if (eSecondaryAction == PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_BRACETS_OUT) {
if (strncmp(strHeader+i, "const", 5) == 0) {
i+=4;
continue;
}
else if (iSquareBracketsIndex == 0 && iBracketsIndex == 0) {
SClassParserPossibleMacroWithoutKnownledge s;
s.m_pType = eFunctionType;
s.m_strMacroLine = ClassParserFind::getStringBetween(strHeader, iPreviousImportantActionIndex, i) ;
m_listClassInformation[iClassIndex].m_listPossibleMacroWithoutKnownledge.append( s );
}
}
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
EClassParserClassMainType eClassType = ClassParserFind::isStartWithClassType(strHeader+i, &iPosition);
if (eClassType == CLASS_MAIN_TYPE_CLASS) {
ClassParserInformation s;
s.m_strClassType = "class";
s.m_iParentClassIndex = iClassIndex;
s.m_strFromHeaderFile = m_listClassInformation[iClassIndex].m_strFromHeaderFile;
m_listClassInformation.append(s);
i += iPosition;
i += parseClass(strHeader+i, m_listClassInformation.size()-1);
}
else if (eClassType == CLASS_MAIN_TYPE_STRUCT) {
ClassParserInformation s;
s.m_strClassType = "struct";
s.m_iParentClassIndex = iClassIndex;
s.m_strFromHeaderFile = m_listClassInformation[iClassIndex].m_strFromHeaderFile;
m_listClassInformation.append(s);
i += iPosition;
i += parseClass(strHeader+i, m_listClassInformation.size()-1);
}
else if (eClassType == CLASS_MAIN_TYPE_ENUM) {
ClassParserInformation s;
s.m_strClassType = "enum";
s.m_iParentClassIndex = iClassIndex;
s.m_strFromHeaderFile = m_listClassInformation[iClassIndex].m_strFromHeaderFile;
m_listClassInformation.append(s);
i += iPosition;
i += parseEnum(strHeader+i, m_listClassInformation.size()-1);
}
else if (eClassType == CLASS_MAIN_TYPE_TYPEDEF) {
ClassParserInformation s;
s.m_strClassType = "typedef";
s.m_iParentClassIndex = iClassIndex;
s.m_strFromHeaderFile = m_listClassInformation[iClassIndex].m_strFromHeaderFile;
m_listClassInformation.append(s);
i += iPosition;
i += parseTypedef(strHeader+i, m_listClassInformation.size()-1);
}
else if (eClassType == CLASS_MAIN_TYPE_TEMPLATE) {
ClassParserInformation s;
s.m_strClassType = "template";
s.m_iParentClassIndex = iClassIndex;
s.m_strFromHeaderFile = m_listClassInformation[iClassIndex].m_strFromHeaderFile;
i += iPosition;
i += ClassParserFind::parseTemplate(strHeader+i, &s);
m_listClassInformation.append(s);
}
else if (eClassType == CLASS_MAIN_TYPE_UNION) {
ClassParserInformation s;
s.m_strClassType = "union";
s.m_iParentClassIndex = iClassIndex;
s.m_strFromHeaderFile = m_listClassInformation[iClassIndex].m_strFromHeaderFile;
i += iPosition;
i += ClassParserFind::parseTemplate(strHeader+i, &s);
m_listClassInformation.append(s);
}
else if (ClassParserFind::skipThisLine(strHeader, i, &iPosition) ) {
i=iPosition;
}
else if (isStartWithMacroBeginForFunction(strHeader+i, &iMacroIndex)) {
ClassParserFind::getFunctionWithMacroBegin(strHeader, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPosition, m_listMacroBeginForMember[iMacroIndex]);
i += iPosition;
}
else {
eMemberType = ClassParserFind::isStartWithMemberType(strHeader+i, &iPosition);
if (eMemberType != FUNCTION_TYPE_NONE) {
i+=iPosition;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FIRST_HAND_INFO;
eFunctionType = eMemberType;
}
else {
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_OR_DATATYPE;
iPreviousImportantActionIndex = i;
}
}
}
else if (eSecondaryAction == PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_BRACETS_OUT) {
if (strHeader[i] == '{' ) {
iSquareBracketsIndex = 1;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_INLINE;
}
else if (strHeader[i] == ';' ) {
// This call creates function from
// emit foo(); in inline function.
// Also Q_OBJECT handled incorrectly.
ClassParserFind::getFunctionBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPositionAdd, "");
i+=iPositionAdd;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
}
else if (strHeader[i] == '=' && iBracketsIndex == 0 && iSquareBracketsIndex == 0) {
ClassParserFind::getFunctionBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPositionAdd, "");
i+=iPositionAdd;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
}
}
break;
case PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_OR_DATATYPE:
if (strHeader[i] == ';') {
if (iSquareBracketsIndex == 0 && iBracketsIndex == 0) {
ClassParserFind::getDataTypeBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex]);
}
else {
ClassParserFind::getFunctionBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPositionAdd, "");
i+=iPositionAdd;
}
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
}
else if (strHeader[i] == '(' ) {
iBracketsIndex++;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_BRACETS_IN;
}
break;
case PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_BRACETS_IN:
if (strHeader[i] == ';' ) {
ClassParserFind::getFunctionBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPositionAdd, "");
i+=iPositionAdd;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
}
else if (strHeader[i] == '(' ) {
iBracketsIndex++;
}
else if (strHeader[i] == ')' ) {
iBracketsIndex--;
if (iBracketsIndex == 0) {
char c = ClassParserFind::findToNextNextValidNonSpaceChar(strHeader+i+1, &iPosition);
if (c == '(') { // function? still continues
i += iPosition;
iBracketsIndex++;
}
else {
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_BRACETS_OUT;
}
}
}
else if (strHeader[i] == '=' && iBracketsIndex == 0 && iSquareBracketsIndex == 0) {
ClassParserFind::getFunctionBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPositionAdd, "");
i+=iPositionAdd;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
}
break;
case PARSE_ACTION_SECONDARY_IN_THE_CLASS_GETTING_FUNCTION_INLINE:
if (strHeader[i] == '{' ) {
iSquareBracketsIndex++;
}
else if (strHeader[i] == '}' ) {
iSquareBracketsIndex--;
if (iSquareBracketsIndex==0) {
ClassParserFind::getFunctionBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPositionAdd, "");
i+=iPositionAdd;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
}
}
else if (strHeader[i] == ';' ) {
if (iSquareBracketsIndex==0) {
ClassParserFind::getFunctionBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPositionAdd, "");
i+=iPositionAdd;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
}
}
else if (strHeader[i] == '=') {
if (iSquareBracketsIndex == 0) {
ClassParserFind::getFunctionBetween(strHeader, iPreviousImportantActionIndex, i, eFunctionType, &m_listClassInformation[iClassIndex], &iPositionAdd, "");
i+=iPositionAdd;
eSecondaryAction = PARSE_ACTION_SECONDARY_IN_THE_CLASS_NOTHING;
}
}
break;
}
}
}
break;
case PARSE_ACTION_COMMENTS_OUT_MULTI_LINE:
if (strncmp(strHeader+i, "*/", 2) == 0) {
eAction = PARSE_ACTION_NOTHING;
i++;
}
break;
case PARSE_ACTION_COMMENTS_OUT_SINGLE_LINE:
if (strncmp(strHeader+i, "\n", 1) == 0) {
eAction = PARSE_ACTION_NOTHING;
i++;
}
break;
}
}
return i;
}
void
EmsMessage::parseUBAMaintenanceStatusMessage()
{
parseEnum(5, EmsValue::WartungFaellig, EmsValue::Kessel);
}
void UnwrappedLineParser::parseStatement() {
parseComments();
switch (FormatTok.Tok.getKind()) {
case tok::kw_namespace:
parseNamespace();
return;
case tok::kw_public:
case tok::kw_protected:
case tok::kw_private:
parseAccessSpecifier();
return;
case tok::kw_if:
parseIfThenElse();
return;
case tok::kw_for:
case tok::kw_while:
parseForOrWhileLoop();
return;
case tok::kw_do:
parseDoWhile();
return;
case tok::kw_switch:
parseSwitch();
return;
case tok::kw_default:
nextToken();
parseLabel();
return;
case tok::kw_case:
parseCaseLabel();
return;
default:
break;
}
int TokenNumber = 0;
do {
++TokenNumber;
switch (FormatTok.Tok.getKind()) {
case tok::kw_enum:
parseEnum();
return;
case tok::semi:
nextToken();
addUnwrappedLine();
return;
case tok::l_paren:
parseParens();
break;
case tok::l_brace:
parseBlock();
addUnwrappedLine();
return;
case tok::identifier:
nextToken();
if (TokenNumber == 1 && FormatTok.Tok.is(tok::colon)) {
parseLabel();
return;
}
break;
case tok::equal:
nextToken();
// Skip initializers as they will be formatted by a later step.
if (FormatTok.Tok.is(tok::l_brace))
nextToken();
break;
default:
nextToken();
break;
}
} while (!eof());
}
void PackageParser::parse() {
while (stream_.hasMoreTokens()) {
auto documentation = parseDocumentationToken();
auto exported = Attribute<E_EARTH_GLOBE_EUROPE_AFRICA>().parse(&stream_);
auto theToken = stream_.consumeToken(IDENTIFIER);
switch (theToken.value[0]) {
case E_PACKAGE: {
exported.disallow();
auto nameToken = stream_.consumeToken(VARIABLE);
auto namespaceToken = stream_.consumeToken(IDENTIFIER);
auto name = nameToken.value.utf8CString();
package_->loadPackage(name, namespaceToken.value[0], theToken);
continue;
}
case E_CROCODILE:
parseProtocol(documentation, theToken, exported.set());
continue;
case E_TURKEY:
parseEnum(documentation, exported.set());
continue;
case E_RADIO:
exported.disallow();
package_->setRequiresBinary();
if (strcmp(package_->name(), "_") == 0) {
throw CompilerErrorException(theToken, "You may not set 📻 for the _ package.");
}
continue;
case E_CRYSTAL_BALL: {
exported.disallow();
if (package_->validVersion()) {
throw CompilerErrorException(theToken, "Package version already declared.");
}
auto major = stream_.consumeToken(INTEGER).value.utf8CString();
auto minor = stream_.consumeToken(INTEGER).value.utf8CString();
uint16_t majori = strtol(major, nullptr, 0);
uint16_t minori = strtol(minor, nullptr, 0);
delete [] major;
delete [] minor;
package_->setPackageVersion(PackageVersion(majori, minori));
if (!package_->validVersion()) {
throw CompilerErrorException(theToken, "The provided package version is not valid.");
}
continue;
}
case E_WALE: {
exported.disallow();
EmojicodeChar className, enamespace;
bool optional;
auto &classNameToken = parseTypeName(&className, &enamespace, &optional);
if (optional) {
throw CompilerErrorException(classNameToken, "Optional types are not extendable.");
}
Type type = typeNothingness;
if (!package_->fetchRawType(className, enamespace, optional, theToken, &type)) {
throw CompilerErrorException(classNameToken, "Class does not exist.");
}
if (type.type() != TT_CLASS) {
throw CompilerErrorException(classNameToken, "Only classes are extendable.");
}
// Native extensions are allowed if the class was defined in this package.
parseClassBody(type.eclass, nullptr, type.eclass->package() == package_);
continue;
}
case E_RABBIT:
parseClass(documentation, theToken, exported.set());
continue;
case E_SCROLL: {
exported.disallow();
auto pathString = stream_.consumeToken(STRING);
auto relativePath = pathString.position().file;
auto fileString = pathString.value.utf8CString();
char *str = fileString;
const char *lastSlash = strrchr(relativePath, '/');
if (lastSlash != nullptr) {
const char *directory = strndup(relativePath, lastSlash - relativePath);
asprintf(&str, "%s/%s", directory, fileString);
delete [] fileString;
delete [] directory;
}
PackageParser(package_, lex(str)).parse();
delete [] str;
continue;
}
default:
ecCharToCharStack(theToken.value[0], f);
throw CompilerErrorException(theToken, "Unexpected identifier %s", f);
break;
}
}
}
