void SetLineNumber(TSourceLoc line, TSourceLoc& outLine) { outLine.file = NULL; outLine.line = line.line; if (line.file && line.file[0]) { // GLSL does not permit quoted strings in #line directives if(line.file[0] == '"') { TString stripped(line.file + 1); size_t len = stripped.size(); if(stripped[len - 1] == '"') { stripped.resize(len - 1); } outLine.file = NewPoolTString(stripped.c_str())->c_str(); } else { outLine.file = NewPoolTString(line.file)->c_str(); } } }
// Find and execute the given command. static CBM::IOErrorMessage execute(const QString& cmdString, Interface& iface) { QString params, stripped(cmdString); // Strip of trailing whitespace (in fact, CR for e.g. OPEN 1,8,15,"I:" which generates a CR. while(stripped.endsWith(QChar('\r')) or stripped.endsWith(QChar(' '))) stripped.chop(1); Command* dosCmd = find(stripped, params); if(0 not_eq dosCmd) return dosCmd->process(params, iface); return CBM::ErrCommandNotFound; } // execute
int QgsSpinBox::valueFromText( const QString &text ) const { if ( !mExpressionsEnabled ) { return QSpinBox::valueFromText( text ); } QString trimmedText = stripped( text ); if ( trimmedText.isEmpty() ) { return mShowClearButton ? clearValue() : value(); } return std::round( QgsExpression::evaluateToDouble( trimmedText, value() ) ); }
void DigitView::slotZoomChange(const QString &zoom) { QString stripped(zoom); if (stripped.right(1) == QString("%")) stripped.remove(stripped.length() - 1, 1); m_zoom = stripped.toInt(); double scale = (double) m_zoom / 100.0; QMatrix ms; ms.scale(scale, scale); setWorldMatrix(ms); updateContents(); }
void FontImporter::handlePage(std::stringstream & stream, FontFace * font, const std::string & filename) { const std::string path = iozeug::FilePath(filename).directoryPath(); extractKeyValuePairs(stream, [this, font, &path](const std::string & key, const std::string & value) { if (key == "file") { std::string filename = stripped(value, { '"', '\r' }); font->setGlyphTexture(m_resourceManager.load<globjects::Texture>(path + "/" + filename)); } else if (key == "id") { // nothing for now } }); }
static void display_filename (unsigned long linenum, char status, const char *filename, const char *patchname) { if (mode == mode_list && !file_matches ()) /* This is lsdiff --files=... and this file is not to be * listed. */ return; if (print_patchnames) printf ("%s:", patchname); if (numbering) printf ("%lu\t", linenum); if (number_files) printf ("File #%-3lu\t", filecount); if (show_status) printf ("%c ", status); if (prefix_to_add) fputs (prefix_to_add, stdout); puts (stripped (filename, strip_components)); }
// BTRTODO: Support arrays!? MaterialParameters* ProcessedCustomMaterial::allocMaterialParameters() { MaterialParameters* ret = Parent::allocMaterialParameters(); // See if any of the dynamic fields match up with shader constants we have. SimFieldDictionary* fields = mMaterial->getFieldDictionary(); if (!fields || fields->getNumFields() == 0) return ret; const Vector<GFXShaderConstDesc>& consts = ret->getShaderConstDesc(); for (U32 i = 0; i < consts.size(); i++) { // strip the dollar sign from the front. String stripped(consts[i].name); stripped.erase(0, 1); SimFieldDictionary::Entry* field = fields->findDynamicField(stripped); if (field) { MaterialParameterHandle* handle = getMaterialParameterHandle(consts[i].name); switch (consts[i].constType) { case GFXSCT_Float : setMaterialParameter<F32>(ret, handle, field->value); break; case GFXSCT_Float2: setMaterialParameter<Point2F>(ret, handle, field->value); break; case GFXSCT_Float3: setMaterialParameter<Point3F>(ret, handle, field->value); break; case GFXSCT_Float4: setMaterialParameter<Point4F>(ret, handle, field->value); break; case GFXSCT_Float2x2: case GFXSCT_Float3x3: setMatrixParameter(ret, handle, field->value, consts[i].constType); break; case GFXSCT_Float4x4: setMaterialParameter<MatrixF>(ret, handle, field->value); break; case GFXSCT_Int: setMaterialParameter<S32>(ret, handle, field->value); break; case GFXSCT_Int2: setMaterialParameter<Point2I>(ret, handle, field->value); break; case GFXSCT_Int3: setMaterialParameter<Point3I>(ret, handle, field->value); break; case GFXSCT_Int4: setMaterialParameter<Point4I>(ret, handle, field->value); break; // Do we want to ignore these? case GFXSCT_Sampler: case GFXSCT_SamplerCube: default: break; } } } return ret; }
/*! \param points Series of data points \return Curve points */ QPolygonF QwtWeedingCurveFitter::fitCurve( const QPolygonF &points ) const { QStack<Line> stack; stack.reserve( 500 ); const QPointF *p = points.data(); const int nPoints = points.size(); QVector<bool> usePoint( nPoints, false ); double distToSegment; stack.push( Line( 0, nPoints - 1 ) ); while ( !stack.isEmpty() ) { const Line r = stack.pop(); // initialize line segment const double vecX = p[r.to].x() - p[r.from].x(); const double vecY = p[r.to].y() - p[r.from].y(); const double vecLength = qSqrt( vecX * vecX + vecY * vecY ); const double unitVecX = ( vecLength != 0.0 ) ? vecX / vecLength : 0.0; const double unitVecY = ( vecLength != 0.0 ) ? vecY / vecLength : 0.0; double maxDist = 0.0; int nVertexIndexMaxDistance = r.from + 1; for ( int i = r.from + 1; i < r.to; i++ ) { //compare to anchor const double fromVecX = p[i].x() - p[r.from].x(); const double fromVecY = p[i].y() - p[r.from].y(); const double fromVecLength = qSqrt( fromVecX * fromVecX + fromVecY * fromVecY ); if ( fromVecX * unitVecX + fromVecY * unitVecY < 0.0 ) { distToSegment = fromVecLength; } if ( fromVecX * unitVecX + fromVecY * unitVecY < 0.0 ) { distToSegment = fromVecLength; } else { const double toVecX = p[i].x() - p[r.to].x(); const double toVecY = p[i].y() - p[r.to].y(); const double toVecLength = qSqrt( toVecX * toVecX + toVecY * toVecY ); const double s = toVecX * ( -unitVecX ) + toVecY * ( -unitVecY ); if ( s < 0.0 ) distToSegment = toVecLength; else { distToSegment = qSqrt( qFabs( toVecLength * toVecLength - s * s ) ); } } if ( maxDist < distToSegment ) { maxDist = distToSegment; nVertexIndexMaxDistance = i; } } if ( maxDist <= d_data->tolerance ) { usePoint[r.from] = true; usePoint[r.to] = true; } else { stack.push( Line( r.from, nVertexIndexMaxDistance ) ); stack.push( Line( nVertexIndexMaxDistance, r.to ) ); } } int cnt = 0; QPolygonF stripped( nPoints ); for ( int i = 0; i < nPoints; i++ ) { if ( usePoint[i] ) stripped[cnt++] = p[i]; } stripped.resize( cnt ); return stripped; }
// ====================================================================== void ListHookedKeyboard::Item::apply(const Params_KeyboardEventCallBack& params) { if (params.key >= KeyCode::VK__BEGIN__) { // Invalid keycode IOLOG_ERROR("ListHookedKeyboard::Item::apply invalid key:%d eventType:%d\n", params.key.get(), params.eventType.get()); return; } if (params.eventType == EventType::MODIFY && !params.key.isModifier()) { // Invalid modifierkeycode IOLOG_ERROR("ListHookedKeyboard::Item::apply invalid modifierkey:%08x\n", params.key.get()); return; } // ------------------------------------------------------------ KeyboardEventCallback callback = orig_keyboardEventAction_; if (!callback) return; OSObject* target = orig_keyboardEventTarget_; if (!target) return; OSObject* sender = OSDynamicCast(OSObject, device_); if (!sender) return; const AbsoluteTime& ts = CommonData::getcurrent_ts(); OSObject* refcon = nullptr; // ---------------------------------------- // Send an UpdateEventFlags event if needed. (Send before KeyboardEvent when EventType::DOWN) bool needUpdateEventFlagsEvent = false; if (params.flags.isOn(ModifierFlag::NUMPAD)) { needUpdateEventFlagsEvent = true; } if (needUpdateEventFlagsEvent && params.eventType == EventType::DOWN) { Params_UpdateEventFlagsCallback p(params.flags); apply(p); } // ---------------------------------------- Params_KeyboardEventCallBack::log(false, params.eventType, params.flags, params.key, params.keyboardType, params.repeat); { // We need to unlock the global lock while we are calling the callback function. // // When Sticky Keys (in Universal Access) is activated, // Apple driver calls EventInputQueue::push_* recursively. // // If we don't unlock the global lock, deadlock is occured. GlobalLock::ScopedUnlock lk; callback(target, params.eventType.get(), params.flags.get(), params.key.get(), params.charCode.get(), params.charSet.get(), params.origCharCode.get(), params.origCharSet.get(), params.keyboardType.get(), params.repeat, ts, sender, refcon); } // ---------------------------------------- // Send an UpdateEventFlags event if needed. (Send after KeyboardEvent when EventType::UP) if (needUpdateEventFlagsEvent && params.eventType == EventType::UP) { Flags stripped(params.flags); stripped.stripNUMPAD(); Params_UpdateEventFlagsCallback p(stripped); apply(p); } // ---------------------------------------- // The CapsLock LED is not designed to turn it on/off frequently. // So, we have to use the timer to call a setAlphaLock function at appropriate frequency. enum { CAPSLOCK_LED_DELAY_MS = 5, }; setcapslock_timer_.setTimeoutMS(CAPSLOCK_LED_DELAY_MS, false); }
static int filterdiff (FILE *f, const char *patchname) { static unsigned long linenum = 1; char *names[2]; char *header[MAX_HEADERS] = { NULL, NULL }; unsigned int num_headers = 0; char *line = NULL; size_t linelen = 0; char *p; const char *p_stripped; int match; int i; if (getline (&line, &linelen, f) == -1) return 0; for (;;) { char status = '!'; unsigned long start_linenum; int orig_file_exists, new_file_exists; int is_context = -1; int result; int (*do_diff) (FILE *, char **, unsigned int, int, char **, size_t *, unsigned long *, unsigned long, char, const char *, const char *, int *, int *); orig_file_exists = 0; // shut gcc up // Search for start of patch ("diff ", or "--- " for // unified diff, "*** " for context). for (;;) { if (!strncmp (line, "diff ", 5)) break; if (!strncmp (line, "--- ", 4)) { is_context = 0; break; } if (!strncmp (line, "*** ", 4)) { is_context = 1; break; } /* Show non-diff lines if excluding, or if * in verbose mode, and if --clean isn't specified. */ if (mode == mode_filter && (pat_exclude || verbose) && !clean_comments) fputs (line, stdout); if (getline (&line, &linelen, f) == -1) goto eof; linenum++; } start_linenum = linenum; header[0] = xstrdup (line); num_headers = 1; if (is_context == -1) { int valid_extended = 1; for (;;) { if (getline (&line, &linelen, f) == -1) goto eof; linenum++; if (!strncmp (line, "diff ", 5)) { header[num_headers++] = xstrdup (line); break; } if (!strncmp (line, "--- ", 4)) is_context = 0; else if (!strncmp (line, "*** ", 4)) is_context = 1; else if (strncmp (line, "old mode ", 9) && strncmp (line, "new mode ", 9) && strncmp (line, "deleted file mode ", 18) && strncmp (line, "new file mode ", 15) && strncmp (line, "copy from ", 10) && strncmp (line, "copy to ", 8) && strncmp (line, "rename from ", 12) && strncmp (line, "rename to ", 10) && strncmp (line, "similarity index ", 17) && strncmp (line, "dissimilarity index ", 20) && strncmp (line, "index ", 6)) valid_extended = 0; if (!valid_extended) break; /* Drop excess header lines */ if (num_headers >= MAX_HEADERS - 2) free (header[--num_headers]); header[num_headers++] = xstrdup (line); if (is_context != -1) break; } if (!valid_extended) goto flush_continue; } if (is_context == -1) { /* We don't yet do anything with diffs with * zero hunks. */ unsigned int i = 0; flush_continue: if (mode == mode_filter && (pat_exclude || verbose) && !clean_comments) { for (i = 0; i < num_headers; i++) fputs (header[i], stdout); } for (i = 0; i < num_headers; i++) { free (header[i]); header[i] = NULL; } num_headers = 0; continue; } names[0] = filename_from_header (line + 4); if (mode != mode_filter && show_status) orig_file_exists = file_exists (names[0], line + 4 + strlen (names[0])); if (getline (&line, &linelen, f) == -1) { /* Show non-diff lines if excluding, or if * in verbose mode, and if --clean isn't specified. */ if (mode == mode_filter && (pat_exclude || verbose) && !clean_comments) fputs (header[0], stdout); free (names[0]); goto eof; } linenum++; if (strncmp (line, is_context ? "--- " : "+++ ", 4)) { /* Show non-diff lines if excluding, or if * in verbose mode, and if --clean isn't specified. */ free (names[0]); goto flush_continue; } filecount++; header[num_headers++] = xstrdup (line); names[1] = filename_from_header (line + 4); if (mode != mode_filter && show_status) new_file_exists = file_exists (names[1], line + 4 + strlen (names[1])); // Decide whether this matches this pattern. p = best_name (2, names); p_stripped = stripped (p, ignore_components); match = !patlist_match(pat_exclude, p_stripped); if (match && pat_include != NULL) match = patlist_match(pat_include, p_stripped); // print if it matches. if (match && !show_status && mode == mode_list) display_filename (start_linenum, status, p, patchname); if (is_context) do_diff = do_context; else do_diff = do_unified; result = do_diff (f, header, num_headers, match, &line, &linelen, &linenum, start_linenum, status, p, patchname, &orig_file_exists, &new_file_exists); // print if it matches. if (match && show_status && mode == mode_list) { if (!orig_file_exists) status = '+'; else if (!new_file_exists) status = '-'; display_filename (start_linenum, status, p, patchname); } switch (result) { case EOF: free (names[0]); free (names[1]); goto eof; case 1: goto next_diff; } next_diff: for (i = 0; i < 2; i++) free (names[i]); for (i = 0; i < num_headers; i++) { free (header[i]); header[i] = NULL; } num_headers = 0; } eof: for (i = 0; i < num_headers; i++) if (header[i]) free (header[i]); if (line) free (line); return 0; }
static int output_header_line (const char *line) { char *fn; if (strncmp (line, "diff", 4) == 0 && isspace (line[4])) { size_t args = 0; const char *end = line + 5, *begin = end, *ws = end; printf ("%.5s", line); while (*end != 0) { if (isspace (*begin)) begin = end; if (isspace (*end)) { if (*begin == '-') { if (isspace (begin[1])) ++args; printf ("%.*s", (int)(end - ws), ws); } else { printf ("%.*s", (int)(begin - ws), ws); if (args == 0 && old_prefix_to_add) fputs (old_prefix_to_add, stdout); if (args == 1 && new_prefix_to_add) fputs (new_prefix_to_add, stdout); ++args; fn = xstrndup (begin, end - begin); fputs (stripped (fn, strip_components), stdout); free (fn); } ws = begin = end; } ++end; } printf ("%.*s", (int)(end - ws), ws); } else if (strncmp (line, "---", 3) == 0 || strncmp (line, "+++", 3) == 0) { int h = strcspn (line + 4, "\t\n"); fwrite (line, 1, 4, stdout); if (prefix_to_add) fputs (prefix_to_add, stdout); else { if (old_prefix_to_add && strncmp (line, "---", 3) == 0) fputs (old_prefix_to_add, stdout); if (new_prefix_to_add && strncmp (line, "+++", 3) == 0) fputs (new_prefix_to_add, stdout); } fn = xstrndup (line + 4, h); fputs (stripped (fn, strip_components), stdout); if (removing_timestamp) putchar ('\n'); else fputs (line + 4 + h, stdout); free (fn); } else fputs (line, stdout); return 0; }
void SkCommandLineFlags::Parse(int argc, char** argv) { // Only allow calling this function once. static bool gOnce; if (gOnce) { SkDebugf("Parse should only be called once at the beginning of main!\n"); SkASSERT(false); return; } gOnce = true; bool helpPrinted = false; // Loop over argv, starting with 1, since the first is just the name of the program. for (int i = 1; i < argc; i++) { if (0 == strcmp("-h", argv[i]) || 0 == strcmp("--help", argv[i])) { // Print help message. SkTDArray<const char*> helpFlags; for (int j = i + 1; j < argc; j++) { if (SkStrStartsWith(argv[j], '-')) { break; } helpFlags.append(1, &argv[j]); } if (0 == helpFlags.count()) { // Only print general help message if help for specific flags is not requested. SkDebugf("%s\n%s\n", argv[0], gUsage.c_str()); } SkDebugf("Flags:\n"); SkFlagInfo* flag = SkCommandLineFlags::gHead; while (flag != NULL) { // If no flags followed --help, print them all bool printFlag = 0 == helpFlags.count(); if (!printFlag) { for (int k = 0; k < helpFlags.count(); k++) { if (flag->name().equals(helpFlags[k]) || flag->shortName().equals(helpFlags[k])) { printFlag = true; helpFlags.remove(k); break; } } } if (printFlag) { print_help_for_flag(flag); } flag = flag->next(); } if (helpFlags.count() > 0) { SkDebugf("Requested help for unrecognized flags:\n"); for (int k = 0; k < helpFlags.count(); k++) { SkDebugf("\t--%s\n", helpFlags[k]); } } helpPrinted = true; } if (!helpPrinted) { bool flagMatched = false; SkFlagInfo* flag = gHead; while (flag != NULL) { if (flag->match(argv[i])) { flagMatched = true; switch (flag->getFlagType()) { case SkFlagInfo::kBool_FlagType: // Can be handled by match, above, but can also be set by the next // string. if (i+1 < argc && !SkStrStartsWith(argv[i+1], '-')) { i++; bool value; if (parse_bool_arg(argv[i], &value)) { flag->setBool(value); } } break; case SkFlagInfo::kString_FlagType: flag->resetStrings(); // Add all arguments until another flag is reached. while (i+1 < argc && !SkStrStartsWith(argv[i+1], '-')) { i++; flag->append(argv[i]); } break; case SkFlagInfo::kInt_FlagType: i++; flag->setInt(atoi(argv[i])); break; case SkFlagInfo::kDouble_FlagType: i++; flag->setDouble(atof(argv[i])); break; default: SkDEBUGFAIL("Invalid flag type"); } break; } flag = flag->next(); } if (!flagMatched) { SkString stripped(argv[i]); while (stripped.startsWith('-')) { stripped.remove(0, 1); } if (!FLAGS_undefok.contains(stripped.c_str())) { SkDebugf("Got unknown flag \"%s\". Exiting.\n", argv[i]); exit(-1); } } } } // Since all of the flags have been set, release the memory used by each // flag. FLAGS_x can still be used after this. SkFlagInfo* flag = gHead; gHead = NULL; while (flag != NULL) { SkFlagInfo* next = flag->next(); SkDELETE(flag); flag = next; } if (helpPrinted) { exit(0); } }