inline void flush( Polygon &polyline )
    {
        appendTo( y1, polyline );

        if ( y2 > y1 )
            qSwap( yMin, yMax );

        if ( yMax != y1 )
            appendTo( yMax, polyline );

        if ( yMin != yMax )
            appendTo( yMin, polyline );

        if ( y2 != yMin )
            appendTo( y2, polyline );
    }
    inline void flush( Polygon &polyline )
    {
        appendTo( x1, polyline );

        if ( x2 > x1 )
            qSwap( xMin, xMax );

        if ( xMax != x1 )
            appendTo( xMax, polyline );

        if ( xMin != xMax )
            appendTo( xMin, polyline );

        if ( x2 != xMin )
            appendTo( x2, polyline );
    }
예제 #3
0
Vector<UChar> String::charactersWithNullTermination() const
{
    if (!m_impl)
        return Vector<UChar>();

    Vector<UChar> result;
    result.reserveInitialCapacity(length() + 1);
    appendTo(result);
    result.append('\0');
    return result;
}
예제 #4
0
파일: list.c 프로젝트: shinsy1023/emacs
int main(int argc, char const *argv[]) {
	list* linked = init_list();
	int i;
	for (i = 1; i < 6; i++) {
		appendTo(linked, newnode(i));
	}
	print_list(linked);
	delAt(linked, -1);
	delAt(linked, 5);
	print_list(linked);
	delAt(linked, 3);
	print_list(linked);
	return 0;
}
예제 #5
0
 ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
   ListNode* ans = NULL; 
   ListNode* ret = NULL;
   int increment = 0;
   while(l1 || l2 || increment) {
     int value = increment;
     if (l1) {
       value += l1->val;
       l1 = l1->next;
     }
     if (l2) {
       value += l2->val;
       l2 = l2->next;
     }
     increment = value / 10;
     value %= 10;
     bool isHead;
     ans = appendTo(ans, value, isHead);
     if (isHead) {
       ret = ans;
     }
   }
   return ret;
 }
