static void
skipToNonemptyLine(TConn * const connectionP,
                   time_t  const deadline,
                   bool *  const errorP) {

    char * const bufferStart = connectionP->buffer.t + connectionP->bufferpos;

    bool gotNonEmptyLine;
    bool error;
    char * lineStart;
    
    lineStart       = bufferStart;  /* initial value */
    gotNonEmptyLine = FALSE;        /* initial value */
    error           = FALSE;        /* initial value */          

    while (!gotNonEmptyLine && !error) {
        char * lineEnd;

        getLineInBuffer(connectionP, lineStart, deadline, &lineEnd, &error);

        if (!error) {
            if (!isEmptyLine(lineStart))
                gotNonEmptyLine = TRUE;
            else
                lineStart = lineEnd;
        }
    }
    if (!error) {
        /* Consume all the empty lines; advance buffer pointer to first
           non-empty line.
        */
        connectionP->bufferpos = lineStart - connectionP->buffer.t;
    }
    *errorP = error;
}
Example #2
0
static int scriptinternalstep(int fromIp) //internal step routine
{
    int maxIp = (int)linemap.size(); //maximum ip
    if(fromIp >= maxIp) //script end
        return fromIp;
    while(isEmptyLine(linemap.at(fromIp).type) && fromIp < maxIp) //skip empty lines
        fromIp++;
    fromIp++;
    return fromIp;
}
static void
readHeader(TConn * const connectionP,
           time_t  const deadline,
           bool *  const endOfHeadersP,
           char ** const headerP,
           bool *  const errorP) {
/*----------------------------------------------------------------------------
   Read an HTTP header, or the end of headers empty line, on connection
   *connectionP.

   An HTTP header is basically a line, except that if a line starts
   with white space, it's a continuation of the previous line.  A line
   is delimited by either LF or CRLF.

   The first line of an HTTP header is never empty; an empty line signals
   the end of the HTTP headers and beginning of the HTTP body.  We call
   that empty line the EOH mark.

   We assume the connection is positioned to a header or EOH mark.
   
   In the course of reading, we read at least one character past the
   line delimiter at the end of the header or EOH mark; we may read
   much more.  But we leave everything after the header or EOH (and
   its line delimiter) in the internal buffer, with the buffer pointer
   pointing to it.

   We use stuff already in the internal buffer (perhaps left by a
   previous call to this subroutine) before reading any more from from
   the channel.

   We return as *headerP the next header as an ASCIIZ string, with no
   line delimiter.  That string is stored in the "unused" portion of
   the connection's internal buffer.  Iff there is no next header, we
   return *endOfHeadersP == true and nothing meaningful as *headerP.
-----------------------------------------------------------------------------*/
    char * const bufferStart = connectionP->buffer.t + connectionP->bufferpos;

    bool error;
    char * lineEnd;

    getLineInBuffer(connectionP, bufferStart, deadline, &lineEnd, &error);

    if (!error) {
        if (isContinuationLine(bufferStart))
            error = TRUE;
        else if (isEmptyLine(bufferStart)) {
            /* Consume the EOH mark from the buffer */
            connectionP->bufferpos = lineEnd - connectionP->buffer.t;
            *endOfHeadersP = TRUE;
        } else {
            /* We have the first line of a header; there may be more. */

            const char * headerEnd;

            *endOfHeadersP = FALSE;

            getRestOfHeader(connectionP, lineEnd, deadline,
                            &headerEnd, &error);

            if (!error) {
                *headerP = bufferStart;

                /* Consume the header from the buffer (but be careful --
                   you can't reuse that part of the buffer because the
                   string we will return is in it!
                */
                connectionP->bufferpos = headerEnd - connectionP->buffer.t;
            }
        }
    }
    *errorP = error;
}
Example #4
0
/**
 * Parses the content, provided by the Preprocessor object and
 * creates a new Makefile object.
 */
void Parser::apply(Preprocessor* pp,
                   Makefile* mkfile,
                   const QStringList& activeTargets)
{
    m_makefile = mkfile;
    m_activeTargets = activeTargets;
    m_preprocessor = pp;
    const Options* options = mkfile->options();
    m_silentCommands = options->suppressOutputMessages;
    m_ignoreExitCodes = !options->stopOnErrors;
    m_suffixes.clear();
    m_suffixes << QLatin1String(".exe")
               << QLatin1String(".obj")
               << QLatin1String(".asm")
               << QLatin1String(".c")
               << QLatin1String(".cpp")
               << QLatin1String(".cxx")
               << QLatin1String(".bas")
               << QLatin1String(".cbl")
               << QLatin1String(".for")
               << QLatin1String(".pas")
               << QLatin1String(".res")
               << QLatin1String(".rc");
    m_syncPoints.clear();
    m_ruleIdxByToExtension.clear();
    int dbSeparatorPos, dbSeparatorLength, dbCommandSeparatorPos;

    try {
        readLine();
        while (!m_line.isNull()) {
            QString expandedLine = m_preprocessor->macroTable()->expandMacros(m_line);
            if (isEmptyLine(expandedLine)) {
                readLine();
            } else if (isDotDirective(expandedLine)) {
                m_line = expandedLine;
                Preprocessor::removeInlineComments(m_line);
                parseDotDirective();
            } else if (isInferenceRule(expandedLine)) {
                m_line = expandedLine;
                Preprocessor::removeInlineComments(m_line);
                parseInferenceRule();
            } else if (isDescriptionBlock(dbSeparatorPos, dbSeparatorLength, dbCommandSeparatorPos)) {
                parseDescriptionBlock(dbSeparatorPos, dbSeparatorLength, dbCommandSeparatorPos);
            } else {
                error(QLatin1String("syntax error"));
            }
        }
    } catch (FileException&) {
        throw;
    } catch (Exception &e) {
        // Enrich the error message with filename and line number.
        error(e.message());
    }

    // if the makefile doesn't contain target, we can stop here
    if (m_makefile->targets().isEmpty())
        return;

    // make sure that all active targets exist
    foreach (const QString& targetName, m_activeTargets) {
        if (!m_makefile->target(targetName)) {
            QString msg = QLatin1String("Target %1 doesn't exist.");
            throw Exception(msg.arg(targetName));
        }
    }

    // if no active target is defined, use the first one
    if (m_activeTargets.isEmpty()) {
        m_activeTargets.append(m_makefile->firstTarget()->targetName());
    }

    m_makefile->calculateInferenceRulePriorities(m_suffixes);

    // translate sync points from .SYNC targets into real dependencies
    for (QHash<QString, QStringList>::const_iterator it = m_syncPoints.constBegin();
        it != m_syncPoints.constEnd(); ++it)
    {
        DescriptionBlock *target = m_makefile->target(it.key());
        if (!target)
            break;
        target->m_dependents += it.value();
        target->m_dependents.removeDuplicates();
    }

    // build rule suffix cache
    for (int i = m_makefile->inferenceRules().count(); --i >= 0;) {
        InferenceRule *ir = m_makefile->inferenceRules().at(i);
        m_ruleIdxByToExtension[ir->m_toExtension].prepend(ir);
    }

    // check for cycles in active targets
    foreach (const QString& targetName, m_activeTargets) {
        DescriptionBlock *target = m_makefile->target(targetName);
        checkForCycles(target);
        preselectInferenceRules(target);
    }