コード例 #1
0
    void function_arg_minsize() const {
        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
                               "<def>\n"
                               "  <function name=\"foo\">\n"
                               "    <arg nr=\"1\"><minsize type=\"strlen\" arg=\"2\"/></arg>\n"
                               "    <arg nr=\"2\"><minsize type=\"argvalue\" arg=\"3\"/></arg>\n"
                               "    <arg nr=\"3\"/>\n"
                               "  </function>\n"
                               "</def>";

        Library library;
        readLibrary(library, xmldata);

        TokenList tokenList(nullptr);
        std::istringstream istr("foo(a,b,c);");
        tokenList.createTokens(istr);
        tokenList.front()->next()->astOperand1(tokenList.front());

        // arg1: type=strlen arg2
        const std::list<Library::ArgumentChecks::MinSize> *minsizes = library.argminsizes(tokenList.front(),1);
        ASSERT_EQUALS(true, minsizes != nullptr);
        ASSERT_EQUALS(1U, minsizes ? minsizes->size() : 1U);
        if (minsizes && minsizes->size() == 1U) {
            const Library::ArgumentChecks::MinSize &m = minsizes->front();
            ASSERT_EQUALS(Library::ArgumentChecks::MinSize::STRLEN, m.type);
            ASSERT_EQUALS(2, m.arg);
        }

        // arg2: type=argvalue arg3
        minsizes = library.argminsizes(tokenList.front(), 2);
        ASSERT_EQUALS(true, minsizes != nullptr);
        ASSERT_EQUALS(1U, minsizes ? minsizes->size() : 1U);
        if (minsizes && minsizes->size() == 1U) {
            const Library::ArgumentChecks::MinSize &m = minsizes->front();
            ASSERT_EQUALS(Library::ArgumentChecks::MinSize::ARGVALUE, m.type);
            ASSERT_EQUALS(3, m.arg);
        }
    }