예제 #6
0
LBasicBlock Output::appendTo(LBasicBlock block, LBasicBlock nextBlock)
{
    appendTo(block);
    return insertNewBlocksBefore(nextBlock);
}
void SimplePatternFormatterTest::TestManyPlaceholders() {
    UErrorCode status = U_ZERO_ERROR;
    SimplePatternFormatter fmt;
    fmt.compile(
            "Templates {2}{1}{5} and {4} are out of order.", status);
    assertSuccess("Status", status);
    assertFalse("startsWithPlaceholder", fmt.startsWithPlaceholder(2));
    assertEquals("PlaceholderCount", 6, fmt.getPlaceholderCount());
    UnicodeString values[] = {
            "freddy", "tommy", "frog", "billy", "leg", "{0}"};
    UnicodeString *params[] = {
           &values[0], &values[1], &values[2], &values[3], &values[4], &values[5]}; 
    int32_t offsets[6];
    int32_t expectedOffsets[6] = {-1, 22, 18, -1, 35, 27};
    UnicodeString appendTo("Prefix: ");
    assertEquals(
            "format",
            "Prefix: Templates frogtommy{0} and leg are out of order.",
            fmt.format(
                    params,
                    UPRV_LENGTHOF(params),
                    appendTo,
                    offsets,
                    UPRV_LENGTHOF(offsets),
                    status));
    assertSuccess("Status", status);
    for (int32_t i = 0; i < UPRV_LENGTHOF(expectedOffsets); ++i) {
        if (expectedOffsets[i] != offsets[i]) {
            errln("Expected %d, got %d", expectedOffsets[i], offsets[i]);
        }
    }
    appendTo.remove();

    // Not having enough placeholder params results in error.
    fmt.format(
            params,
            UPRV_LENGTHOF(params) - 1,
            appendTo,
            offsets,
            UPRV_LENGTHOF(offsets),
            status);
    if (status != U_ILLEGAL_ARGUMENT_ERROR) {
        errln("Expected U_ILLEGAL_ARGUMENT_ERROR");
    }

    // Ensure we don't write to offsets array beyond its length.
    status = U_ZERO_ERROR;
    offsets[UPRV_LENGTHOF(offsets) - 1] = 289;
    appendTo.remove();
    fmt.format(
            params,
            UPRV_LENGTHOF(params),
            appendTo,
            offsets,
            UPRV_LENGTHOF(offsets) - 1,
            status);
    assertEquals("Offsets buffer length", 289, offsets[UPRV_LENGTHOF(offsets) - 1]);

    // Test assignment
    SimplePatternFormatter s;
    s = fmt;
    appendTo.remove();
    assertEquals(
            "Assignment",
            "Templates frogtommy{0} and leg are out of order.",
            s.format(
                    params,
                    UPRV_LENGTHOF(params),
                    appendTo,
                    NULL,
                    0,
                    status));

    // Copy constructor
    SimplePatternFormatter r(fmt);
    appendTo.remove();
    assertEquals(
            "Copy constructor",
            "Templates frogtommy{0} and leg are out of order.",
            r.format(
                    params,
                    UPRV_LENGTHOF(params),
                    appendTo,
                    NULL,
                    0,
                    status));
    r.compile("{0} meter", status);
    assertEquals("PlaceholderCount", 1, r.getPlaceholderCount());
    appendTo.remove();
    assertEquals(
            "Replace with new compile",
            "freddy meter",
            r.format("freddy", appendTo, status));
    r.compile("{0}, {1}", status);
    assertEquals("PlaceholderCount", 2, r.getPlaceholderCount());
    appendTo.remove();
    assertEquals(
            "2 arg",
            "foo, bar",
            r.format("foo", "bar", appendTo, status));
    r.compile("{0}, {1} and {2}", status);
    assertEquals("PlaceholderCount", 3, r.getPlaceholderCount());
    appendTo.remove();
    assertEquals(
            "3 arg",
            "foo, bar and baz",
            r.format("foo", "bar", "baz", appendTo, status));
    assertSuccess("Status", status);
}
예제 #8
0
파일: format.c 프로젝트: MosheBerman/hebcal
char *formatLine( const date_t gregDate, 
                 const date_t hebDate, 
                 const char *text,
                 char *output,
                 size_t maxOutputLen
    )
{
    size_t formatLen = strlen(formatString);
    int allocLength = 200 + formatLen * 2;
    char autoBuf[allocLength];
    char *buf = autoBuf;
    char * bufEnd = buf + allocLength;
    char * bufIter = buf;
    char * formatEnd = formatString+ formatLen;
    const char *formatIter;

    if( ! buf )
        die( "unable to allocate %s bytes to format line", hc_itoa(strlen(formatString)*2));

    *buf = '\0';
    if( bufEnd > buf )
        *(bufEnd - 1) = '\0';

    for( formatIter = formatString; 
         formatIter < formatEnd && *formatIter; 
         formatIter++)
    {
        switch( *formatIter )
        {
        case '\\':
            formatIter++;
            if( formatIter >=formatEnd || ! *formatIter)
                break;
            switch( *formatIter )
            {
            case 'n':
                appendTo(&buf, &bufEnd, &bufIter, "\n");
                break;
            case 'b':
                appendTo(&buf, &bufEnd, &bufIter, "\b");
                break;
            case 'e':
                appendTo(&buf, &bufEnd, &bufIter, "\033");
                break;
            case 'f':
                appendTo(&buf, &bufEnd, &bufIter, "\f");
                break;
            case 'r':
                appendTo(&buf, &bufEnd, &bufIter, "\r");
                break;
            case 't':
                appendTo(&buf, &bufEnd, &bufIter, "\t");
                break;
            case '\\':
                appendTo(&buf, &bufEnd, &bufIter, "\\");
                break;
            }
            break;
        case '%':
            formatIter++;
            if( formatIter >=formatEnd || ! *formatIter)
                break;
            switch( *formatIter )
            {
            case '%':
                appendTo(&buf, &bufEnd, &bufIter, "%");
                break;
            case 'a':           /* abbreviated weekday name */
                appendTo(&buf, &bufEnd, &bufIter, ShortDayNames[dayOfWeek(gregDate)]);
                break;
            case 'Y':           /* year */
                appendTo(&buf, &bufEnd, &bufIter, hc_itoa(gregDate.yy));
                break;
            case 'm':           /* month */
                appendTo(&buf, &bufEnd, &bufIter, hc_itoa(gregDate.mm));
                break;
            case 'd':           /* day of month */
                appendTo(&buf, &bufEnd, &bufIter, hc_itoa(gregDate.dd));
                break;

            case 'Q': /* hebrew year */
                appendTo(&buf, &bufEnd, &bufIter, hc_itoa(hebDate.yy));
                break;
                
            case 'q': /* hebrew month */
                appendTo(&buf, &bufEnd, &bufIter, hc_itoa(hebDate.mm));
                break;
            case 'k': /* hebrew day */
                appendTo(&buf, &bufEnd, &bufIter, hc_itoa(hebDate.dd));
                break;
            case 'J': /* julian day number */
            {
                char numBuf[20];
                snprintf(numBuf, 20, "%ld",greg2abs(gregDate));
                numBuf[19] = '\0';
                appendTo(&buf, &bufEnd, &bufIter, numBuf);
                break;
            }
                
            case 't': /* holiday text */
                appendTo(&buf, &bufEnd, &bufIter, text);
                break;

/*             default: */
/*                 die ("unknown %% escape: %s",formatIter); */
            }
            break;
        default:
            *bufIter++ = *formatIter;
            break;
        }
    }
    *bufIter++ = '\0';

    strncpy( output, buf, maxOutputLen);

    output[maxOutputLen-1] ='\0';
    return output;
}
예제 #9
0
std::string GlogStyleFormatter::formatMessage(
    const LogMessage& message,
    const LogCategory* /* handlerCategory */) {
  // Get the local time info
  struct tm ltime;
  auto timeSinceEpoch = message.getTimestamp().time_since_epoch();
  auto epochSeconds =
      std::chrono::duration_cast<std::chrono::seconds>(timeSinceEpoch);
  std::chrono::microseconds usecs =
      std::chrono::duration_cast<std::chrono::microseconds>(timeSinceEpoch) -
      epochSeconds;
  time_t unixTimestamp = epochSeconds.count();
  if (!localtime_r(&unixTimestamp, &ltime)) {
    memset(&ltime, 0, sizeof(ltime));
  }

  auto basename = message.getFileBaseName();
  auto headerFormatter = folly::format(
      "{}{:02d}{:02d} {:02d}:{:02d}:{:02d}.{:06d} {:5d} {}:{}] ",
      getGlogLevelName(message.getLevel())[0],
      ltime.tm_mon + 1,
      ltime.tm_mday,
      ltime.tm_hour,
      ltime.tm_min,
      ltime.tm_sec,
      usecs.count(),
      message.getThreadID(),
      basename,
      message.getLineNumber());

  // TODO: Support including thread names and thread context info.

  // The fixed portion of the header takes up 31 bytes.
  //
  // The variable portions that we can't account for here include the line
  // number and the thread ID (just in case it is larger than 6 digits long).
  // Here we guess that 40 bytes will be long enough to include room for this.
  //
  // If this still isn't long enough the string will grow as necessary, so the
  // code will still be correct, but just slightly less efficient than if we
  // had allocated a large enough buffer the first time around.
  size_t headerLengthGuess = 40 + basename.size();

  // Format the data into a buffer.
  std::string buffer;
  StringPiece msgData{message.getMessage()};
  if (message.containsNewlines()) {
    // If there are multiple lines in the log message, add a header
    // before each one.
    std::string header;
    header.reserve(headerLengthGuess);
    headerFormatter.appendTo(header);

    // Make a guess at how many lines will be in the message, just to make an
    // initial buffer allocation.  If the guess is too small then the string
    // will reallocate and grow as necessary, it will just be slightly less
    // efficient than if we had guessed enough space.
    size_t numLinesGuess = 4;
    buffer.reserve(((header.size() + 1) * numLinesGuess) + msgData.size());

    size_t idx = 0;
    while (true) {
      auto end = msgData.find('\n', idx);
      if (end == StringPiece::npos) {
        end = msgData.size();
      }

      buffer.append(header);
      auto line = msgData.subpiece(idx, end - idx);
      buffer.append(line.data(), line.size());
      buffer.push_back('\n');

      if (end == msgData.size()) {
        break;
      }
      idx = end + 1;
    }
  } else {
    buffer.reserve(headerLengthGuess + msgData.size());
    headerFormatter.appendTo(buffer);
    buffer.append(msgData.data(), msgData.size());
    buffer.push_back('\n');
  }

  return buffer;
}