コード例 #2
0
ファイル: recognizeExp.c プロジェクト: DanielsWrath/ADNC
void recognizeExpressions() {
  char *ar;
  List tl, tl1;  
  printf("give an expression: ");
  ar = readInput();
  while (ar[0] != '!') {
    tl = tokenList(ar); 
    printf("the token list is ");
    printList(tl);
    tl1 = tl;
    if ( acceptExpression(&tl1) && tl1 == NULL ) {
      printf("this is an expression\n"); 
    } else {
      printf("this is not an expression\n"); 
    }
    free(ar);
    freeTokenList(tl);
    printf("\ngive an expression: ");
    ar = readInput();
  }
  free(ar);
  printf("good bye\n");
}
コード例 #3
0
ファイル: EmailNotifier.cpp プロジェクト: LordGaav/sipxecs
OsStatus EmailNotifier::handleAlarm(const OsTime alarmTime,
      const UtlString& callingHost,
      const cAlarmData* alarmData,
      const UtlString& alarmMsg)
{
   OsStatus retval = OS_FAILED;

   //execute the mail command for each user
   UtlString groupKey(alarmData->getGroupName());
   if (!groupKey.isNull())
   {
      UtlContainable* pContact = mContacts.findValue(&groupKey);
      if (pContact)
      {
         // Process the comma separated list of contacts
         UtlString* contactList = dynamic_cast<UtlString*> (pContact);
         if (!contactList->isNull())
         {
            MailMessage message(mEmailStrFrom, mReplyTo, mSmtpServer);
            UtlTokenizer tokenList(*contactList);

            UtlString entry;
            while (tokenList.next(entry, ","))
            {
               message.To(entry, entry);
            }

            UtlString body;
            UtlString tempStr;

            body = mEmailStrIntro;
            body.append("\n");

            assembleMsg(mEmailStrAlarm, alarmData->getCode(), tempStr);
            body.append(tempStr);
            body.append("\n");

            assembleMsg(mEmailStrHost, callingHost, tempStr);
            body.append(tempStr);
            body.append("\n");

            OsDateTime logTime(alarmTime);
            UtlString strTime;
            logTime.getIsoTimeStringZus(strTime);
            assembleMsg(mEmailStrTime, strTime, tempStr);
            body.append(tempStr);
            body.append("\n");

            UtlString sevStr = OsSysLog::priorityName(alarmData->getSeverity());
            assembleMsg(mEmailStrSeverity, sevStr, tempStr);
            body.append(tempStr);
            body.append("\n");
            assembleMsg(mEmailStrDescription, alarmMsg, tempStr);
            body.append(tempStr);
            body.append("\n");
            assembleMsg(mEmailStrResolution, alarmData->getResolution(), tempStr);
            body.append(tempStr);
            OsSysLog::add(FAC_ALARM, PRI_DEBUG, "AlarmServer: email body is %s", body.data());

            message.Body(body);

            UtlSList subjectParams;
            UtlString codeStr(alarmData->getCode());
            UtlString titleStr(alarmData->getShortTitle());
            subjectParams.append(&codeStr);
            subjectParams.append(&titleStr);
            assembleMsg(mEmailStrSubject, subjectParams, tempStr);
            message.Subject(tempStr);

            // delegate send to separate task so as not to block
            EmailSendTask::getInstance()->sendMessage(message);
         }
      }
   }

   return retval;
}
コード例 #4
0
Foam::primitiveEntry::primitiveEntry(const keyType& keyword, const token& t)
:
    entry(keyword),
    ITstream(keyword, tokenList(1, t))
{}
コード例 #5
0
ファイル: importproject.cpp プロジェクト: Dmitry-Me/cppcheck
void ImportProject::importCompileCommands(std::istream &istr)
{
    std::map<std::string, std::string> values;

    // TODO: Use a JSON parser

    Settings settings;
    TokenList tokenList(&settings);
    tokenList.createTokens(istr);
    for (const Token *tok = tokenList.front(); tok; tok = tok->next()) {
        if (Token::Match(tok, "%str% : %str% [,}]")) {
            const std::string& key = tok->str();
            const std::string& value = tok->strAt(2);
            values[key.substr(1, key.size() - 2U)] = value.substr(1, value.size() - 2U);
        }

        else if (tok->str() == "}") {
            if (!values["file"].empty() && !values["command"].empty()) {
                struct FileSettings fs;
                fs.filename = Path::fromNativeSeparators(values["file"]);
                const std::string& command = values["command"];
                const std::string directory = Path::fromNativeSeparators(values["directory"]);
                std::string::size_type pos = 0;
                while (std::string::npos != (pos = command.find(' ',pos))) {
                    pos++;
                    if (pos >= command.size())
                        break;
                    if (command[pos] != '/' && command[pos] != '-')
                        continue;
                    pos++;
                    if (pos >= command.size())
                        break;
                    char F = command[pos++];
                    std::string fval;
                    while (pos < command.size() && command[pos] != ' ' && command[pos] != '=') {
                        if (command[pos] != '\\')
                            fval += command[pos];
                        pos++;
                    }
                    if (F=='D')
                        fs.defines += fval + ";";
                    else if (F=='U')
                        fs.undefs.insert(fval);
                    else if (F=='I')
                        fs.includePaths.push_back(fval);
                    else if (F=='s' && fval.compare(0,3,"td=") == 0)
                        fs.standard = fval.substr(3);
                    else if (F == 'i' && fval == "system") {
                        ++pos;
                        std::string isystem;
                        while (pos < command.size() && command[pos] != ' ') {
                            if (command[pos] != '\\')
                                isystem += command[pos];
                            pos++;
                        }
                        fs.systemIncludePaths.push_back(isystem);
                    }
                }
                std::map<std::string, std::string, cppcheck::stricmp> variables;
                fs.setIncludePaths(directory, fs.includePaths, variables);
                fs.setDefines(fs.defines);
                fileSettings.push_back(fs);
            }
            values.clear();
        }
    }
}
コード例 #6
0
ファイル: fvSchemes.C プロジェクト: BarisCumhur/OpenFOAM-dev
Foam::fvSchemes::fvSchemes(const objectRegistry& obr)
:
    IOdictionary
    (
        IOobject
        (
            "fvSchemes",
            obr.time().system(),
            obr,
            (
                obr.readOpt() == IOobject::MUST_READ
             || obr.readOpt() == IOobject::READ_IF_PRESENT
              ? IOobject::MUST_READ_IF_MODIFIED
              : obr.readOpt()
            ),
            IOobject::NO_WRITE
        )
    ),
    ddtSchemes_
    (
        ITstream
        (
            objectPath() + ".ddtSchemes",
            tokenList()
        )()
    ),
    defaultDdtScheme_
    (
        ddtSchemes_.name() + ".default",
        tokenList()
    ),
    d2dt2Schemes_
    (
        ITstream
        (
            objectPath() + ".d2dt2Schemes",
            tokenList()
        )()
    ),
    defaultD2dt2Scheme_
    (
        d2dt2Schemes_.name() + ".default",
        tokenList()
    ),
    interpolationSchemes_
    (
        ITstream
        (
            objectPath() + ".interpolationSchemes",
            tokenList()
        )()
    ),
    defaultInterpolationScheme_
    (
        interpolationSchemes_.name() + ".default",
        tokenList()
    ),
    divSchemes_
    (
        ITstream
        (
            objectPath() + ".divSchemes",
            tokenList()
        )()
    ),
    defaultDivScheme_
    (
        divSchemes_.name() + ".default",
        tokenList()
    ),
    gradSchemes_
    (
        ITstream
        (
            objectPath() + ".gradSchemes",
            tokenList()
        )()
    ),
    defaultGradScheme_
    (
        gradSchemes_.name() + ".default",
        tokenList()
    ),
    snGradSchemes_
    (
        ITstream
        (
            objectPath() + ".snGradSchemes",
            tokenList()
        )()
    ),
    defaultSnGradScheme_
    (
        snGradSchemes_.name() + ".default",
        tokenList()
    ),
    laplacianSchemes_
    (
        ITstream
        (
            objectPath() + ".laplacianSchemes",
            tokenList()
        )()
    ),
    defaultLaplacianScheme_
    (
        laplacianSchemes_.name() + ".default",
        tokenList()
    ),
    fluxRequired_
    (
        ITstream
        (
            objectPath() + ".fluxRequired",
            tokenList()
        )()
    ),
    defaultFluxRequired_(false),
    steady_(false)
{
    if
    (
        readOpt() == IOobject::MUST_READ
     || readOpt() == IOobject::MUST_READ_IF_MODIFIED
     || (readOpt() == IOobject::READ_IF_PRESENT && headerOk())
    )
    {
        read(schemesDict());
    }
}
コード例 #7
0
faSchemes::faSchemes(const objectRegistry& obr)
    :
    IOdictionary
    (
       IOobject
       (
           "faSchemes",
           obr.time().system(),
           obr,
//             IOobject::MUST_READ,
           IOobject::READ_IF_PRESENT,  // Allow default dictionary creation
           IOobject::NO_WRITE
       )
    ),
    ddtSchemes_(ITstream("ddtSchemes", tokenList())()),
    defaultDdtScheme_("default", tokenList()),
    d2dt2Schemes_(ITstream("d2dt2Schemes", tokenList())()),
    defaultD2dt2Scheme_("default", tokenList()),
    interpolationSchemes_(ITstream("interpolationSchemes", tokenList())()),
    defaultInterpolationScheme_("default", tokenList()),
    divSchemes_(ITstream("divSchemes", tokenList())()),
    defaultDivScheme_("default", tokenList()),
    gradSchemes_(ITstream("gradSchemes", tokenList())()),
    defaultGradScheme_("default", tokenList()),
    lnGradSchemes_(ITstream("lnGradSchemes", tokenList())()),
    defaultLnGradScheme_("default", tokenList()),
    laplacianSchemes_(ITstream("laplacianSchemes", tokenList())()),
    defaultLaplacianScheme_("default", tokenList()),
    fluxRequired_(ITstream("fluxRequired", tokenList())())
{
    if (!headerOk())
    {
        if (debug)
        {
            InfoIn
            (
                "faSchemes::faSchemes(const objectRegistry& obr)"
            )   << "faSchemes dictionary not found.  Creating default."
                << endl;
        }
    }

    read();
}
コード例 #8
0
Foam::fvSchemes::fvSchemes(const objectRegistry& obr)
    :
    IOdictionary
    (
       IOobject
       (
           "fvSchemes",
           obr.time().system(),
           obr,
           (
               obr.readOpt() == IOobject::MUST_READ
               ? IOobject::MUST_READ_IF_MODIFIED
               : obr.readOpt()
           ),
           IOobject::NO_WRITE
       )
    ),
    ddtSchemes_
    (
       ITstream
       (
           objectPath() + "::ddtSchemes",
           tokenList()
       )()
    ),
    defaultDdtScheme_
    (
       ddtSchemes_.name() + "::default",
       tokenList()
    ),
    d2dt2Schemes_
    (
       ITstream
       (
           objectPath() + "::d2dt2Schemes",
           tokenList()
       )()
    ),
    defaultD2dt2Scheme_
    (
       d2dt2Schemes_.name() + "::default",
       tokenList()
    ),
    interpolationSchemes_
    (
       ITstream
       (
           objectPath() + "::interpolationSchemes",
           tokenList()
       )()
    ),
    defaultInterpolationScheme_
    (
       interpolationSchemes_.name() + "::default",
       tokenList()
    ),
    divSchemes_
    (
       ITstream
       (
           objectPath() + "::divSchemes",
           tokenList()
       )()
    ),
    defaultDivScheme_
    (
       divSchemes_.name() + "::default",
       tokenList()
    ),
    gradSchemes_
    (
       ITstream
       (
           objectPath() + "::gradSchemes",
           tokenList()
       )()
    ),
    defaultGradScheme_
    (
       gradSchemes_.name() + "::default",
       tokenList()
    ),
    snGradSchemes_
    (
       ITstream
       (
           objectPath() + "::snGradSchemes",
           tokenList()
       )()
    ),
    defaultSnGradScheme_
    (
       snGradSchemes_.name() + "::default",
       tokenList()
    ),
    laplacianSchemes_
    (
       ITstream
       (
           objectPath() + "::laplacianSchemes",
           tokenList()
       )()
    ),
    defaultLaplacianScheme_
    (
       laplacianSchemes_.name() + "::default",
       tokenList()
    ),
    fluxRequired_
    (
       ITstream
       (
           objectPath() + "::fluxRequired",
           tokenList()
       )()
    ),
    defaultFluxRequired_(false)
{
    // persistent settings across reads is incorrect
    clear();

    if
    (
        readOpt() == IOobject::MUST_READ
        || readOpt() == IOobject::MUST_READ_IF_MODIFIED
    )
    {
        read(schemesDict());
    }
}
コード例 #9
0
Foam::fvSchemes::fvSchemes(const objectRegistry& obr)
:
    IOdictionary
    (
        IOobject
        (
            "fvSchemes",
            obr.time().system(),
            obr,
//             IOobject::MUST_READ,
            IOobject::READ_IF_PRESENT,  // Allow default dictionary creation
            IOobject::NO_WRITE
        )
    ),
    ddtSchemes_
    (
        ITstream
        (
            objectPath() + "::ddtSchemes",
            tokenList()
        )()
    ),
    defaultDdtScheme_
    (
        ddtSchemes_.name() + "::default",
        tokenList()
    ),
    d2dt2Schemes_
    (
        ITstream
        (
            objectPath() + "::d2dt2Schemes",
            tokenList()
        )()
    ),
    defaultD2dt2Scheme_
    (
        d2dt2Schemes_.name() + "::default",
        tokenList()
    ),
    interpolationSchemes_
    (
        ITstream
        (
            objectPath() + "::interpolationSchemes",
            tokenList()
        )()
    ),
    defaultInterpolationScheme_
    (
        interpolationSchemes_.name() + "::default",
        tokenList()
    ),
    divSchemes_
    (
        ITstream
        (
            objectPath() + "::divSchemes",
            tokenList()
        )()
    ),
    defaultDivScheme_
    (
        divSchemes_.name() + "::default",
        tokenList()
    ),
    gradSchemes_
    (
        ITstream
        (
            objectPath() + "::gradSchemes",
            tokenList()
        )()
    ),
    defaultGradScheme_
    (
        gradSchemes_.name() + "::default",
        tokenList()
    ),
    snGradSchemes_
    (
        ITstream
        (
            objectPath() + "::snGradSchemes",
            tokenList()
        )()
    ),
    defaultSnGradScheme_
    (
        snGradSchemes_.name() + "::default",
        tokenList()
    ),
    laplacianSchemes_
    (
        ITstream
        (
            objectPath() + "::laplacianSchemes",
            tokenList()
        )()
    ),
    defaultLaplacianScheme_
    (
        laplacianSchemes_.name() + "::default",
        tokenList()
    ),
    fluxRequired_
    (
        ITstream
        (
            objectPath() + "::fluxRequired",
            tokenList()
        )()
    ),
    defaultFluxRequired_(false),
    cacheFields_
    (
        ITstream
        (
            objectPath() + "::cacheFields",
            tokenList()
        )()
    )
{
    if (!headerOk())
    {
        if (debug)
        {
            InfoIn
            (
                "fvSchemes::fvSchemes(const objectRegistry& obr)"
            )   << "fvSchemes dictionary not found.  Creating default."
                << endl;
        }

        regIOobject::write();
    }

    read();
}