text
large_stringlengths 384
2.05k
| rank_avg
float64 1
4.19k
⌀ | rank_max
float64 1
8.21k
⌀ | rank_min
float64 1
5.03k
⌀ | rank_median
float64 1
4.21k
⌀ | rank_by_avgsim
float64 1
4.19k
⌀ | avgsim_to_github
float32 0.77
0.85
⌀ | dataset
large_stringclasses 1
value |
|---|---|---|---|---|---|---|---|
];
asm volatile (
"vld1.8 {d0, d1}, [%[perm], :128]\n"
"1:\n"
"sub %[x], %[x], #16\n"
"sub %[y], %[y], #16\n"
"sub %[position], %[position], #8\n"
"vld1.8 {d4, d5}, [%[pcm]]!\n"
"vuzp.16 d4, d5\n"
"vld1.8 {d20, d21}, [%[pcm]]!\n"
"vuzp.16 d20, d21\n"
"vswp d5, d20\n"
"vtbl.8 d16, {d4, d5}, d0\n"
"vtbl.8 d17, {d4, d5}, d1\n"
"vtbl.8 d18, {d20, d21}, d0\n"
"vtbl.8 d19, {d20, d21}, d1\n"
"vst1.16 {d16, d17}, [%[x], :128]\n"
"vst1.16 {d18, d19}, [%[y], :128]\n"
"subs %[nsamples], %[nsamples], #8\n"
"bgt 1b\n"
:
[x] "+r" (x),
[y] "+r" (y),
[pcm] "+r" (pcm),
[nsamples] "+r" (nsamples),
[position] "+r" (position)
:
[perm] "r" (big_endian ? perm_be : perm_le)
: "cc", "memory", "d0", "d1", "d2", "d3", "d4",
"d5", "d6", "d7", "d16", "d17", "d18", "d19",
"d20", "d21", "d22", "d23");
} else if (nchannels > 1) {
/* proper 'pcm' alignment */
int16_t *x = &X[0][position];
int16_t *y = &X[1][position];
asm volatile (
"vld1.8 {d0, d1}, [%[perm], :128]\n"
"1:\n"
"sub %[x], %[x], #16\n"
"sub %[y], %[y], #16\n"
"sub %[position], %[position], #8\n"
"vld2.16 {d4, d5}, [%[pcm]]!\n"
"vld2.16 {d20, d21}, [%[pcm]]!\n"
"vswp d5, d20\n"
"vtbl.8 d16, {d4, d5}, d0\n"
"vtbl.8 d17, {d4, d5}, d1\n"
"vtbl.8 d18, {d20, d21}, d0\n"
"vtbl.8 d19, {d20, d21}, d1\n"
"vst1.16 {d16, d17}, [%[x], :128]\n"
"vst1.16 {d18, d19}, [%[y], :128]\n"
"subs %[nsamples], %[nsamples], #8\n"
"bgt 1b\n"
:
[x] "+r" (x),
[y] "+r" (y),
[pcm] "+r" (pcm),
[nsamples] "+r" (nsamples),
[position] "+r" (position)
:
[perm] "r" (big_endian ? perm_be : perm_le)
: "cc", "memory", "d0", "d1", "d2", "d3", "d4",
"d5", "d6", "d7", "d16", "d17", "d18", "d19",
"d20", "d21", "d22", "d23");
} else {
int16_t *x = &X[0][position];
asm volatile (
"vld1.8 {d0, d1}, [%[perm],
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
:128]\n"
"1:\n"
"sub %[x], %[x], #16\n"
"sub %[position], %[position], #8\n"
"vld1.8 {d4, d5}, [%[pcm]]!\n"
"vtbl.8 d16, {d4, d5}, d0\n"
"vtbl.8 d17, {d4, d5}, d1\n"
"vst1.16 {d16, d17}, [%[x], :128]\n"
"subs %[nsamples], %[nsamples], #8\n"
"bgt 1b\n"
:
[x] "+r" (x),
[pcm] "+r" (pcm),
[nsamples] "+r" (nsamples),
[position] "+r" (position)
:
[perm] "r" (big_endian ? perm_be : perm_le)
: "cc", "memory", "d0", "d1", "d2", "d3", "d4",
"d5", "d6", "d7", "d16", "d17", "d18", "d19");
}
return position;
}
static SBC_ALWAYS_INLINE int sbc_enc_process_input_8s_neon_internal(
int position,
const uint8_t *pcm, int16_t X[2][SBC_X_BUFFER_SIZE],
int nsamples, int nchannels, int big_endian)
{
static SBC_ALIGNED uint8_t perm_be[4][8] = {
PERM_BE(15, 7, 14, 8),
PERM_BE(13, 9, 12, 10),
PERM_BE(11, 3, 6, 0),
PERM_BE(5, 1, 4, 2)
};
static SBC_ALIGNED uint8_t perm_le[4][8] = {
PERM_LE(15, 7, 14, 8),
PERM_LE(13, 9, 12, 10),
PERM_LE(11, 3, 6, 0),
PERM_LE(5, 1, 4, 2)
};
/* handle X buffer wraparound */
if (position < nsamples) {
int16_t *dst = &X[0][SBC_X_BUFFER_SIZE - 72];
int16_t *src = &X[0][position];
asm volatile (
"vld1.16 {d0, d1, d2, d3}, [%[src], :128]!\n"
"vst1.16 {d0, d1, d2, d3}, [%[dst], :128]!\n"
"vld1.16 {d0, d1, d2, d3}, [%[src], :128]!\n"
"vst1.16 {d0, d1, d2, d3}, [%[dst], :128]!\n"
"vld1.16 {d0, d1, d2, d3}, [%[src], :128]!\n"
"vst1.16 {d0, d1, d2, d3}, [%[dst], :128]!\n"
"vld1.16 {d0, d1, d2, d3}, [%[src], :128]!\n"
"vst1.16 {d0, d1, d2, d3}, [%[dst], :128]!\n"
"vld1.16 {d0, d1}, [%[src], :128]!\n"
"vst1.16 {d0, d1}, [%[dst], :128]!\n"
:
[dst] "+r" (dst),
[src] "+r" (src)
: : "memory", "d0", "d1", "d2", "d3");
if (nchannels > 1) {
dst = &X[1][SBC_X_BUFFER_SIZE - 72];
src = &X[1][position];
asm volatile (
"vld1.16 {d0, d1, d2, d3}, [%[src], :128]!\n"
"vst1.16 {d0, d1, d2, d3}, [%[dst], :128]!\n"
"vld1.16 {d0, d1,
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
d2, d3}, [%[src], :128]!\n"
"vst1.16 {d0, d1, d2, d3}, [%[dst], :128]!\n"
"vld1.16 {d0, d1, d2, d3}, [%[src], :128]!\n"
"vst1.16 {d0, d1, d2, d3}, [%[dst], :128]!\n"
"vld1.16 {d0, d1, d2, d3}, [%[src], :128]!\n"
"vst1.16 {d0, d1, d2, d3}, [%[dst], :128]!\n"
"vld1.16 {d0, d1}, [%[src], :128]!\n"
"vst1.16 {d0, d1}, [%[dst], :128]!\n"
:
[dst] "+r" (dst),
[src] "+r" (src)
: : "memory", "d0", "d1", "d2", "d3");
}
position = SBC_X_BUFFER_SIZE - 72;
}
if ((nchannels > 1) && ((uintptr_t)pcm & 1)) {
/* poor 'pcm' alignment */
int16_t *x = &X[0][position];
int16_t *y = &X[1][position];
asm volatile (
"vld1.8 {d0, d1, d2, d3}, [%[perm], :128]\n"
"1:\n"
"sub %[x], %[x], #32\n"
"sub %[y], %[y], #32\n"
"sub %[position], %[position], #16\n"
"vld1.8 {d4, d5, d6, d7}, [%[pcm]]!\n"
"vuzp.16 q2, q3\n"
"vld1.8 {d20, d21, d22, d23}, [%[pcm]]!\n"
"vuzp.16 q10, q11\n"
"vswp q3, q10\n"
"vtbl.8 d16, {d4, d5, d6, d7}, d0\n"
"vtbl.8 d17, {d4, d5, d6, d7}, d1\n"
"vtbl.8 d18, {d4, d5, d6, d7}, d2\n"
"vtbl.8 d19, {d4, d5, d6, d7}, d3\n"
"vst1.16 {d16, d17, d18, d19}, [%[x], :128]\n"
"vtbl.8 d16, {d20, d21, d22, d23}, d0\n"
"vtbl.8 d17, {d20, d21, d22, d23}, d1\n"
"vtbl.8 d18, {d20, d21, d22, d23}, d2\n"
"vtbl.8 d19, {d20, d21, d22, d23}, d3\n"
"vst1.16 {d16, d17, d18, d19}, [%[y], :128]\n"
"subs %[nsamples], %[nsamples], #16\n"
"bgt 1b\n"
:
[x] "+r" (x),
[y] "+r" (y),
[pcm] "+r" (pcm),
[nsamples] "+r" (nsamples),
[position] "+r" (position)
:
[perm] "r" (big_endian ? perm_be : perm_le)
: "cc", "memory", "d0", "d1", "d2", "d3", "d4",
"d5", "d6", "d7", "d16", "d17", "d18", "d19",
"d20", "d21", "d22", "d23");
} else if (nchannels > 1) {
/* proper 'pcm' alignment */
int16_t *x = &X[0][position];
int16_t *y = &X[1][position];
asm volatile (
"vld1.8 {d0, d1, d2, d3}, [%[perm], :128]\n"
"1:\n"
"sub
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
%[x], %[x], #32\n"
"sub %[y], %[y], #32\n"
"sub %[position], %[position], #16\n"
"vld2.16 {d4, d5, d6, d7}, [%[pcm]]!\n"
"vld2.16 {d20, d21, d22, d23}, [%[pcm]]!\n"
"vswp q3, q10\n"
"vtbl.8 d16, {d4, d5, d6, d7}, d0\n"
"vtbl.8 d17, {d4, d5, d6, d7}, d1\n"
"vtbl.8 d18, {d4, d5, d6, d7}, d2\n"
"vtbl.8 d19, {d4, d5, d6, d7}, d3\n"
"vst1.16 {d16, d17, d18, d19}, [%[x], :128]\n"
"vtbl.8 d16, {d20, d21, d22, d23}, d0\n"
"vtbl.8 d17, {d20, d21, d22, d23}, d1\n"
"vtbl.8 d18, {d20, d21, d22, d23}, d2\n"
"vtbl.8 d19, {d20, d21, d22, d23}, d3\n"
"vst1.16 {d16, d17, d18, d19}, [%[y], :128]\n"
"subs %[nsamples], %[nsamples], #16\n"
"bgt 1b\n"
:
[x] "+r" (x),
[y] "+r" (y),
[pcm] "+r" (pcm),
[nsamples] "+r" (nsamples),
[position] "+r" (position)
:
[perm] "r" (big_endian ? perm_be : perm_le)
: "cc", "memory", "d0", "d1", "d2", "d3", "d4",
"d5", "d6", "d7", "d16", "d17", "d18", "d19",
"d20", "d21", "d22", "d23");
} else {
int16_t *x = &X[0][position];
asm volatile (
"vld1.8 {d0, d1, d2, d3}, [%[perm], :128]\n"
"1:\n"
"sub %[x], %[x], #32\n"
"sub %[position], %[position], #16\n"
"vld1.8 {d4, d5, d6, d7}, [%[pcm]]!\n"
"vtbl.8 d16, {d4, d5, d6, d7}, d0\n"
"vtbl.8 d17, {d4, d5, d6, d7}, d1\n"
"vtbl.8 d18, {d4, d5, d6, d7}, d2\n"
"vtbl.8 d19, {d4, d5, d6, d7}, d3\n"
"vst1.16 {d16, d17, d18, d19}, [%[x], :128]\n"
"subs %[nsamples], %[nsamples], #16\n"
"bgt 1b\n"
:
[x] "+r" (x),
[pcm] "+r" (pcm),
[nsamples] "+r" (nsamples),
[position] "+r" (position)
:
[perm] "r" (big_endian ? perm_be : perm_le)
: "cc", "memory", "d0", "d1", "d2", "d3", "d4",
"d5", "d6", "d7", "d16", "d17", "d18", "d19");
}
return position;
}
#undef PERM_BE
#undef PERM_LE
static int sbc_enc_process_input_4s_be_neon(int position, const uint8_t *pcm,
int16_t X[2][SBC_X_BUFFER_SIZE],
int nsamp
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
les, int nchannels)
{
return sbc_enc_process_input_4s_neon_internal(
position, pcm, X, nsamples, nchannels, 1);
}
static int sbc_enc_process_input_4s_le_neon(int position, const uint8_t *pcm,
int16_t X[2][SBC_X_BUFFER_SIZE],
int nsamples, int nchannels)
{
return sbc_enc_process_input_4s_neon_internal(
position, pcm, X, nsamples, nchannels, 0);
}
static int sbc_enc_process_input_8s_be_neon(int position, const uint8_t *pcm,
int16_t X[2][SBC_X_BUFFER_SIZE],
int nsamples, int nchannels)
{
return sbc_enc_process_input_8s_neon_internal(
position, pcm, X, nsamples, nchannels, 1);
}
static int sbc_enc_process_input_8s_le_neon(int position, const uint8_t *pcm,
int16_t X[2][SBC_X_BUFFER_SIZE],
int nsamples, int nchannels)
{
return sbc_enc_process_input_8s_neon_internal(
position, pcm, X, nsamples, nchannels, 0);
}
void sbc_init_primitives_neon(struct sbc_encoder_state *state)
{
state->sbc_analyze_4b_4s = sbc_analyze_4b_4s_neon;
state->sbc_analyze_4b_8s = sbc_analyze_4b_8s_neon;
state->sbc_calc_scalefactors = sbc_calc_scalefactors_neon;
state->sbc_calc_scalefactors_j = sbc_calc_scalefactors_j_neon;
state->sbc_enc_process_input_4s_le = sbc_enc_process_input_4s_le_neon;
state->sbc_enc_process_input_4s_be = sbc_enc_process_input_4s_be_neon;
state->sbc_enc_process_input_8s_le = sbc_enc_process_input_8s_le_neon;
state->sbc_enc_process_input_8s_be = sbc_enc_process_input_8s_be_neon;
state->implementation_info = "NEON";
}
#endif
# DESCRIPTION
# Converting a system of equations to a vector equation.
# ENDDESCRIPTION
##\{ textbook_ref_exact("Holt Linear Algebra", "2.1","12") \}
## DBsubject(Linear algebra)
## DBchapter(Systems of linear equations)
## DBsection(Vector equations)
## Institution(Saint Louis University)
## Author(Mike May)
## MLT(ConvertSysToVectEqn)
## MLTleader(1)
## Level(2)
## TitleText1('Linear Algebra')
## AuthorText1('Holt')
## EditionText1('')
## Section1('2.1')
## Problem1('12')
## KEYWORDS('linear algebra','vectors')
DOCUMENT();
loadMacros(
"PGstand
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ard.pl",
"PGchoicemacros.pl",
"PGgraphmacros.pl",
"PGmatrixmacros.pl",
"PGnumericalmacros.pl",
"PGmorematrixmacros.pl",
"MathObjects.pl",
"freemanMacros.pl",
"PGasu.pl",
"PGcourse.pl"
);
# make sure we're in the context we want
Context("Numeric");
$v11=random(1,9,1);
$v12=random(-9,9,1);
$v13=random(-9,9,1);
$v21=random(-9,9,1);
$v22=random(1,9,1);
$v23=random(-9,9,1);
if($v11*$v22==$v12*$v21){$v22=-$v22;}
$v31=random(1,9,1)*random(-1,1,2);
$v32=random(-9,9,1);
$v33=random(1,9,1);
if($v11*$v22*$v33+$v21*$v32*$v13+$v31*$v12*$v23-$v13*$v22*$v31-$v23*$v32*$v11-$v33*$v12*$v21==0){$v33=-$v33;}
$v41=random(1,9,1)*random(-1,1,2);
$v42=random(1,9,1)*random(-1,1,2);
$v43=random(1,9,1)*random(-1,1,2);
$a1=random(1,9,1);
$a2=random(1,9,1)*random(-1,1,2);
$a3=random(1,9,1)*random(-1,1,2);
$a=($v42-$a2*$v22-$a3*$v32)/$a1;
$b=($v41-$a1*$v11-$a2*$v21)/$a3;
$m[1][1]=$v11;
$m[1][2]=$v12;
$m[1][3]=$v13;
$m[2][1]=$v21;
$m[2][2]=$v22;
$m[2][3]=$v23;
$m[3][1]=$v31;
$m[3][2]=$v32;
$m[3][3]=$v33;
$m[4][1]=$v41;
$m[4][2]=$v42;
$m[4][3]=$v43;
TEXT(beginproblem());
$showPartialCorrectAnswers = 1;
BEGIN_TEXT
\{ textbook_ref_exact("Holt Linear Algebra", "2.1","12") \}
$PAR
Express the following system of linear equations as a vector equation.
$PAR
\[$v11 x_1 + $v21 x_2 + $v31 x_3 = $v41\]
$PAR
\[$v12 x_1 + $v22 x_2 + $v32 x_3 = $v42\]
$PAR
\[$v13 x_1 + $v23 x_2 + $v33 x_3 = $v43\]
$PAR
$PAR
\{ mbox(
display_matrix([[ans_rule(5)],[ans_rule(5)],[ans_rule(5)]]), '\(x_1 +\) ',
display_matrix([[ans_rule(5)],[ans_rule(5)],[ans_rule(5)]]), '\(x_2 +\)',
display_matrix([[ans_rule(5)],[ans_rule(5)],[ans_rule(5)]]), '\(x_3 =\)',
display_matrix([[ans_rule(5)],[ans_rule(5)],[ans_rule(5)]])
) \}
$PAR
END_TEXT
Context()->normalStrings;
$showPartialCorrectAnswers = 1;
foreach $i (0..3) {
foreach $j (0..2) {
ANS(num_cmp($m[$i+1][$j+1]) );
}
}
Context()->texStrings;
SOLUTION(EV3(<<'END_SOLUTION'));
$PAR
SOLUTION
$PAR
\[
\left[\begin{matrix} $v11 \cr $v12 \cr $v13 \cr \end{matrix} \right] x_1+
\left[\beg
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
in{matrix} $v21 \cr $v22 \cr $v23 \cr \end{matrix} \right] x_2+
\left[\begin{matrix} $v31 \cr $v32 \cr $v33 \cr \end{matrix} \right] x_3=
\left[\begin{matrix} $v41 \cr $v42 \cr $v43 \cr \end{matrix} \right]
\]
END_SOLUTION
Context()->normalStrings;
ENDDOCUMENT();
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using AccessibilityInsights.CommonUxComponents.Controls;
using AccessibilityInsights.SharedUx.Enums;
using Axe.Windows.Core.Bases;
using System;
using System.Windows;
using System.Windows.Automation;
using System.Windows.Automation.Peers;
using System.Windows.Automation.Provider;
using System.Windows.Controls;
using System.Windows.Input;
namespace AccessibilityInsights.SharedUx.Controls
{
/// <summary>
/// Interaction logic for InspectTabsControl.xaml
/// </summary>
public partial class InspectTabsControl : UserControl
{
/// <summary>
/// Expose event config
/// </summary>
public EventConfigTabControl CtrlEventConfig
{
get
{
return this.ctrlEventConfig;
}
}
/// <summary>
/// Expose event message
/// </summary>
public EventDetailControl CtrlEventMessage
{
get
{
return this.ctrlEventMessage;
}
}
/// <summary>
/// Action to perform when user needs to log into the server
/// </summary>
public Action SwitchToServerLogin
{
get
{
return this.ctrlTests.SwitchToServerLogin;
}
set
{
this.ctrlTests.SwitchToServerLogin = value;
}
}
/// <summary>
/// Dependency property to show how to fix tab
/// </summary>
public static readonly DependencyProperty Curr
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
entModeProperty =
DependencyProperty.Register("CurrentMode", typeof(InspectTabMode), typeof(InspectTabsControl),
new PropertyMetadata(new PropertyChangedCallback(CurrentModePropertyChanged)));
/// <summary>
/// CurrentMode Property Change event handler
/// </summary>
/// <param name="d"></param>
/// <param name="e"></param>
private static void CurrentModePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var control = d as InspectTabsControl;
if (control != null)
{
control.CurrentMode = (InspectTabMode)e.NewValue;
}
}
/// <summary>
/// flat to show whether record is changed.
/// </summary>
/// <param name="isStarted"></param>
public void IsRecordingChanged(bool isStarted)
{
if (this.CurrentMode == InspectTabMode.Events || this.CurrentMode == InspectTabMode.EventsRecording)
{
this.ctrlEventConfig.SetEditEnabled(isStarted);
if (isStarted)
{
// Switch to details tab when recording starts
this.CurrentMode = InspectTabMode.EventsRecording;
}
}
}
/// <summary>
/// Update main window view selection based on current tab selection
/// </summary>
public Action<InspectTabType> UpdateMainWinView { get; set; }
InspectTabMode _currentMode;
public InspectTabMode CurrentMode
{
get
{
return _currentMode;
}
set
{
this._currentMode = value;
tabControlInspect.Items.Clear();
tabControlInspect.Items.Add(tabDetails);
switch (_currentMode)
{
case InspectTabMode.Live:
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
DisableEventsPanel();
this.tabDetails.IsSelected = true;
break;
case InspectTabMode.TestHowToFix:
tabControlInspect.Items.Add(tabHowToFix);
DisableEventsPanel();
this.tabHowToFix.IsSelected = true;
break;
case InspectTabMode.TestProperties:
tabControlInspect.Items.Add(tabHowToFix);
DisableEventsPanel();
this.tabDetails.IsSelected = true;
break;
case InspectTabMode.Events:
tabControlInspect.Items.Add(tabEvents);
EnableEventsPanel();
this.tabEvents.IsSelected = true;
break;
case InspectTabMode.EventsRecording:
tabControlInspect.Items.Add(tabEvents);
EnableEventsPanel();
this.tabDetails.IsSelected = true;
break;
case InspectTabMode.LoadedEvents:
EnableEventsPanel();
this.tabDetails.IsSelected = true;
break;
}
}
}
public static readonly RoutedCommand PropertySettingsAcceleratorCommand = new RoutedCommand();
public static readonly RoutedCommand MoveFocusToPropertiesGridCommand = new RoutedCommand();
public static readonly RoutedCommand MoveFocusToPropertiesSearchCommand = new RoutedCommand();
public static readonly RoutedCommand MoveFocusToPatternsTreeCommand = new RoutedCommand();
public static readonly RoutedCommand MoveFocusToEventsMessagesCommand = new RoutedCommand();
/// <summary>
/// Constructor
/// </summary>
public InspectTabsControl()
{
Initi
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
alizeComponent();
InitCommandBindings();
InitAcceleratorPropertiesOnDescendants();
tabDetails.Tag = InspectTabType.Details;
tabHowToFix.Tag = InspectTabType.HowToFix;
tabEvents.Tag = InspectTabType.EventConfig;
}
void InitCommandBindings()
{
var bindings = CreateCommandBindings();
this.CommandBindings.AddRange(bindings);
}
private CommandBinding[] CreateCommandBindings()
{
return new CommandBinding[]{
new CommandBinding(PropertySettingsAcceleratorCommand, this.OnPropertySettingsAccelerator),
new CommandBinding(MoveFocusToPropertiesGridCommand, this.OnMoveFocusToPropertiesGrid),
new CommandBinding(MoveFocusToPropertiesSearchCommand, this.OnMoveFocusToPropertiesSearch),
new CommandBinding(MoveFocusToPatternsTreeCommand, this.OnMoveFocusToPatternsTree),
new CommandBinding(MoveFocusToEventsMessagesCommand, this.OnMoveFocusToEventsMessages) };
}
/// <summary>
/// This function is necessary because we need the accelerator keys to be
/// available from everywhere inside the InspectTabsControl.
/// However, the AutomationProperties for accelerator keys belong to a different class.
/// </summary>
private void InitAcceleratorPropertiesOnDescendants()
{
this.ctrlProperties.textboxSearch.SetValue(AutomationProperties.AcceleratorKeyProperty, "Alt+E");
this.ctrlProperties.lvProperties.SetValue(AutomationProperties.AcceleratorKeyProperty, "Alt+P");
this.ctrlPatterns.treePatterns.SetValue(AutomationProperties.AcceleratorKeyProperty, "Alt+A");
this.CtrlEventMessage.dgEvents.SetValue(AutomationProperties.AcceleratorKeyProperty, "Alt+V");
}
/// <summary>
/// Set element and children control elements
/// </summary>
/// <param n
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ame="el"></param>
/// <param name="enableAction"></param>
public void SetElement(A11yElement el, bool enableAction = false, Guid ecId = default(Guid))
{
if (el != null)
{
this.tbElement.Text = el.Glimpse;
this.ctrlProperties.SetElement(el);
this.ctrlPatterns.SetElement(el, enableAction);
this.ctrlTests.SetElement(el, ecId);
}
else
{
Clear();
}
}
/// <summary>
/// Clear controls
/// </summary>
public void Clear()
{
this.tbElement.Text = null;
this.ctrlProperties.Clear();
this.ctrlTests.Clear();
this.ctrlPatterns.Clear();
this.ctrlEventMessage.Clear();
}
/// <summary>
/// Label as pane
/// </summary>
/// <returns></returns>
protected override AutomationPeer OnCreateAutomationPeer()
{
return new CustomControlOverridingAutomationPeer(this, "pane");
}
/// <summary>
/// Handles checking of show all available properties
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void mniShowCoreProps_Checked(object sender, RoutedEventArgs e)
{
this.ctrlProperties.mniShowCorePropertiesChecked();
}
/// <summary>
/// Handles unchecking of show all available properties
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void mniShowCoreProps_Unchecked(object sender, RoutedEventArgs e)
{
this.ctrlProperties.mniShowCorePropertiesUnchecked();
}
/// <summary>
/// Open properties configuration dialog
/// </summary>
/// <param name="sender"></param>
/// <param n
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ame="e"></param>
private void mniIncludeAllProps_Click(object sender, RoutedEventArgs e)
{
this.ctrlProperties.mniIncludeAllPropertiesClicked();
}
/// <summary>
/// Update show selected properties check state
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void mniShowCoreProps_Loaded(object sender, RoutedEventArgs e)
{
Controls.PropertyInfoControl.mniShowCorePropertiesLoaded(sender);
}
private void OnPropertySettingsAccelerator(object sender, RoutedEventArgs e)
{
var peer = new ButtonAutomationPeer(this.btnSetting);
var invokeProvider = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
invokeProvider?.Invoke();
}
private void OnMoveFocusToPropertiesGrid(object sender, RoutedEventArgs e)
{
var traversalRequest = new TraversalRequest(FocusNavigationDirection.First);
this.ctrlProperties.lvProperties.MoveFocus(traversalRequest);
}
private void OnMoveFocusToPropertiesSearch(object sender, RoutedEventArgs e)
{
if (!this.ctrlProperties.textboxSearch.IsVisible)
{
System.Media.SystemSounds.Asterisk.Play();
return;
}
this.ctrlProperties.textboxSearch.Focus();
}
private void OnMoveFocusToPatternsTree(object sender, RoutedEventArgs e)
{
var traversalRequest = new TraversalRequest(FocusNavigationDirection.First);
this.ctrlPatterns.MoveFocus(traversalRequest);
}
private void OnMoveFocusToEventsMessages(object sender, RoutedEventArgs e)
{
if (!this.CtrlEventMessage.IsVisible)
{
System.Media.SystemSounds.Asterisk.Play();
return;
}
var traversalRequest = new Tr
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
aversalRequest(FocusNavigationDirection.First);
this.CtrlEventMessage.MoveFocus(traversalRequest);
}
/// <summary>
/// Update main window when tab selection changes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TabControl_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
// This handler can be called by selectionchanged events occuring in child controls of the tabcontrol
// We check to make sure the event source is actually the intended tab control before handling the event.
if (e.Source == tabControlInspect && e.AddedItems.Count > 0)
{
var tab = (e.AddedItems[0] as TabItem);
if (e.RemovedItems.Count > 0 && tab.Tag is InspectTabType type)
{
UpdateMainWinView?.Invoke(type);
}
}
}
private void EnableEventsPanel()
{
this.expEvents.Visibility = Visibility.Visible;
this.gsEvents.Visibility = Visibility.Visible;
this.rowEvents.MinHeight = 80;
this.rowEvents.Height = new GridLength(3, GridUnitType.Star);
}
private void DisableEventsPanel()
{
this.expEvents.Visibility = Visibility.Collapsed;
this.gsEvents.Visibility = Visibility.Collapsed;
this.rowEvents.MinHeight = 0;
this.rowEvents.Height = new GridLength(0);
}
} // class
}//namespace
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.o
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
rg/MPL/2.0/.
#ifndef EIGEN_GENERAL_PRODUCT_H
#define EIGEN_GENERAL_PRODUCT_H
namespace Eigen {
/** \class GeneralProduct
* \ingroup Core_Module
*
* \brief Expression of the product of two general matrices or vectors
*
* \param LhsNested the type used to store the left-hand side
* \param RhsNested the type used to store the right-hand side
* \param ProductMode the type of the product
*
* This class represents an expression of the product of two general matrices.
* We call a general matrix, a dense matrix with full storage. For instance,
* This excludes triangular, selfadjoint, and sparse matrices.
* It is the return type of the operator* between general matrices. Its template
* arguments are determined automatically by ProductReturnType. Therefore,
* GeneralProduct should never be used direclty. To determine the result type of a
* function which involves a matrix product, use ProductReturnType::Type.
*
* \sa ProductReturnType, MatrixBase::operator*(const MatrixBase<OtherDerived>&)
*/
template<typename Lhs, typename Rhs, int ProductType = internal::product_type<Lhs,Rhs>::value>
class GeneralProduct;
enum {
Large = 2,
Small = 3
};
namespace internal {
template<int Rows, int Cols, int Depth> struct product_type_selector;
template<int Size, int MaxSize> struct product_size_category
{
enum { is_large = MaxSize == Dynamic ||
Size >= EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD,
value = is_large ? Large
: Size == 1 ? 1
: Small
};
};
template<typename Lhs, typename Rhs> struct product_type
{
typedef typename remove_all<Lhs>::type _Lhs;
typedef typename remove_all<Rhs>::type _Rhs;
enum {
MaxRows = _Lhs::MaxRowsAtCompileTime,
Rows = _Lhs::RowsAtCompileTime,
MaxCols = _Rhs::MaxColsAtCompileTime,
Cols = _Rhs::ColsAtCompileTime,
MaxDepth = EIGEN_SIZE_MIN_PREFER_FIXED(_Lhs::MaxColsAtCompileTime,
_Rhs::MaxRowsAtCompileTime),
Depth = EIGE
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
N_SIZE_MIN_PREFER_FIXED(_Lhs::ColsAtCompileTime,
_Rhs::RowsAtCompileTime),
LargeThreshold = EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
};
// the splitting into different lines of code here, introducing the _select enums and the typedef below,
// is to work around an internal compiler error with gcc 4.1 and 4.2.
private:
enum {
rows_select = product_size_category<Rows,MaxRows>::value,
cols_select = product_size_category<Cols,MaxCols>::value,
depth_select = product_size_category<Depth,MaxDepth>::value
};
typedef product_type_selector<rows_select, cols_select, depth_select> selector;
public:
enum {
value = selector::ret
};
#ifdef EIGEN_DEBUG_PRODUCT
static void debug()
{
EIGEN_DEBUG_VAR(Rows);
EIGEN_DEBUG_VAR(Cols);
EIGEN_DEBUG_VAR(Depth);
EIGEN_DEBUG_VAR(rows_select);
EIGEN_DEBUG_VAR(cols_select);
EIGEN_DEBUG_VAR(depth_select);
EIGEN_DEBUG_VAR(value);
}
#endif
};
/* The following allows to select the kind of product at compile time
* based on the three dimensions of the product.
* This is a compile time mapping from {1,Small,Large}^3 -> {product types} */
// FIXME I'm not sure the current mapping is the ideal one.
template<int M, int N> struct product_type_selector<M,N,1> { enum { ret = OuterProduct }; };
template<int Depth> struct product_type_selector<1, 1, Depth> { enum { ret = InnerProduct }; };
template<> struct product_type_selector<1, 1, 1> { enum { ret = InnerProduct }; };
template<> struct product_type_selector<Small,1, Small> { enum { ret = CoeffBasedProductMode }; };
template<> struct product_type_selector<1, Small,Small> { enum { ret = CoeffBasedProductMode }; };
template<> struct product_type_selector<Small,Small,Small> { enum { ret = CoeffBasedProductMode }; };
template<> struct product_type_selector<Small, Small, 1> { enum { ret = LazyCoeffBasedProductMode }; };
temp
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
late<> struct product_type_selector<Small, Large, 1> { enum { ret = LazyCoeffBasedProductMode }; };
template<> struct product_type_selector<Large, Small, 1> { enum { ret = LazyCoeffBasedProductMode }; };
template<> struct product_type_selector<1, Large,Small> { enum { ret = CoeffBasedProductMode }; };
template<> struct product_type_selector<1, Large,Large> { enum { ret = GemvProduct }; };
template<> struct product_type_selector<1, Small,Large> { enum { ret = CoeffBasedProductMode }; };
template<> struct product_type_selector<Large,1, Small> { enum { ret = CoeffBasedProductMode }; };
template<> struct product_type_selector<Large,1, Large> { enum { ret = GemvProduct }; };
template<> struct product_type_selector<Small,1, Large> { enum { ret = CoeffBasedProductMode }; };
template<> struct product_type_selector<Small,Small,Large> { enum { ret = GemmProduct }; };
template<> struct product_type_selector<Large,Small,Large> { enum { ret = GemmProduct }; };
template<> struct product_type_selector<Small,Large,Large> { enum { ret = GemmProduct }; };
template<> struct product_type_selector<Large,Large,Large> { enum { ret = GemmProduct }; };
template<> struct product_type_selector<Large,Small,Small> { enum { ret = GemmProduct }; };
template<> struct product_type_selector<Small,Large,Small> { enum { ret = GemmProduct }; };
template<> struct product_type_selector<Large,Large,Small> { enum { ret = GemmProduct }; };
} // end namespace internal
/** \class ProductReturnType
* \ingroup Core_Module
*
* \brief Helper class to get the correct and optimized returned type of operator*
*
* \param Lhs the type of the left-hand side
* \param Rhs the type of the right-hand side
* \param ProductMode the type of the product (determined automatically by internal::product_mode)
*
* This class define
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
s the typename Type representing the optimized product expression
* between two matrix expressions. In practice, using ProductReturnType<Lhs,Rhs>::Type
* is the recommended way to define the result type of a function returning an expression
* which involve a matrix product. The class Product should never be
* used directly.
*
* \sa class Product, MatrixBase::operator*(const MatrixBase<OtherDerived>&)
*/
template<typename Lhs, typename Rhs, int ProductType>
struct ProductReturnType
{
// TODO use the nested type to reduce instanciations ????
// typedef typename internal::nested<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
// typedef typename internal::nested<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
typedef GeneralProduct<Lhs/*Nested*/, Rhs/*Nested*/, ProductType> Type;
};
template<typename Lhs, typename Rhs>
struct ProductReturnType<Lhs,Rhs,CoeffBasedProductMode>
{
typedef typename internal::nested<Lhs, Rhs::ColsAtCompileTime, typename internal::plain_matrix_type<Lhs>::type >::type LhsNested;
typedef typename internal::nested<Rhs, Lhs::RowsAtCompileTime, typename internal::plain_matrix_type<Rhs>::type >::type RhsNested;
typedef CoeffBasedProduct<LhsNested, RhsNested, EvalBeforeAssigningBit | EvalBeforeNestingBit> Type;
};
template<typename Lhs, typename Rhs>
struct ProductReturnType<Lhs,Rhs,LazyCoeffBasedProductMode>
{
typedef typename internal::nested<Lhs, Rhs::ColsAtCompileTime, typename internal::plain_matrix_type<Lhs>::type >::type LhsNested;
typedef typename internal::nested<Rhs, Lhs::RowsAtCompileTime, typename internal::plain_matrix_type<Rhs>::type >::type RhsNested;
typedef CoeffBasedProduct<LhsNested, RhsNested, NestByRefBit> Type;
};
// this is a workaround for sun CC
template<typename Lhs, typename Rhs>
struct LazyProductReturnType : public ProductReturnType<Lhs,Rhs,LazyCoeffBasedProductMode>
{};
/***********************************************************************
* Implementation of Inner Vector Vector Product
**********************************************
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
*************************/
// FIXME : maybe the "inner product" could return a Scalar
// instead of a 1x1 matrix ??
// Pro: more natural for the user
// Cons: this could be a problem if in a meta unrolled algorithm a matrix-matrix
// product ends up to a row-vector times col-vector product... To tackle this use
// case, we could have a specialization for Block<MatrixType,1,1> with: operator=(Scalar x);
namespace internal {
template<typename Lhs, typename Rhs>
struct traits<GeneralProduct<Lhs,Rhs,InnerProduct> >
: traits<Matrix<typename scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1> >
{};
}
template<typename Lhs, typename Rhs>
class GeneralProduct<Lhs, Rhs, InnerProduct>
: internal::no_assignment_operator,
public Matrix<typename internal::scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1>
{
typedef Matrix<typename internal::scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1> Base;
public:
GeneralProduct(const Lhs& lhs, const Rhs& rhs)
{
EIGEN_STATIC_ASSERT((internal::is_same<typename Lhs::RealScalar, typename Rhs::RealScalar>::value),
YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
Base::coeffRef(0,0) = (lhs.transpose().cwiseProduct(rhs)).sum();
}
/** Convertion to scalar */
operator const typename Base::Scalar() const {
return Base::coeff(0,0);
}
};
/***********************************************************************
* Implementation of Outer Vector Vector Product
***********************************************************************/
namespace internal {
// Column major
template<typename ProductType, typename Dest, typename Func>
EIGEN_DONT_INLINE void outer_product_selector_run(const ProductType& prod, Dest& dest, const Func& func, const false_type&)
{
typedef typename Dest::Index Index;
// FIXME make sure lhs is sequentially stored
// FIXME not very good if rhs is
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
real and lhs complex while alpha is real too
const Index cols = dest.cols();
for (Index j=0; j<cols; ++j)
func(dest.col(j), prod.rhs().coeff(j) * prod.lhs());
}
// Row major
template<typename ProductType, typename Dest, typename Func>
EIGEN_DONT_INLINE void outer_product_selector_run(const ProductType& prod, Dest& dest, const Func& func, const true_type&) {
typedef typename Dest::Index Index;
// FIXME make sure rhs is sequentially stored
// FIXME not very good if lhs is real and rhs complex while alpha is real too
const Index rows = dest.rows();
for (Index i=0; i<rows; ++i)
func(dest.row(i), prod.lhs().coeff(i) * prod.rhs());
}
template<typename Lhs, typename Rhs>
struct traits<GeneralProduct<Lhs,Rhs,OuterProduct> >
: traits<ProductBase<GeneralProduct<Lhs,Rhs,OuterProduct>, Lhs, Rhs> >
{};
}
template<typename Lhs, typename Rhs>
class GeneralProduct<Lhs, Rhs, OuterProduct>
: public ProductBase<GeneralProduct<Lhs,Rhs,OuterProduct>, Lhs, Rhs>
{
template<typename T> struct IsRowMajor : internal::conditional<(int(T::Flags)&RowMajorBit), internal::true_type, internal::false_type>::type {};
public:
EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct)
GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs)
{
EIGEN_STATIC_ASSERT((internal::is_same<typename Lhs::RealScalar, typename Rhs::RealScalar>::value),
YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
}
struct set { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() = src; } };
struct add { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += src; } };
struct sub { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() -= src; } };
struct adds {
Scalar m_scale;
adds(const Scalar& s) : m_scale(s) {}
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const {
dst.const_cast_derived() += m_scale * src;
}
};
template<typename Dest>
inline void evalTo(Dest& dest) const {
internal::outer_product_selector_run(*this, dest, set(), IsRowMajor<Dest>());
}
template<typename Dest>
inline void addTo(Dest& dest) const {
internal::outer_product_selector_run(*this, dest, add(), IsRowMajor<Dest>());
}
template<typename Dest>
inline void subTo(Dest& dest) const {
internal::outer_product_selector_run(*this, dest, sub(), IsRowMajor<Dest>());
}
template<typename Dest> void scaleAndAddTo(Dest& dest, const Scalar& alpha) const
{
internal::outer_product_selector_run(*this, dest, adds(alpha), IsRowMajor<Dest>());
}
};
/***********************************************************************
* Implementation of General Matrix Vector Product
***********************************************************************/
/* According to the shape/flags of the matrix we have to distinghish 3 different cases:
* 1 - the matrix is col-major, BLAS compatible and M is large => call fast BLAS-like colmajor routine
* 2 - the matrix is row-major, BLAS compatible and N is large => call fast BLAS-like rowmajor routine
* 3 - all other cases are handled using a simple loop along the outer-storage direction.
* Therefore we need a lower level meta selector.
* Furthermore, if the matrix is the rhs, then the product has to be transposed.
*/
namespace internal {
template<typename Lhs, typename Rhs>
struct traits<GeneralProduct<Lhs,Rhs,GemvProduct> >
: traits<ProductBase<GeneralProduct<Lhs,Rhs,GemvProduct>, Lhs, Rhs> >
{};
template<int Side, int StorageOrder, bool BlasCompatible>
struct gemv_selector;
} // end namespace internal
template<typename Lhs, typename Rhs>
class GeneralProduct<Lhs, Rhs, GemvProduct>
: public ProductBase<GeneralProduct<Lhs,Rhs,GemvProduct>, Lhs, Rhs>
{
public:
EIGEN_PROD
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
UCT_PUBLIC_INTERFACE(GeneralProduct)
typedef typename Lhs::Scalar LhsScalar;
typedef typename Rhs::Scalar RhsScalar;
GeneralProduct(const Lhs& a_lhs, const Rhs& a_rhs) : Base(a_lhs,a_rhs)
{
// EIGEN_STATIC_ASSERT((internal::is_same<typename Lhs::Scalar, typename Rhs::Scalar>::value),
// YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
}
enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight };
typedef typename internal::conditional<int(Side)==OnTheRight,_LhsNested,_RhsNested>::type MatrixType;
template<typename Dest> void scaleAndAddTo(Dest& dst, const Scalar& alpha) const
{
eigen_assert(m_lhs.rows() == dst.rows() && m_rhs.cols() == dst.cols());
internal::gemv_selector<Side,(int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)>::run(*this, dst, alpha);
}
};
namespace internal {
// The vector is on the left => transposition
template<int StorageOrder, bool BlasCompatible>
struct gemv_selector<OnTheLeft,StorageOrder,BlasCompatible>
{
template<typename ProductType, typename Dest>
static void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha)
{
Transpose<Dest> destT(dest);
enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor };
gemv_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
::run(GeneralProduct<Transpose<const typename ProductType::_RhsNested>,Transpose<const typename ProductType::_LhsNested>, GemvProduct>
(prod.rhs().transpose(), prod.lhs().transpose()), destT, alpha);
}
};
template<typename Scalar,int Size,int MaxSize,bool Cond> struct gemv_static_vector_if;
template<typename Scalar,int Size,int MaxSize>
struct gemv_static_vector_if<Scalar,Size,MaxSize,false>
{
EIGEN_STRONG_INLINE Scalar* data() { eigen_internal_assert(false && "should never be called"); return 0; }
};
templa
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
te<typename Scalar,int Size>
struct gemv_static_vector_if<Scalar,Size,Dynamic,true>
{
EIGEN_STRONG_INLINE Scalar* data() { return 0; }
};
template<typename Scalar,int Size,int MaxSize>
struct gemv_static_vector_if<Scalar,Size,MaxSize,true>
{
#if EIGEN_ALIGN_STATICALLY
internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize),0> m_data;
EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
#else
// Some architectures cannot align on the stack,
// => let's manually enforce alignment by allocating more data and return the address of the first aligned element.
enum {
ForceAlignment = internal::packet_traits<Scalar>::Vectorizable,
PacketSize = internal::packet_traits<Scalar>::size
};
internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize)+(ForceAlignment?PacketSize:0),0> m_data;
EIGEN_STRONG_INLINE Scalar* data() {
return ForceAlignment
? reinterpret_cast<Scalar*>((reinterpret_cast<size_t>(m_data.array) & ~(size_t(15))) + 16)
: m_data.array;
}
#endif
};
template<> struct gemv_selector<OnTheRight,ColMajor,true>
{
template<typename ProductType, typename Dest>
static inline void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha)
{
typedef typename ProductType::Index Index;
typedef typename ProductType::LhsScalar LhsScalar;
typedef typename ProductType::RhsScalar RhsScalar;
typedef typename ProductType::Scalar ResScalar;
typedef typename ProductType::RealScalar RealScalar;
typedef typename ProductType::ActualLhsType ActualLhsType;
typedef typename ProductType::ActualRhsType ActualRhsType;
typedef typename ProductType::LhsBlasTraits LhsBlasTraits;
typedef typename ProductType::RhsBlasTraits RhsBlasTraits;
typedef Map<Matrix<ResScalar,Dynamic,1>, Aligned> MappedDest;
ActualLhsType actualLhs = LhsBlasTraits::extract(prod.lhs());
ActualRhsType actualRhs = RhsBlasTraits::extract(prod.rhs());
ResScalar actualAlpha = alpha *
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
LhsBlasTraits::extractScalarFactor(prod.lhs())
* RhsBlasTraits::extractScalarFactor(prod.rhs());
enum {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime==1,
ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex),
MightCannotUseDest = (Dest::InnerStrideAtCompileTime!=1) || ComplexByReal
};
gemv_static_vector_if<ResScalar,Dest::SizeAtCompileTime,Dest::MaxSizeAtCompileTime,MightCannotUseDest> static_dest;
bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha);
ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
evalToDest ? dest.data() : static_dest.data());
if(!evalToDest)
{
#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
int size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
#endif
if(!alphaIsCompatible)
{
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
}
else
MappedDest(actualDestPtr, dest.size()) = dest;
}
general_matrix_vector_product
<Index,LhsScalar,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsBlasTraits::NeedToConjugate>::run(
actualLhs.rows(), actualLhs.cols(),
actualLhs.data(), actualLhs.outerStride(),
actualRhs.data(), actualRhs.innerStride(),
actualDestPtr, 1,
compatibleAlpha);
if (!evalToDest)
{
if(!alphaIsCompatible)
dest += actualAlpha * MappedDest(actualDestPtr, dest.size());
else
dest = MappedDest(actualDestPtr, dest.size());
}
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
}
};
template<> struct gemv_selector<OnTheRight,RowMajor,true>
{
template<typename ProductType, typename Dest>
static void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha)
{
typedef typename ProductType::LhsScalar LhsScalar;
typedef typename ProductType::RhsScalar RhsScalar;
typedef typename ProductType::Scalar ResScalar;
typedef typename ProductType::Index Index;
typedef typename ProductType::ActualLhsType ActualLhsType;
typedef typename ProductType::ActualRhsType ActualRhsType;
typedef typename ProductType::_ActualRhsType _ActualRhsType;
typedef typename ProductType::LhsBlasTraits LhsBlasTraits;
typedef typename ProductType::RhsBlasTraits RhsBlasTraits;
typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(prod.lhs());
typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(prod.rhs());
ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs())
* RhsBlasTraits::extractScalarFactor(prod.rhs());
enum {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
DirectlyUseRhs = _ActualRhsType::InnerStrideAtCompileTime==1
};
gemv_static_vector_if<RhsScalar,_ActualRhsType::SizeAtCompileTime,_ActualRhsType::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
if(!DirectlyUseRhs)
{
#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
int size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
#endif
Map<typename _ActualRhsType::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
}
general_matrix_vector_product
<Index,LhsScalar,RowMajor,LhsBlasTraits::NeedToConjugate,RhsSca
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
lar,RhsBlasTraits::NeedToConjugate>::run(
actualLhs.rows(), actualLhs.cols(),
actualLhs.data(), actualLhs.outerStride(),
actualRhsPtr, 1,
dest.data(), dest.innerStride(),
actualAlpha);
}
};
template<> struct gemv_selector<OnTheRight,ColMajor,false>
{
template<typename ProductType, typename Dest>
static void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha)
{
typedef typename Dest::Index Index;
// TODO makes sure dest is sequentially stored in memory, otherwise use a temp
const Index size = prod.rhs().rows();
for(Index k=0; k<size; ++k)
dest += (alpha*prod.rhs().coeff(k)) * prod.lhs().col(k);
}
};
template<> struct gemv_selector<OnTheRight,RowMajor,false>
{
template<typename ProductType, typename Dest>
static void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha)
{
typedef typename Dest::Index Index;
// TODO makes sure rhs is sequentially stored in memory, otherwise use a temp
const Index rows = prod.rows();
for(Index i=0; i<rows; ++i)
dest.coeffRef(i) += alpha * (prod.lhs().row(i).cwiseProduct(prod.rhs().transpose())).sum();
}
};
} // end namespace internal
/***************************************************************************
* Implementation of matrix base methods
***************************************************************************/
/** \returns the matrix product of \c *this and \a other.
*
* \note If instead of the matrix product you want the coefficient-wise product, see Cwise::operator*().
*
* \sa lazyProduct(), operator*=(const MatrixBase&), Cwise::operator*()
*/
template<typename Derived>
template<typename OtherDerived>
inline const typename ProductReturnType<Derived, OtherDerived>::Type
MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const
{
// A note regarding the function declaration: In MSVC, this function will sometimes
// not be inlined since DenseStorage is an unwindable object
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
for dynamic
// matrices and product types are holding a member to store the result.
// Thus it does not help tagging this function with EIGEN_STRONG_INLINE.
enum {
ProductIsValid = Derived::ColsAtCompileTime==Dynamic
|| OtherDerived::RowsAtCompileTime==Dynamic
|| int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
};
// note to the lost user:
// * for a dot product use: v1.dot(v2)
// * for a coeff-wise product use: v1.cwiseProduct(v2)
EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
#ifdef EIGEN_DEBUG_PRODUCT
internal::product_type<Derived,OtherDerived>::debug();
#endif
return typename ProductReturnType<Derived,OtherDerived>::Type(derived(), other.derived());
}
/** \returns an expression of the matrix product of \c *this and \a other without implicit evaluation.
*
* The returned product will behave like any other expressions: the coefficients of the product will be
* computed once at a time as requested. This might be useful in some extremely rare cases when only
* a small and no coherent fraction of the result's coefficients have to be computed.
*
* \warning This version of the matrix product can be much much slower. So use it only if you know
* what you are doing and that you measured a true speed improvement.
*
* \sa operator*(const MatrixBase&)
*/
template<typename Derived>
template<typename OtherDerived>
const typename LazyProductReturnType<Derived,OtherDerived>::Type
MatrixBase
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
<Derived>::lazyProduct(const MatrixBase<OtherDerived> &other) const
{
enum {
ProductIsValid = Derived::ColsAtCompileTime==Dynamic
|| OtherDerived::RowsAtCompileTime==Dynamic
|| int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
};
// note to the lost user:
// * for a dot product use: v1.dot(v2)
// * for a coeff-wise product use: v1.cwiseProduct(v2)
EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
return typename LazyProductReturnType<Derived,OtherDerived>::Type(derived(), other.derived());
}
} // end namespace Eigen
#endif // EIGEN_PRODUCT_H
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.facebook.buck.swift;
import com.facebook.buck.core.build.buildable.context.BuildableContext;
import com.facebook.buck.core.build.context.BuildContext;
import com.facebook.buck.core.build.execution.context.ExecutionContext;
import com.facebook.buck.
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
core.filesystems.AbsPath;
import com.facebook.buck.core.model.BuildTarget;
import com.facebook.buck.core.model.Flavor;
import com.facebook.buck.core.model.impl.BuildTargetPaths;
import com.facebook.buck.core.rulekey.AddToRuleKey;
import com.facebook.buck.core.rules.ActionGraphBuilder;
import com.facebook.buck.core.rules.BuildRule;
import com.facebook.buck.core.rules.BuildRuleResolver;
import com.facebook.buck.core.rules.attr.SupportsInputBasedRuleKey;
import com.facebook.buck.core.rules.common.BuildableSupport;
import com.facebook.buck.core.rules.impl.AbstractBuildRule;
import com.facebook.buck.core.sourcepath.ExplicitBuildTargetSourcePath;
import com.facebook.buck.core.sourcepath.SourcePath;
import com.facebook.buck.core.sourcepath.resolver.SourcePathResolverAdapter;
import com.facebook.buck.core.toolchain.tool.Tool;
import com.facebook.buck.cxx.CxxDescriptionEnhancer;
import com.facebook.buck.cxx.PreprocessorFlags;
import com.facebook.buck.cxx.toolchain.HeaderVisibility;
import com.facebook.buck.rules.coercer.FrameworkPath;
import com.facebook.buck.cxx.toolchain.LinkerMapMode;
import com.facebook.buck.cxx.toolchain.PathShortener;
import com.facebook.buck.cxx.toolchain.Preprocessor;
import com.facebook.buck.io.BuildCellRelativePath;
import com.facebook.buck.io.file.MostFiles;
import com.facebook.buck.io.filesystem.ProjectFilesystem;
import com.facebook.buck.rules.args.AddsToRuleKeyFunction;
import com.facebook.buck.rules.args.Arg;
import com.facebook.buck.rules.args.FileListableLinkerInputArg;
import com.facebook.buck.rules.args.SourcePathArg;
import com.facebook.buck.rules.args.StringArg;
import com.facebook.buck.step.Step;
import com.facebook.buck.step.StepExecutionResult;
import com.facebook.buck.step.StepExecutionResults;
import com.facebook.buck.step.fs.MkdirStep;
import com.facebook.buck.swift.toolchain.SwiftTargetTriple;
import com.facebook.buck.util.MoreIterables;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.collect.Immutabl
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
eList;
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Streams;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Optional;
import java.util.SortedSet;
/** A build rule which compiles one or more Swift sources into a Swift module. */
public class SwiftCompile extends AbstractBuildRule implements SupportsInputBasedRuleKey {
private static final String INCLUDE_FLAG = "-I";
@AddToRuleKey private final Tool swiftCompiler;
@AddToRuleKey private final String moduleName;
@AddToRuleKey(stringify = true)
private final Path outputPath;
@AddToRuleKey(stringify = true)
private final Path objectFilePath;
@AddToRuleKey(stringify = true)
private final Path modulePath;
@AddToRuleKey(stringify = true)
private final Path moduleObjectPath;
@AddToRuleKey(stringify = true)
private final ImmutableList<Path> objectPaths;
private final Optional<AbsPath> swiftFileListPath;
@AddToRuleKey private final boolean shouldEmitSwiftdocs;
@AddToRuleKey private final boolean useModulewrap;
@AddToRuleKey private final boolean compileForceCache;
@AddToRuleKey(stringify = true)
private final Path swiftdocPath;
@AddToRuleKey private final ImmutableSortedSet<SourcePath> srcs;
@AddToRuleKey private final SwiftTargetTriple swiftTarget;
@AddToRuleKey private final Optional<String> version;
@AddToRuleKey private final ImmutableList<? extends Arg> compilerFlags;
@AddToRuleKey(stringify = true)
private final Path headerPath;
@AddToRuleKey private final ImmutableSet<FrameworkPath> frameworks;
@AddToRuleKey private final AddsToRuleKeyFunction<FrameworkPath, Path> frameworkPathToSearchPath;
@AddToRuleKey(stringify = true)
private final Flavor flavor;
@AddToRuleKey private final boolean enable
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ObjcInterop;
@AddToRuleKey private final Optional<SourcePath> bridgingHeader;
@AddToRuleKey private final Preprocessor cPreprocessor;
@AddToRuleKey private final PreprocessorFlags cxxDeps;
@AddToRuleKey private final boolean importUnderlyingModule;
private BuildableSupport.DepsSupplier depsSupplier;
SwiftCompile(
SwiftBuckConfig swiftBuckConfig,
BuildTarget buildTarget,
SwiftTargetTriple swiftTarget,
ProjectFilesystem projectFilesystem,
ActionGraphBuilder graphBuilder,
Tool swiftCompiler,
ImmutableSet<FrameworkPath> frameworks,
AddsToRuleKeyFunction<FrameworkPath, Path> frameworkPathToSearchPath,
Flavor flavor,
String moduleName,
Path outputPath,
Iterable<SourcePath> srcs,
Optional<String> version,
ImmutableList<Arg> compilerFlags,
Optional<Boolean> enableObjcInterop,
Optional<SourcePath> bridgingHeader,
Preprocessor preprocessor,
PreprocessorFlags cxxDeps,
boolean importUnderlyingModule) {
super(buildTarget, projectFilesystem);
this.frameworks = frameworks;
this.frameworkPathToSearchPath = frameworkPathToSearchPath;
this.flavor = flavor;
this.swiftCompiler = swiftCompiler;
this.outputPath = outputPath;
this.importUnderlyingModule = importUnderlyingModule;
this.headerPath = outputPath.resolve(SwiftDescriptions.toSwiftHeaderName(moduleName) + ".h");
String escapedModuleName = CxxDescriptionEnhancer.normalizeModuleName(moduleName);
this.moduleName = escapedModuleName;
this.objectFilePath = outputPath.resolve(escapedModuleName + ".o");
this.modulePath = outputPath.resolve(escapedModuleName + ".swiftmodule");
this.moduleObjectPath = outputPath.resolve(escapedModuleName + ".swiftmodule.o");
this.objectPaths =
swiftBuckConfig.getUseModulewrap()
? ImmutableList.of(objectFilePath, moduleObjectPath)
: ImmutableList.of(objectFilePath);
this.swiftFileListPath =
swiftBuckConfig.getUseFileList()
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
? Optional.of(
getProjectFilesystem()
.getRootPath()
.resolve(
BuildTargetPaths.getScratchPath(
getProjectFilesystem(), getBuildTarget(), "%s__filelist.txt")))
: Optional.empty();
this.shouldEmitSwiftdocs = swiftBuckConfig.getEmitSwiftdocs();
this.useModulewrap = swiftBuckConfig.getUseModulewrap();
this.compileForceCache = swiftBuckConfig.getCompileForceCache();
this.swiftdocPath = outputPath.resolve(escapedModuleName + ".swiftdoc");
this.srcs = ImmutableSortedSet.copyOf(srcs);
this.swiftTarget = swiftTarget;
this.version = version;
this.compilerFlags =
new ImmutableList.Builder<Arg>()
.addAll(StringArg.from(swiftBuckConfig.getCompilerFlags().orElse(ImmutableSet.of())))
.addAll(compilerFlags)
.build();
this.enableObjcInterop = enableObjcInterop.orElse(true);
this.bridgingHeader = bridgingHeader;
this.cPreprocessor = preprocessor;
this.cxxDeps = cxxDeps;
this.depsSupplier = BuildableSupport.buildDepsSupplier(this, graphBuilder);
performChecks(buildTarget);
}
private void performChecks(BuildTarget buildTarget) {
Preconditions.checkArgument(
!LinkerMapMode.FLAVOR_DOMAIN.containsAnyOf(buildTarget.getFlavors().getSet()),
"SwiftCompile %s should not be created with LinkerMapMode flavor (%s)",
this,
LinkerMapMode.FLAVOR_DOMAIN);
Preconditions.checkArgument(
!buildTarget.getFlavors().contains(CxxDescriptionEnhancer.SHARED_FLAVOR));
}
private SwiftCompileStep makeCompileStep(SourcePathResolverAdapter resolver) {
ImmutableList.Builder<String> compilerCommand = ImmutableList.builder();
compilerCommand.addAll(swiftCompiler.getCommandPrefix(resolver));
compilerCommand.add("-target", swiftTarget.getTriple());
if (bridgingHeader.isPresent()) {
compilerCommand.add(
"-import-objc-header", resolver.getRelativePat
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
h(bridgingHeader.get()).toString());
}
if (importUnderlyingModule) {
compilerCommand.add("-import-underlying-module");
}
compilerCommand.addAll(
Streams.concat(frameworks.stream(), cxxDeps.getFrameworkPaths().stream())
.filter(x -> !x.isSDKROOTFrameworkPath())
.map(frameworkPathToSearchPath)
.flatMap(searchPath -> ImmutableSet.of("-F", searchPath.toString()).stream())
.iterator());
compilerCommand.addAll(
MoreIterables.zipAndConcat(Iterables.cycle("-Xcc"), getSwiftIncludeArgs(resolver)));
compilerCommand.addAll(
MoreIterables.zipAndConcat(
Iterables.cycle(INCLUDE_FLAG),
getBuildDeps().stream()
.filter(SwiftCompile.class::isInstance)
.map(BuildRule::getSourcePathToOutput)
.map(input -> resolver.getRelativePath(input).toString())
.collect(ImmutableSet.toImmutableSet())));
boolean hasMainEntry =
srcs.stream()
.map(input -> resolver.getAbsolutePath(input).getFileName().toString())
.anyMatch(SwiftDescriptions.SWIFT_MAIN_FILENAME::equalsIgnoreCase);
compilerCommand.add(
"-c",
enableObjcInterop ? "-enable-objc-interop" : "",
hasMainEntry ? "" : "-parse-as-library",
"-serialize-debugging-options",
"-module-name",
moduleName,
"-emit-module",
"-emit-module-path",
modulePath.toString(),
"-emit-objc-header-path",
headerPath.toString(),
"-o",
objectFilePath.toString());
if (shouldEmitSwiftdocs) {
compilerCommand.add("-emit-module-doc", "-emit-module-doc-path", swiftdocPath.toString());
}
version.ifPresent(
v -> {
compilerCommand.add("-swift-version", validVersionString(v));
});
compilerCommand.addAll(
Iterables.filter(Arg.stringify(compilerFlags, resolver), arg -> !arg.equals("-Xfrontend")));
if (swiftFileListPath.isPresent()) {
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
compilerCommand.add("-filelist", swiftFileListPath.get().toString());
} else {
for (SourcePath sourcePath : srcs) {
compilerCommand.add(resolver.getRelativePath(sourcePath).toString());
}
}
ProjectFilesystem projectFilesystem = getProjectFilesystem();
return new SwiftCompileStep(
projectFilesystem.getRootPath(), ImmutableMap.of(), compilerCommand.build());
}
@VisibleForTesting
static String validVersionString(String originalVersionString) {
// Swiftc officially only accepts the major version, but it respects the minor
// version if the version is 4.2.
String[] versions = originalVersionString.split("\\.");
if (versions.length > 2) {
versions = Arrays.copyOfRange(versions, 0, 2);
}
if (versions.length == 2) {
Integer majorVersion = Integer.parseInt(versions[0]);
Integer minorVersion = Integer.parseInt(versions[1]);
if (majorVersion > 4 || (majorVersion >= 4 && minorVersion >= 2)) {
return String.format("%d.%d", majorVersion, minorVersion);
} else {
return originalVersionString.length() > 1
? originalVersionString.substring(0, 1)
: originalVersionString;
}
} else {
return originalVersionString.length() > 1
? originalVersionString.substring(0, 1)
: originalVersionString;
}
}
private SwiftCompileStep makeModulewrapStep(SourcePathResolverAdapter resolver) {
ImmutableList.Builder<String> compilerCommand = ImmutableList.builder();
ImmutableList<String> commandPrefix = swiftCompiler.getCommandPrefix(resolver);
// The swift compiler path will be the first element of the command prefix
compilerCommand.add(commandPrefix.get(0));
compilerCommand.add("-modulewrap", modulePath.toString(), "-o", moduleObjectPath.toString());
compilerCommand.add("-target", swiftTarget.getTriple());
ProjectFilesystem projectFilesystem = getProjectFilesystem();
return new SwiftCompileStep(
projectFilesystem.getRoot
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
Path(), ImmutableMap.of(), compilerCommand.build());
}
@Override
public boolean isCacheable() {
// .swiftmodule artifacts are not cacheable because they can contain machine-specific
// headers. More specifically, all files included in a bridging header will be
// literally included in the .swiftmodule file. When the Swift compiler encounters
// `import Module`, it will include the headers from the .swiftmodule and those
// headers are referenced via an absolute path stored in the .swiftmodule. This
// means that Obj-C headers can be included multiple times if the machines which
// populated the cache and the machine which is building have placed the source
// repository at different paths (usually the case with CI and developer machines).
return !bridgingHeader.isPresent() || compileForceCache;
}
@Override
public SortedSet<BuildRule> getBuildDeps() {
return depsSupplier.get();
}
@Override
public void updateBuildRuleResolver(BuildRuleResolver ruleResolver) {
this.depsSupplier = BuildableSupport.buildDepsSupplier(this, ruleResolver);
}
@Override
public ImmutableList<Step> getBuildSteps(
BuildContext context, BuildableContext buildableContext) {
buildableContext.recordArtifact(outputPath);
Builder<Step> steps = ImmutableList.builder();
steps.add(
MkdirStep.of(
BuildCellRelativePath.fromCellRelativePath(
context.getBuildCellRootPath(), getProjectFilesystem(), outputPath)));
swiftFileListPath.map(
path -> steps.add(makeFileListStep(context.getSourcePathResolver(), path)));
steps.add(makeCompileStep(context.getSourcePathResolver()));
if (useModulewrap) {
steps.add(makeModulewrapStep(context.getSourcePathResolver()));
}
return steps.build();
}
private Step makeFileListStep(SourcePathResolverAdapter resolver, AbsPath swiftFileListPath) {
ImmutableList<String> relativePaths =
srcs.stream()
.map(sourcePath -> resolver.getRelativePath(
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
sourcePath).toString())
.collect(ImmutableList.toImmutableList());
return new Step() {
@Override
public StepExecutionResult execute(ExecutionContext context) throws IOException {
if (Files.notExists(swiftFileListPath.getParent().getPath())) {
Files.createDirectories(swiftFileListPath.getParent().getPath());
}
MostFiles.writeLinesToFile(relativePaths, swiftFileListPath);
return StepExecutionResults.SUCCESS;
}
@Override
public String getShortName() {
return "swift-filelist";
}
@Override
public String getDescription(ExecutionContext context) {
return "swift-filelist";
}
};
}
@Override
public SourcePath getSourcePathToOutput() {
return ExplicitBuildTargetSourcePath.of(getBuildTarget(), outputPath);
}
/**
* @return the arguments to add to the preprocessor command line to include the given header packs
* in preprocessor search path.
* <p>We can't use CxxHeaders.getArgs() because 1. we don't need the system include roots. 2.
* swift doesn't like spaces after the "-I" flag.
*/
@VisibleForTesting
ImmutableList<String> getSwiftIncludeArgs(SourcePathResolverAdapter resolver) {
ImmutableList.Builder<String> args = ImmutableList.builder();
// Arg list can't simply be passed in since the current implementation of toToolFlags drops the
// dependency information.
Iterable<Arg> argsFromDeps =
cxxDeps
.toToolFlags(
resolver,
PathShortener.byRelativizingToWorkingDir(getProjectFilesystem().getRootPath()),
frameworkPathToSearchPath,
cPreprocessor,
Optional.empty())
.getAllFlags();
args.addAll(Arg.stringify(argsFromDeps, resolver));
if (bridgingHeader.isPresent()) {
for (HeaderVisibility headerVisibility : HeaderVisibility.values()) {
// We should probably pass in the correct symlink trees instead of guessi
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ng.
Path headerPath =
CxxDescriptionEnhancer.getHeaderSymlinkTreePath(
getProjectFilesystem(),
getBuildTarget().withFlavors(),
headerVisibility,
flavor);
args.add(INCLUDE_FLAG.concat(headerPath.toString()));
}
}
return args.build();
}
public ImmutableList<Arg> getAstLinkArgs() {
if (!useModulewrap) {
return ImmutableList.<Arg>builder()
.addAll(StringArg.from("-Xlinker", "-add_ast_path"))
.add(SourcePathArg.of(ExplicitBuildTargetSourcePath.of(getBuildTarget(), modulePath)))
.build();
} else {
return ImmutableList.<Arg>builder().build();
}
}
ImmutableList<Arg> getFileListLinkArg() {
return FileListableLinkerInputArg.from(
objectPaths.stream()
.map(
objectPath ->
SourcePathArg.of(
ExplicitBuildTargetSourcePath.of(getBuildTarget(), objectPath)))
.collect(ImmutableList.toImmutableList()));
}
/** @return The name of the Swift module. */
public String getModuleName() {
return moduleName;
}
/** @return List of {@link SourcePath} to the output object file(s) (i.e., .o file) */
public ImmutableList<SourcePath> getObjectPaths() {
// Ensures that users of the object path can depend on this build target
return objectPaths.stream()
.map(objectPath -> ExplicitBuildTargetSourcePath.of(getBuildTarget(), objectPath))
.collect(ImmutableList.toImmutableList());
}
/** @return File name of the Objective-C Generated Interface Header. */
public String getObjCGeneratedHeaderFileName() {
return headerPath.getFileName().toString();
}
/** @return {@link SourcePath} of the Objective-C Generated Interface Header. */
public SourcePath getObjCGeneratedHeaderPath() {
return ExplicitBuildTargetSourcePath.of(getBuildTarget(), headerPath);
}
/**
* @return {@link SourcePath} to the directory containing outputs from t
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
he compilation process
* (object files, Swift module metadata, etc).
*/
public SourcePath getOutputPath() {
return ExplicitBuildTargetSourcePath.of(getBuildTarget(), outputPath);
}
/**
* @return {@link SourcePath} to the .swiftmodule output from the compilation process. A
* swiftmodule file contains the public interface for a module, and is basically a binary file
* format equivalent to header files for a C framework or library.
*
* A swiftmodule file contains serialized ASTs (and possibly SIL), it conforms to
* Swift Binary Serialization Format, more details about this binary format can be found here:
* https://github.com/apple/swift/blob/7e6d62dae4bae4eb3737a6f76c0e51534c1bcca3/docs/Serialization.rst.
*/
public SourcePath getSwiftModuleOutputPath() {
return ExplicitBuildTargetSourcePath.of(getBuildTarget(), modulePath);
}
}
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Welcome to CodeIgniter : CodeIgniter User Guide</title>
<style type='text/css' media='all'>@import url('userguide.css');</style>
<link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
<script type="text/javascript" src="nav/nav.js"></script>
<script type="text/javascript" src="nav/prototype.lite.js"></script>
<script type="text/javascript" src="nav/moo.fx.js"></script>
<script type="text/javascript" src="nav/user_guide_menu.js"></script>
<meta http-equiv='expires' content='-1' />
<meta http-equiv= 'pragma' content='no-cache' />
<meta name='robots' content='all' />
<meta name='author' content='ExpressionEngine Dev Team' />
<meta name='description' content='CodeIgniter User Guide' />
</head>
<body>
<!-- START NAVIGATION -->
<div id="nav"><div id="nav_inner"><script type="text/javascript">create_menu('null');</script></div></div>
<div id="nav2"><
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
a name="top"></a><a href="javascript:void(0);" onclick="myHeight.toggle();"><img src="images/nav_toggle_darker.jpg" width="154" height="43" border="0" title="Toggle Table of Contents" alt="Toggle Table of Contents" /></a></div>
<div id="masthead">
<table cellpadding="0" cellspacing="0" border="0" style="width:100%">
<tr>
<td><h1>CodeIgniter User Guide Version 2.1.0</h1></td>
<td id="breadcrumb_right"><a href="toc.html">Table of Contents Page</a></td>
</tr>
</table>
</div>
<!-- END NAVIGATION -->
<table cellpadding="0" cellspacing="0" border="0" style="width:100%">
<tr>
<td id="breadcrumb">
<a href="http://codeigniter.com/">CodeIgniter Home</a> › CodeIgniter User Guide
</td>
<td id="searchbox"><form method="get" action="http://www.google.com/search"><input type="hidden" name="as_sitesearch" id="as_sitesearch" value="codeigniter.com/user_guide/" />Search User Guide <input type="text" class="input" style="width:200px;" name="q" id="q" size="31" maxlength="255" value="" /> <input type="submit" class="submit" name="sa" value="Go" /></form></td>
</tr>
</table>
<br clear="all" />
<div class="center"><img src="images/ci_logo_flame.jpg" width="150" height="164" border="0" alt="CodeIgniter" /></div>
<!-- START CONTENT -->
<div id="content">
<h2>Welcome to CodeIgniter</h2>
<p>CodeIgniter is an Application Development Framework - a toolkit - for people who build web sites using PHP.
Its goal is to enable you to develop projects much faster than you could if you were writing code
from scratch, by providing a rich set of libraries for commonly needed tasks, as well as a simple interface and
logical structure to access these libraries. CodeIgniter lets you creatively focus on your project by
minimizing the amount of code needed for a given task.</p>
<h2>Who is CodeIgniter For?</h2>
<p>CodeIgniter is right for you if:</p>
<ul>
<li>You want a framework with a small footprint.</li>
<li>You need exceptional performance.</li>
<li>You need broad compatibility with standard hosting accounts
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
that run a variety of PHP versions and configurations.</li>
<li>You want a framework that requires nearly zero configuration.</li>
<li>You want a framework that does not require you to use the command line.</li>
<li>You want a framework that does not require you to adhere to restrictive coding rules.</li>
<li>You do not want to be forced to learn a templating language (although a template parser is optionally available if you desire one).</li>
<li>You eschew complexity, favoring simple solutions.</li>
<li>You need clear, thorough documentation.</li>
</ul>
</div>
<!-- END CONTENT -->
<div id="footer">
<p><a href="#top">Top of Page</a></p>
<p><a href="http://codeigniter.com">CodeIgniter</a> · Copyright © 2006 - 2011 · <a href="http://ellislab.com/">EllisLab, Inc.</a></p>
</div>
</body>
</html>
/*
* (C) Copyright 2008 Stefan Roese <sr@denx.de>, DENX Software Engineering
*
* Copyright (C) 2006 Micronas GmbH
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef _REG_EBI_PREMIUM_H_
#define _REG_EBI_PREMIUM_H_
#define EBI_BASE 0x00000000
/* Relative offsets of the register adresses */
#define EBI_CPU_IO_ACCS_OFFS 0x00000000
#define EBI_CPU_IO_ACCS(base) ((base) + EBI_CPU_IO_ACCS_OFFS)
#define EBI_IO_ACCS_DATA_OFFS 0x00000004
#define EBI_IO_ACCS_DATA(base) ((base) + EBI_IO_ACCS_DATA_OFFS)
#define EBI_CPU_IO_ACCS2_OFFS 0x00000008
#define EBI_CPU_IO_ACCS2(base) ((base) + EBI_CPU_IO_ACCS2_OFFS)
#define EBI_IO_ACCS2_DATA_OFFS 0x0000000C
#define EBI_IO_ACCS2_DATA(base) ((base) + EBI_IO_ACCS2_DATA_OFFS)
#define EBI_CTRL_OFFS 0x00000010
#define EBI_CTRL(base) ((base) + EBI_CTRL_OFFS)
#define EBI_IRQ_MASK_OFFS 0x00000018
#define EBI_IRQ_MASK(base) ((base) + EBI_IRQ_MASK_OFFS)
#define EBI_IRQ_MASK2_OFFS 0x0000001C
#define EBI_IRQ_MASK2(base) ((base) + EBI_IRQ_MASK2_OFFS)
#define EBI_TAG1_SYS_ID_OFFS 0x00000030
#define EBI_TAG1_SYS_ID(base) ((base) + EBI_TAG1_SYS_ID_OFFS)
#define EBI_TAG2_SYS_ID_OFFS 0x00000040
#define EBI_TAG2_SYS_ID(base) ((base) + E
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
BI_TAG2_SYS_ID_OFFS)
#define EBI_TAG3_SYS_ID_OFFS 0x00000050
#define EBI_TAG3_SYS_ID(base) ((base) + EBI_TAG3_SYS_ID_OFFS)
#define EBI_TAG4_SYS_ID_OFFS 0x00000060
#define EBI_TAG4_SYS_ID(base) ((base) + EBI_TAG4_SYS_ID_OFFS)
#define EBI_GEN_DMA_CTRL_OFFS 0x00000070
#define EBI_GEN_DMA_CTRL(base) ((base) + EBI_GEN_DMA_CTRL_OFFS)
#define EBI_STATUS_OFFS 0x00000080
#define EBI_STATUS(base) ((base) + EBI_STATUS_OFFS)
#define EBI_STATUS_DMA_CNT_OFFS 0x00000084
#define EBI_STATUS_DMA_CNT(base) ((base) + EBI_STATUS_DMA_CNT_OFFS)
#define EBI_SIG_LEVEL_OFFS 0x00000088
#define EBI_SIG_LEVEL(base) ((base) + EBI_SIG_LEVEL_OFFS)
#define EBI_CTRL_SIG_ACTLV_OFFS 0x0000008C
#define EBI_CTRL_SIG_ACTLV(base) ((base) + EBI_CTRL_SIG_ACTLV_OFFS)
#define EBI_CRC_GEN_OFFS 0x00000090
#define EBI_CRC_GEN(base) ((base) + EBI_CRC_GEN_OFFS)
#define EBI_EXT_ADDR_OFFS 0x000000A0
#define EBI_EXT_ADDR(base) ((base) + EBI_EXT_ADDR_OFFS)
#define EBI_IRQ_STATUS_OFFS 0x000000B0
#define EBI_IRQ_STATUS(base) ((base) + EBI_IRQ_STATUS_OFFS)
#define EBI_IRQ_STATUS2_OFFS 0x000000B4
#define EBI_IRQ_STATUS2(base) ((base) + EBI_IRQ_STATUS2_OFFS)
#define EBI_EXT_MASTER_SRAM_HIGH_OFFS 0x000000C0
#define EBI_EXT_MASTER_SRAM_HIGH(base) ((base) + EBI_EXT_MASTER_SRAM_HIGH_OFFS)
#define EBI_EXT_MASTER_SRAM_LOW_OFFS 0x000000C4
#define EBI_EXT_MASTER_SRAM_LOW(base) ((base) + EBI_EXT_MASTER_SRAM_LOW_OFFS)
#define EBI_ECC0_OFFS 0x000000D0
#define EBI_ECC0(base) ((base) + EBI_ECC0_OFFS)
#define EBI_ECC1_OFFS 0x000000D4
#define EBI_ECC1(base) ((base) + EBI_ECC1_OFFS)
#define EBI_ECC2_OFFS 0x000000D8
#define EBI_ECC2(base) ((base) + EBI_ECC2_OFFS)
#define EBI_ECC3_OFFS 0x000000DC
#define EBI_ECC3(base) ((base) + EBI_ECC3_OFFS)
#define EBI_DEV1_DMA_EXT_ADDR_OFFS 0x00000100
#define EBI_DEV1_DMA_EXT_ADDR(base) ((base) + EBI_DEV1_DMA_EXT_ADDR_OFFS)
#define EBI_DEV1_EXT_ACC_OFFS 0x00000104
#define EBI_DEV1_EXT_ACC(base) ((base) + EBI_DEV1_EXT_ACC_OFFS)
#define EBI_DEV1_CONFIG1_OFFS 0x00000108
#define EBI_DEV1_CONFIG1(base) ((base) + EB
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
I_DEV1_CONFIG1_OFFS)
#define EBI_DEV1_CONFIG2_OFFS 0x0000010C
#define EBI_DEV1_CONFIG2(base) ((base) + EBI_DEV1_CONFIG2_OFFS)
#define EBI_DEV1_FIFO_CONFIG_OFFS 0x00000110
#define EBI_DEV1_FIFO_CONFIG(base) ((base) + EBI_DEV1_FIFO_CONFIG_OFFS)
#define EBI_DEV1_FLASH_CONF_ST_OFFS 0x00000114
#define EBI_DEV1_FLASH_CONF_ST(base) ((base) + EBI_DEV1_FLASH_CONF_ST_OFFS)
#define EBI_DEV1_DMA_CONFIG1_OFFS 0x00000118
#define EBI_DEV1_DMA_CONFIG1(base) ((base) + EBI_DEV1_DMA_CONFIG1_OFFS)
#define EBI_DEV1_DMA_CONFIG2_OFFS 0x0000011C
#define EBI_DEV1_DMA_CONFIG2(base) ((base) + EBI_DEV1_DMA_CONFIG2_OFFS)
#define EBI_DEV1_DMA_ECC_CTRL_OFFS 0x00000120
#define EBI_DEV1_DMA_ECC_CTRL(base) ((base) + EBI_DEV1_DMA_ECC_CTRL_OFFS)
#define EBI_DEV1_TIM1_RD1_OFFS 0x00000124
#define EBI_DEV1_TIM1_RD1(base) ((base) + EBI_DEV1_TIM1_RD1_OFFS)
#define EBI_DEV1_TIM1_RD2_OFFS 0x00000128
#define EBI_DEV1_TIM1_RD2(base) ((base) + EBI_DEV1_TIM1_RD2_OFFS)
#define EBI_DEV1_TIM1_WR1_OFFS 0x0000012C
#define EBI_DEV1_TIM1_WR1(base) ((base) + EBI_DEV1_TIM1_WR1_OFFS)
#define EBI_DEV1_TIM1_WR2_OFFS 0x00000130
#define EBI_DEV1_TIM1_WR2(base) ((base) + EBI_DEV1_TIM1_WR2_OFFS)
#define EBI_DEV1_TIM_EXT_OFFS 0x00000134
#define EBI_DEV1_TIM_EXT(base) ((base) + EBI_DEV1_TIM_EXT_OFFS)
#define EBI_DEV1_TIM2_CFI_RD1_OFFS 0x00000138
#define EBI_DEV1_TIM2_CFI_RD1(base) ((base) + EBI_DEV1_TIM2_CFI_RD1_OFFS)
#define EBI_DEV1_TIM2_CFI_RD2_OFFS 0x0000013C
#define EBI_DEV1_TIM2_CFI_RD2(base) ((base) + EBI_DEV1_TIM2_CFI_RD2_OFFS)
#define EBI_DEV1_TIM3_DMA1_OFFS 0x00000140
#define EBI_DEV1_TIM3_DMA1(base) ((base) + EBI_DEV1_TIM3_DMA1_OFFS)
#define EBI_DEV1_TIM3_DMA2_OFFS 0x00000144
#define EBI_DEV1_TIM3_DMA2(base) ((base) + EBI_DEV1_TIM3_DMA2_OFFS)
#define EBI_DEV1_TIM4_UDMA1_OFFS 0x00000148
#define EBI_DEV1_TIM4_UDMA1(base) ((base) + EBI_DEV1_TIM4_UDMA1_OFFS)
#define EBI_DEV1_TIM4_UDMA2_OFFS 0x0000014C
#define EBI_DEV1_TIM4_UDMA2(base) ((base) + EBI_DEV1_TIM4_UDMA2_OFFS)
#define EBI_DEV1_ACK_RM_CNT_OFFS 0x00000150
#define EBI_DEV1_ACK_RM_CNT(base) ((base) +
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
EBI_DEV1_ACK_RM_CNT_OFFS)
#define EBI_DEV2_DMA_EXT_ADDR_OFFS 0x00000200
#define EBI_DEV2_DMA_EXT_ADDR(base) ((base) + EBI_DEV2_DMA_EXT_ADDR_OFFS)
#define EBI_DEV2_EXT_ACC_OFFS 0x00000204
#define EBI_DEV2_EXT_ACC(base) ((base) + EBI_DEV2_EXT_ACC_OFFS)
#define EBI_DEV2_CONFIG1_OFFS 0x00000208
#define EBI_DEV2_CONFIG1(base) ((base) + EBI_DEV2_CONFIG1_OFFS)
#define EBI_DEV2_CONFIG2_OFFS 0x0000020C
#define EBI_DEV2_CONFIG2(base) ((base) + EBI_DEV2_CONFIG2_OFFS)
#define EBI_DEV2_FIFO_CONFIG_OFFS 0x00000210
#define EBI_DEV2_FIFO_CONFIG(base) ((base) + EBI_DEV2_FIFO_CONFIG_OFFS)
#define EBI_DEV2_FLASH_CONF_ST_OFFS 0x00000214
#define EBI_DEV2_FLASH_CONF_ST(base) ((base) + EBI_DEV2_FLASH_CONF_ST_OFFS)
#define EBI_DEV2_DMA_CONFIG1_OFFS 0x00000218
#define EBI_DEV2_DMA_CONFIG1(base) ((base) + EBI_DEV2_DMA_CONFIG1_OFFS)
#define EBI_DEV2_DMA_CONFIG2_OFFS 0x0000021C
#define EBI_DEV2_DMA_CONFIG2(base) ((base) + EBI_DEV2_DMA_CONFIG2_OFFS)
#define EBI_DEV2_DMA_ECC_CTRL_OFFS 0x00000220
#define EBI_DEV2_DMA_ECC_CTRL(base) ((base) + EBI_DEV2_DMA_ECC_CTRL_OFFS)
#define EBI_DEV2_TIM1_RD1_OFFS 0x00000224
#define EBI_DEV2_TIM1_RD1(base) ((base) + EBI_DEV2_TIM1_RD1_OFFS)
#define EBI_DEV2_TIM1_RD2_OFFS 0x00000228
#define EBI_DEV2_TIM1_RD2(base) ((base) + EBI_DEV2_TIM1_RD2_OFFS)
#define EBI_DEV2_TIM1_WR1_OFFS 0x0000022C
#define EBI_DEV2_TIM1_WR1(base) ((base) + EBI_DEV2_TIM1_WR1_OFFS)
#define EBI_DEV2_TIM1_WR2_OFFS 0x00000230
#define EBI_DEV2_TIM1_WR2(base) ((base) + EBI_DEV2_TIM1_WR2_OFFS)
#define EBI_DEV2_TIM_EXT_OFFS 0x00000234
#define EBI_DEV2_TIM_EXT(base) ((base) + EBI_DEV2_TIM_EXT_OFFS)
#define EBI_DEV2_TIM2_CFI_RD1_OFFS 0x00000238
#define EBI_DEV2_TIM2_CFI_RD1(base) ((base) + EBI_DEV2_TIM2_CFI_RD1_OFFS)
#define EBI_DEV2_TIM2_CFI_RD2_OFFS 0x0000023C
#define EBI_DEV2_TIM2_CFI_RD2(base) ((base) + EBI_DEV2_TIM2_CFI_RD2_OFFS)
#define EBI_DEV2_TIM3_DMA1_OFFS 0x00000240
#define EBI_DEV2_TIM3_DMA1(base) ((base) + EBI_DEV2_TIM3_DMA1_OFFS)
#define EBI_DEV2_TIM3_DMA2_OFFS 0x00000244
#define EBI_DEV2_TIM3_DMA2(base) ((base) +
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
EBI_DEV2_TIM3_DMA2_OFFS)
#define EBI_DEV2_TIM4_UDMA1_OFFS 0x00000248
#define EBI_DEV2_TIM4_UDMA1(base) ((base) + EBI_DEV2_TIM4_UDMA1_OFFS)
#define EBI_DEV2_TIM4_UDMA2_OFFS 0x0000024C
#define EBI_DEV2_TIM4_UDMA2(base) ((base) + EBI_DEV2_TIM4_UDMA2_OFFS)
#define EBI_DEV2_ACK_RM_CNT_OFFS 0x00000250
#define EBI_DEV2_ACK_RM_CNT(base) ((base) + EBI_DEV2_ACK_RM_CNT_OFFS)
#define EBI_DEV3_DMA_EXT_ADDR_OFFS 0x00000300
#define EBI_DEV3_DMA_EXT_ADDR(base) ((base) + EBI_DEV3_DMA_EXT_ADDR_OFFS)
#define EBI_DEV3_EXT_ACC_OFFS 0x00000304
#define EBI_DEV3_EXT_ACC(base) ((base) + EBI_DEV3_EXT_ACC_OFFS)
#define EBI_DEV3_CONFIG1_OFFS 0x00000308
#define EBI_DEV3_CONFIG1(base) ((base) + EBI_DEV3_CONFIG1_OFFS)
#define EBI_DEV3_CONFIG2_OFFS 0x0000030C
#define EBI_DEV3_CONFIG2(base) ((base) + EBI_DEV3_CONFIG2_OFFS)
#define EBI_DEV3_FIFO_CONFIG_OFFS 0x00000310
#define EBI_DEV3_FIFO_CONFIG(base) ((base) + EBI_DEV3_FIFO_CONFIG_OFFS)
#define EBI_DEV3_FLASH_CONF_ST_OFFS 0x00000314
#define EBI_DEV3_FLASH_CONF_ST(base) ((base) + EBI_DEV3_FLASH_CONF_ST_OFFS)
#define EBI_DEV3_DMA_CONFIG1_OFFS 0x00000318
#define EBI_DEV3_DMA_CONFIG1(base) ((base) + EBI_DEV3_DMA_CONFIG1_OFFS)
#define EBI_DEV3_DMA_CONFIG2_OFFS 0x0000031C
#define EBI_DEV3_DMA_CONFIG2(base) ((base) + EBI_DEV3_DMA_CONFIG2_OFFS)
#define EBI_DEV3_DMA_ECC_CTRL_OFFS 0x00000320
#define EBI_DEV3_DMA_ECC_CTRL(base) ((base) + EBI_DEV3_DMA_ECC_CTRL_OFFS)
#define EBI_DEV3_TIM1_RD1_OFFS 0x00000324
#define EBI_DEV3_TIM1_RD1(base) ((base) + EBI_DEV3_TIM1_RD1_OFFS)
#define EBI_DEV3_TIM1_RD2_OFFS 0x00000328
#define EBI_DEV3_TIM1_RD2(base) ((base) + EBI_DEV3_TIM1_RD2_OFFS)
#define EBI_DEV3_TIM1_WR1_OFFS 0x0000032C
#define EBI_DEV3_TIM1_WR1(base) ((base) + EBI_DEV3_TIM1_WR1_OFFS)
#define EBI_DEV3_TIM1_WR2_OFFS 0x00000330
#define EBI_DEV3_TIM1_WR2(base) ((base) + EBI_DEV3_TIM1_WR2_OFFS)
#define EBI_DEV3_TIM_EXT_OFFS 0x00000334
#define EBI_DEV3_TIM_EXT(base) ((base) + EBI_DEV3_TIM_EXT_OFFS)
#define EBI_DEV3_TIM2_CFI_RD1_OFFS 0x00000338
#define EBI_DEV3_TIM2_CFI_RD1(base) ((base) + EBI_DEV
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
3_TIM2_CFI_RD1_OFFS)
#define EBI_DEV3_TIM2_CFI_RD2_OFFS 0x0000033C
#define EBI_DEV3_TIM2_CFI_RD2(base) ((base) + EBI_DEV3_TIM2_CFI_RD2_OFFS)
#define EBI_DEV3_TIM3_DMA1_OFFS 0x00000340
#define EBI_DEV3_TIM3_DMA1(base) ((base) + EBI_DEV3_TIM3_DMA1_OFFS)
#define EBI_DEV3_TIM3_DMA2_OFFS 0x00000344
#define EBI_DEV3_TIM3_DMA2(base) ((base) + EBI_DEV3_TIM3_DMA2_OFFS)
#define EBI_DEV3_TIM4_UDMA1_OFFS 0x00000348
#define EBI_DEV3_TIM4_UDMA1(base) ((base) + EBI_DEV3_TIM4_UDMA1_OFFS)
#define EBI_DEV3_TIM4_UDMA2_OFFS 0x0000034C
#define EBI_DEV3_TIM4_UDMA2(base) ((base) + EBI_DEV3_TIM4_UDMA2_OFFS)
#define EBI_DEV3_ACK_RM_CNT_OFFS 0x00000350
#define EBI_DEV3_ACK_RM_CNT(base) ((base) + EBI_DEV3_ACK_RM_CNT_OFFS)
#define EBI_DEV4_DMA_EXT_ADDR_OFFS 0x00000400
#define EBI_DEV4_DMA_EXT_ADDR(base) ((base) + EBI_DEV4_DMA_EXT_ADDR_OFFS)
#define EBI_DEV4_EXT_ACC_OFFS 0x00000404
#define EBI_DEV4_EXT_ACC(base) ((base) + EBI_DEV4_EXT_ACC_OFFS)
#define EBI_DEV4_CONFIG1_OFFS 0x00000408
#define EBI_DEV4_CONFIG1(base) ((base) + EBI_DEV4_CONFIG1_OFFS)
#define EBI_DEV4_CONFIG2_OFFS 0x0000040C
#define EBI_DEV4_CONFIG2(base) ((base) + EBI_DEV4_CONFIG2_OFFS)
#define EBI_DEV4_FIFO_CONFIG_OFFS 0x00000410
#define EBI_DEV4_FIFO_CONFIG(base) ((base) + EBI_DEV4_FIFO_CONFIG_OFFS)
#define EBI_DEV4_FLASH_CONF_ST_OFFS 0x00000414
#define EBI_DEV4_FLASH_CONF_ST(base) ((base) + EBI_DEV4_FLASH_CONF_ST_OFFS)
#define EBI_DEV4_DMA_CONFIG1_OFFS 0x00000418
#define EBI_DEV4_DMA_CONFIG1(base) ((base) + EBI_DEV4_DMA_CONFIG1_OFFS)
#define EBI_DEV4_DMA_CONFIG2_OFFS 0x0000041C
#define EBI_DEV4_DMA_CONFIG2(base) ((base) + EBI_DEV4_DMA_CONFIG2_OFFS)
#define EBI_DEV4_DMA_ECC_CTRL_OFFS 0x00000420
#define EBI_DEV4_DMA_ECC_CTRL(base) ((base) + EBI_DEV4_DMA_ECC_CTRL_OFFS)
#define EBI_DEV4_TIM1_RD1_OFFS 0x00000424
#define EBI_DEV4_TIM1_RD1(base) ((base) + EBI_DEV4_TIM1_RD1_OFFS)
#define EBI_DEV4_TIM1_RD2_OFFS 0x00000428
#define EBI_DEV4_TIM1_RD2(base) ((base) + EBI_DEV4_TIM1_RD2_OFFS)
#define EBI_DEV4_TIM1_WR1_OFFS 0x0000042C
#define EBI_DEV4_TIM1_WR1(base) ((base) +
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
EBI_DEV4_TIM1_WR1_OFFS)
#define EBI_DEV4_TIM1_WR2_OFFS 0x00000430
#define EBI_DEV4_TIM1_WR2(base) ((base) + EBI_DEV4_TIM1_WR2_OFFS)
#define EBI_DEV4_TIM_EXT_OFFS 0x00000434
#define EBI_DEV4_TIM_EXT(base) ((base) + EBI_DEV4_TIM_EXT_OFFS)
#define EBI_DEV4_TIM2_CFI_RD1_OFFS 0x00000438
#define EBI_DEV4_TIM2_CFI_RD1(base) ((base) + EBI_DEV4_TIM2_CFI_RD1_OFFS)
#define EBI_DEV4_TIM2_CFI_RD2_OFFS 0x0000043C
#define EBI_DEV4_TIM2_CFI_RD2(base) ((base) + EBI_DEV4_TIM2_CFI_RD2_OFFS)
#define EBI_DEV4_TIM3_DMA1_OFFS 0x00000440
#define EBI_DEV4_TIM3_DMA1(base) ((base) + EBI_DEV4_TIM3_DMA1_OFFS)
#define EBI_DEV4_TIM3_DMA2_OFFS 0x00000444
#define EBI_DEV4_TIM3_DMA2(base) ((base) + EBI_DEV4_TIM3_DMA2_OFFS)
#define EBI_DEV4_TIM4_UDMA1_OFFS 0x00000448
#define EBI_DEV4_TIM4_UDMA1(base) ((base) + EBI_DEV4_TIM4_UDMA1_OFFS)
#define EBI_DEV4_TIM4_UDMA2_OFFS 0x0000044C
#define EBI_DEV4_TIM4_UDMA2(base) ((base) + EBI_DEV4_TIM4_UDMA2_OFFS)
#define EBI_DEV4_ACK_RM_CNT_OFFS 0x00000450
#define EBI_DEV4_ACK_RM_CNT(base) ((base) + EBI_DEV4_ACK_RM_CNT_OFFS)
#define EBI_INTERLEAVE_CNT_OFFS 0x00000900
#define EBI_INTERLEAVE_CNT(base) ((base) + EBI_INTERLEAVE_CNT_OFFS)
#define EBI_CNT_FL_PROGR_OFFS 0x00000904
#define EBI_CNT_FL_PROGR(base) ((base) + EBI_CNT_FL_PROGR_OFFS)
#define EBI_CNT_EXT_PAGE_SZ_OFFS 0x0000090C
#define EBI_CNT_EXT_PAGE_SZ(base) ((base) + EBI_CNT_EXT_PAGE_SZ_OFFS)
#define EBI_CNT_WAIT_RDY_OFFS 0x00000914
#define EBI_CNT_WAIT_RDY(base) ((base) + EBI_CNT_WAIT_RDY_OFFS)
#define EBI_CNT_ACK_OFFS 0x00000918
#define EBI_CNT_ACK(base) ((base) + EBI_CNT_ACK_OFFS)
#define EBI_GENIO1_CONFIG1_OFFS 0x00000A00
#define EBI_GENIO1_CONFIG1(base) ((base) + EBI_GENIO1_CONFIG1_OFFS)
#define EBI_GENIO1_CONFIG2_OFFS 0x00000A04
#define EBI_GENIO1_CONFIG2(base) ((base) + EBI_GENIO1_CONFIG2_OFFS)
#define EBI_GENIO1_CONFIG3_OFFS 0x00000A08
#define EBI_GENIO1_CONFIG3(base) ((base) + EBI_GENIO1_CONFIG3_OFFS)
#define EBI_GENIO2_CONFIG1_OFFS 0x00000A10
#define EBI_GENIO2_CONFIG1(base) ((base) + EBI_GENIO2_CONFIG1_OFFS)
#define EBI_GENIO2_CO
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
NFIG2_OFFS 0x00000A14
#define EBI_GENIO2_CONFIG2(base) ((base) + EBI_GENIO2_CONFIG2_OFFS)
#define EBI_GENIO2_CONFIG3_OFFS 0x00000A18
#define EBI_GENIO2_CONFIG3(base) ((base) + EBI_GENIO2_CONFIG3_OFFS)
#define EBI_GENIO3_CONFIG1_OFFS 0x00000A20
#define EBI_GENIO3_CONFIG1(base) ((base) + EBI_GENIO3_CONFIG1_OFFS)
#define EBI_GENIO3_CONFIG2_OFFS 0x00000A24
#define EBI_GENIO3_CONFIG2(base) ((base) + EBI_GENIO3_CONFIG2_OFFS)
#define EBI_GENIO3_CONFIG3_OFFS 0x00000A28
#define EBI_GENIO3_CONFIG3(base) ((base) + EBI_GENIO3_CONFIG3_OFFS)
#define EBI_GENIO4_CONFIG1_OFFS 0x00000A30
#define EBI_GENIO4_CONFIG1(base) ((base) + EBI_GENIO4_CONFIG1_OFFS)
#define EBI_GENIO4_CONFIG2_OFFS 0x00000A34
#define EBI_GENIO4_CONFIG2(base) ((base) + EBI_GENIO4_CONFIG2_OFFS)
#define EBI_GENIO4_CONFIG3_OFFS 0x00000A38
#define EBI_GENIO4_CONFIG3(base) ((base) + EBI_GENIO4_CONFIG3_OFFS)
#define EBI_GENIO5_CONFIG1_OFFS 0x00000A40
#define EBI_GENIO5_CONFIG1(base) ((base) + EBI_GENIO5_CONFIG1_OFFS)
#define EBI_GENIO5_CONFIG2_OFFS 0x00000A44
#define EBI_GENIO5_CONFIG2(base) ((base) + EBI_GENIO5_CONFIG2_OFFS)
#define EBI_GENIO5_CONFIG3_OFFS 0x00000A48
#define EBI_GENIO5_CONFIG3(base) ((base) + EBI_GENIO5_CONFIG3_OFFS)
#endif
CHIPSET(0x4C57, RADEON_LW, RV200)
CHIPSET(0x4C58, RADEON_LX, RV200)
CHIPSET(0x4C59, RADEON_LY, RV100)
CHIPSET(0x4C5A, RADEON_LZ, RV100)
CHIPSET(0x5144, RADEON_QD, R100)
CHIPSET(0x5145, RADEON_QE, R100)
CHIPSET(0x5146, RADEON_QF, R100)
CHIPSET(0x5147, RADEON_QG, R100)
CHIPSET(0x5159, RADEON_QY, RV100)
CHIPSET(0x515A, RADEON_QZ, RV100)
CHIPSET(0x5157, RV200_QW, RV200)
CHIPSET(0x5158, RV200_QX, RV200)
CHIPSET(0x515E, RN50_515E, UNKNOWN)
CHIPSET(0x5969, RN50_5969, UNKNOWN)
CHIPSET(0x4136, RS100_4136, RS100)
CHIPSET(0x4336, RS100_4336, RS100)
CHIPSET(0x4137, RS200_4137, RS200)
CHIPSET(0x4337, RS200_4337, RS200)
CHIPSET(0x4237, RS250_4237, RS200)
CHIPSET(0x4437, RS250_4437, RS200)
---
- hosts: ip-services
vars:
create_cust_account: false
roles:
- bootstrap
{
"created_at": "2015-02-27T22:28:23.898988",
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
"description": "Debug clojure from the browser",
"fork": false,
"full_name": "prismofeverything/schmetterling",
"language": "JavaScript",
"updated_at": "2015-02-27T23:42:35.555182"
}
/*
* Copyright 2012-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.context.event;
import org.springframework.boot.ConfigurableBootstrapContext;
import org.springframework.boot.SpringApplication;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
/**
* Event published when a {@link SpringApplication} is starting up and the
* {@link Environment} is first available for inspection and modification.
*
* @author Dave Syer
* @since 1.0.0
*/
@SuppressWarnings("serial")
public class ApplicationEnvironmentPreparedEvent extends SpringApplicationEvent {
private final ConfigurableBootstrapContext bootstrapContext;
private final ConfigurableEnvironment environment;
/**
* Create a new {@link ApplicationEnvironmentPreparedEvent} instance.
* @param application the current application
* @param args the arguments the application is running with
* @param environment the environment that was just created
* @deprecated since 2.4.0 in favor of
* {@link #ApplicationEnvironmentPreparedEvent(ConfigurableBootstrapContext, SpringApplication, String[], ConfigurableEnvironment)}
*/
@Deprecated
public ApplicationEnvironmentPreparedEvent(SpringApplication application, String[] args,
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ConfigurableEnvironment environment) {
this(null, application, args, environment);
}
/**
* Create a new {@link ApplicationEnvironmentPreparedEvent} instance.
* @param bootstrapContext the bootstrap context
* @param application the current application
* @param args the arguments the application is running with
* @param environment the environment that was just created
*/
public ApplicationEnvironmentPreparedEvent(ConfigurableBootstrapContext bootstrapContext,
SpringApplication application, String[] args, ConfigurableEnvironment environment) {
super(application, args);
this.bootstrapContext = bootstrapContext;
this.environment = environment;
}
/**
* Return the bootstap context.
* @return the bootstrap context
* @since 2.4.0
*/
public ConfigurableBootstrapContext getBootstrapContext() {
return this.bootstrapContext;
}
/**
* Return the environment.
* @return the environment
*/
public ConfigurableEnvironment getEnvironment() {
return this.environment;
}
}
@startuml
sprite $redhat [48x48/16] {
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000048BCDDCB840000000000000000000
00000000000000003AFFFFFFFFFFFFA30000000000000000
000000000000002CFFFFFFFFFFFFFFFFC200000000000000
00000000000008FFFFFFFFFFFFDEFFFFFF70000000000000
000000000000BFFFFE411466424439FFFFFB000000000000
00000000000CFFFFF4000000033EF1BFFFFFC00000000000
0000000000BFFFFFE01000000059501FFFFFFB0000000000
0000000008FFFFFFB0F9676100000009FFFFFF8000000000
000000003FFFFFFF709FFDA400000002FFFFFFF300000000
00000000CFFFFFFF4007100000000000BFFFFFFC00000000
00000004FFFFFEEF60000000000000006FFFFFFF40000000
0000000BFFC40008F6000000000000001FFFFFFFB0000000
00000
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
01FFD000007FFE95100000000000EFFFFFFF1000000
0000006FFC000000BFFFFFD8000000000D7BFFFFF5000000
0000009FFF30000006EFFFFF9000000047003DFFF9000000
000000CFFFD100000005BFFFF0000000100000DFFC000000
000000EFFFFD20000000016AC70000000000007FFE000000
000000FFFFFFF60000000000000000000000006FFF000000
000000FFFFFFFFC20000000000000000000000AFFF000000
000000DFFFFFFFDCA200000000000000000003FFFD000000
000000CFFFFFFE005FB400000000000000003EFFFC000000
0000009FFFFFFC0009AEE930000000000018FFFFF9000000
0000005FFFFFFF400003FFFFC86444468CFFFFFFF6000000
0000001CCA501DE200003EFFFFFFFFFFFFFFFFFFF1000000
00000000000001A90000004531041130FFFFFFFFB0000000
00000000000000000000000000000003FFFFFFFF50000000
0000000000000000000000000A670006FFFFFFFD00000000
0000000000000000000000000497000AFFEB9AC400000000
0000000000000000000000000000004FF800000000000000
000000000000000000000000000001ED5000000000000000
00000000000000000000000000000AC00000000000000000
000000000000000000000000000049100000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
}
!define DEV_REDHAT(_alias) ENTITY(rectangle,black,redhat,_alias,DEV REDHAT)
!define DEV_REDHAT(_alias, _label) ENTITY(rectangle,black,redhat,_label, _alias,DEV REDHAT)
!define DEV_REDHAT(_alias, _label, _shape) ENTITY(_shape,black,redhat,_label, _alias,DEV REDHAT)
!define DEV_REDHAT(_alias, _label, _shape, _color) ENTITY(_shape,_color,redhat,_label, _alias,DEV REDHAT)
skinparam folderBackgroundColor<<DEV REDHAT>> White
@enduml
[Language]
LanguageSupport0=0009
[OperatingSystem]
OSSupport=0000000000010010
[Data]
CurrentMedia=CD-ROM
CurrentComponentDef=Default.cdf
ProductName=Executor
set_mifserial=
DevEnvironment=GNU C
AppExe=
set_dlldebug=No
EmailAddres
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ss=
Instructions=Instructions.txt
set_testmode=No
set_mif=No
SummaryText=
Department=
HomeURL=
Author=
Type=Database Application
InstallRoot=D:\My Installations\Executor Win32
Version=2.1pr11
InstallationGUID=18397a85-64ea-11d1-962e-00609734111f
set_level=Level 3
CurrentFileGroupDef=Default.fdf
Notes=Notes.txt
set_maxerr=50
set_args=
set_miffile=Status.mif
set_dllcmdline=
Copyright=
set_warnaserr=No
CurrentPlatform=
Category=
set_preproc=
CurrentLanguage=English
CompanyName=ARDI
Description=Description.txt
set_maxwarn=50
set_crc=Yes
[MediaInfo]
mediadata0=Default/Media\Default
mediadata1=CD-ROM/Media\CD-ROM
[General]
Type=INSTALLMAIN
Version=1.00.000
SUMMARY="X.Org GL protocol headers"
DESCRIPTION="Headers for the X11 GL protocol."
HOMEPAGE="https://www.x.org/releases/individual/proto/"
COPYRIGHT="1991-2000 Silicon Graphics, Inc."
LICENSE="MIT"
REVISION="2"
SOURCE_URI="https://www.x.org/releases/individual/proto/glproto-$portVersion.tar.bz2"
CHECKSUM_SHA256="adaa94bded310a2bfcbb9deb4d751d965fcfe6fb3a2f6d242e2df2d6589dbe40"
ARCHITECTURES="!x86_gcc2 x86 x86_64"
SECONDARY_ARCHITECTURES="x86"
PROVIDES="
glproto$secondaryArchSuffix = $portVersion
devel:glproto$secondaryArchSuffix = $portVersion
"
REQUIRES="
haiku$secondaryArchSuffix
"
BUILD_REQUIRES="
haiku${secondaryArchSuffix}_devel
"
BUILD_PREREQUIRES="
cmd:aclocal
cmd:autoconf
cmd:gcc$secondaryArchSuffix
cmd:make
cmd:pkg_config$secondaryArchSuffix
devel:util_macros
"
BUILD()
{
autoreconf -vfi
runConfigure ./configure
}
INSTALL()
{
make install
fixPkgconfig
}
/* Copyright (C) 2011-2013 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
/* Kernel module implementing an IP set type: the hash:net,iface type */
#include <linux/jhash.h>
#include <linux/module.h>
#include <linux/ip.h>
#include <linux/skbuff.h>
#include
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
<linux/errno.h>
#include <linux/random.h>
#include <linux/rbtree.h>
#include <net/ip.h>
#include <net/ipv6.h>
#include <net/netlink.h>
#include <linux/netfilter.h>
#include <linux/netfilter/ipset/pfxlen.h>
#include <linux/netfilter/ipset/ip_set.h>
#include <linux/netfilter/ipset/ip_set_hash.h>
#define IPSET_TYPE_REV_MIN 0
/* 1 nomatch flag support added */
/* 2 /0 support added */
/* 3 Counters support added */
/* 4 Comments support added */
/* 5 Forceadd support added */
#define IPSET_TYPE_REV_MAX 6 /* skbinfo support added */
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
IP_SET_MODULE_DESC("hash:net,iface", IPSET_TYPE_REV_MIN, IPSET_TYPE_REV_MAX);
MODULE_ALIAS("ip_set_hash:net,iface");
/* Interface name rbtree */
struct iface_node {
struct rb_node node;
char iface[IFNAMSIZ];
};
#define iface_data(n) (rb_entry(n, struct iface_node, node)->iface)
static void
rbtree_destroy(struct rb_root *root)
{
struct iface_node *node, *next;
rbtree_postorder_for_each_entry_safe(node, next, root, node)
kfree(node);
*root = RB_ROOT;
}
static int
iface_test(struct rb_root *root, const char **iface)
{
struct rb_node *n = root->rb_node;
while (n) {
const char *d = iface_data(n);
int res = strcmp(*iface, d);
if (res < 0)
n = n->rb_left;
else if (res > 0)
n = n->rb_right;
else {
*iface = d;
return 1;
}
}
return 0;
}
static int
iface_add(struct rb_root *root, const char **iface)
{
struct rb_node **n = &(root->rb_node), *p = NULL;
struct iface_node *d;
while (*n) {
char *ifname = iface_data(*n);
int res = strcmp(*iface, ifname);
p = *n;
if (res < 0)
n = &((*n)->rb_left);
else if (res > 0)
n = &((*n)->rb_right);
else {
*iface = ifname;
return 0;
}
}
d = kzalloc(sizeof(*d), GFP_ATOMIC);
if (!d)
return -ENOMEM;
strcpy(d->iface, *iface);
rb_link_node(&d->node, p, n);
rb_insert_color(&d->node, root);
*iface = d->iface;
return 0;
}
/* Type specific function prefix */
#define HTYPE
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
hash_netiface
#define IP_SET_HASH_WITH_NETS
#define IP_SET_HASH_WITH_RBTREE
#define IP_SET_HASH_WITH_MULTI
#define IP_SET_HASH_WITH_NET0
#define STREQ(a, b) (strcmp(a, b) == 0)
/* IPv4 variant */
struct hash_netiface4_elem_hashed {
__be32 ip;
u8 physdev;
u8 cidr;
u8 nomatch;
u8 elem;
};
/* Member elements */
struct hash_netiface4_elem {
__be32 ip;
u8 physdev;
u8 cidr;
u8 nomatch;
u8 elem;
const char *iface;
};
/* Common functions */
static inline bool
hash_netiface4_data_equal(const struct hash_netiface4_elem *ip1,
const struct hash_netiface4_elem *ip2,
u32 *multi)
{
return ip1->ip == ip2->ip &&
ip1->cidr == ip2->cidr &&
(++*multi) &&
ip1->physdev == ip2->physdev &&
ip1->iface == ip2->iface;
}
static inline int
hash_netiface4_do_data_match(const struct hash_netiface4_elem *elem)
{
return elem->nomatch ? -ENOTEMPTY : 1;
}
static inline void
hash_netiface4_data_set_flags(struct hash_netiface4_elem *elem, u32 flags)
{
elem->nomatch = (flags >> 16) & IPSET_FLAG_NOMATCH;
}
static inline void
hash_netiface4_data_reset_flags(struct hash_netiface4_elem *elem, u8 *flags)
{
swap(*flags, elem->nomatch);
}
static inline void
hash_netiface4_data_netmask(struct hash_netiface4_elem *elem, u8 cidr)
{
elem->ip &= ip_set_netmask(cidr);
elem->cidr = cidr;
}
static bool
hash_netiface4_data_list(struct sk_buff *skb,
const struct hash_netiface4_elem *data)
{
u32 flags = data->physdev ? IPSET_FLAG_PHYSDEV : 0;
if (data->nomatch)
flags |= IPSET_FLAG_NOMATCH;
if (nla_put_ipaddr4(skb, IPSET_ATTR_IP, data->ip) ||
nla_put_u8(skb, IPSET_ATTR_CIDR, data->cidr) ||
nla_put_string(skb, IPSET_ATTR_IFACE, data->iface) ||
(flags &&
nla_put_net32(skb, IPSET_ATTR_CADT_FLAGS, htonl(flags))))
goto nla_put_failure;
return 0;
nla_put_failure:
return 1;
}
static inline void
hash_netiface4_data_next(struct hash_netiface4_elem *next,
const struct hash_netiface4_elem *d)
{
next->ip = d->ip;
}
#define MTYPE hash_netiface4
#define PF 4
#define HO
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ST_MASK 32
#define HKEY_DATALEN sizeof(struct hash_netiface4_elem_hashed)
#include "ip_set_hash_gen.h"
static int
hash_netiface4_kadt(struct ip_set *set, const struct sk_buff *skb,
const struct xt_action_param *par,
enum ipset_adt adt, struct ip_set_adt_opt *opt)
{
struct hash_netiface *h = set->data;
ipset_adtfn adtfn = set->variant->adt[adt];
struct hash_netiface4_elem e = {
.cidr = IP_SET_INIT_CIDR(h->nets[0].cidr[0], HOST_MASK),
.elem = 1,
};
struct ip_set_ext ext = IP_SET_INIT_KEXT(skb, opt, set);
int ret;
if (e.cidr == 0)
return -EINVAL;
if (adt == IPSET_TEST)
e.cidr = HOST_MASK;
ip4addrptr(skb, opt->flags & IPSET_DIM_ONE_SRC, &e.ip);
e.ip &= ip_set_netmask(e.cidr);
#define IFACE(dir) (par->dir ? par->dir->name : NULL)
#define PHYSDEV(dir) (nf_bridge->dir ? nf_bridge->dir->name : NULL)
#define SRCDIR (opt->flags & IPSET_DIM_TWO_SRC)
if (opt->cmdflags & IPSET_FLAG_PHYSDEV) {
#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
const struct nf_bridge_info *nf_bridge = skb->nf_bridge;
if (!nf_bridge)
return -EINVAL;
e.iface = SRCDIR ? PHYSDEV(physindev) : PHYSDEV(physoutdev);
e.physdev = 1;
#else
e.iface = NULL;
#endif
} else
e.iface = SRCDIR ? IFACE(in) : IFACE(out);
if (!e.iface)
return -EINVAL;
ret = iface_test(&h->rbtree, &e.iface);
if (adt == IPSET_ADD) {
if (!ret) {
ret = iface_add(&h->rbtree, &e.iface);
if (ret)
return ret;
}
} else if (!ret)
return ret;
return adtfn(set, &e, &ext, &opt->ext, opt->cmdflags);
}
static int
hash_netiface4_uadt(struct ip_set *set, struct nlattr *tb[],
enum ipset_adt adt, u32 *lineno, u32 flags, bool retried)
{
struct hash_netiface *h = set->data;
ipset_adtfn adtfn = set->variant->adt[adt];
struct hash_netiface4_elem e = { .cidr = HOST_MASK, .elem = 1 };
struct ip_set_ext ext = IP_SET_INIT_UEXT(set);
u32 ip = 0, ip_to = 0, last;
char iface[IFNAMSIZ];
int ret;
if (unlikely(!tb[IPSET_ATTR_IP] ||
!tb[IPSET_ATTR_IFACE] ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_TIMEOUT) ||
!ip_
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
set_optattr_netorder(tb, IPSET_ATTR_CADT_FLAGS) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_PACKETS) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_BYTES) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_SKBMARK) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_SKBPRIO) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_SKBQUEUE)))
return -IPSET_ERR_PROTOCOL;
if (tb[IPSET_ATTR_LINENO])
*lineno = nla_get_u32(tb[IPSET_ATTR_LINENO]);
ret = ip_set_get_hostipaddr4(tb[IPSET_ATTR_IP], &ip) ||
ip_set_get_extensions(set, tb, &ext);
if (ret)
return ret;
if (tb[IPSET_ATTR_CIDR]) {
e.cidr = nla_get_u8(tb[IPSET_ATTR_CIDR]);
if (e.cidr > HOST_MASK)
return -IPSET_ERR_INVALID_CIDR;
}
strcpy(iface, nla_data(tb[IPSET_ATTR_IFACE]));
e.iface = iface;
ret = iface_test(&h->rbtree, &e.iface);
if (adt == IPSET_ADD) {
if (!ret) {
ret = iface_add(&h->rbtree, &e.iface);
if (ret)
return ret;
}
} else if (!ret)
return ret;
if (tb[IPSET_ATTR_CADT_FLAGS]) {
u32 cadt_flags = ip_set_get_h32(tb[IPSET_ATTR_CADT_FLAGS]);
if (cadt_flags & IPSET_FLAG_PHYSDEV)
e.physdev = 1;
if (cadt_flags & IPSET_FLAG_NOMATCH)
flags |= (IPSET_FLAG_NOMATCH << 16);
}
if (adt == IPSET_TEST || !tb[IPSET_ATTR_IP_TO]) {
e.ip = htonl(ip & ip_set_hostmask(e.cidr));
ret = adtfn(set, &e, &ext, &ext, flags);
return ip_set_enomatch(ret, flags, adt, set) ? -ret :
ip_set_eexist(ret, flags) ? 0 : ret;
}
if (tb[IPSET_ATTR_IP_TO]) {
ret = ip_set_get_hostipaddr4(tb[IPSET_ATTR_IP_TO], &ip_to);
if (ret)
return ret;
if (ip_to < ip)
swap(ip, ip_to);
if (ip + UINT_MAX == ip_to)
return -IPSET_ERR_HASH_RANGE;
} else
ip_set_mask_from_to(ip, ip_to, e.cidr);
if (retried)
ip = ntohl(h->next.ip);
while (!after(ip, ip_to)) {
e.ip = htonl(ip);
last = ip_set_range_to_cidr(ip, ip_to, &e.cidr);
ret = adtfn(set, &e, &ext, &ext, flags);
if (ret && !ip_set_eexist(ret, flags))
return ret;
else
ret = 0;
ip = last + 1;
}
return ret;
}
/* IPv6 variant */
struct hash_ne
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
tiface6_elem_hashed {
union nf_inet_addr ip;
u8 physdev;
u8 cidr;
u8 nomatch;
u8 elem;
};
struct hash_netiface6_elem {
union nf_inet_addr ip;
u8 physdev;
u8 cidr;
u8 nomatch;
u8 elem;
const char *iface;
};
/* Common functions */
static inline bool
hash_netiface6_data_equal(const struct hash_netiface6_elem *ip1,
const struct hash_netiface6_elem *ip2,
u32 *multi)
{
return ipv6_addr_equal(&ip1->ip.in6, &ip2->ip.in6) &&
ip1->cidr == ip2->cidr &&
(++*multi) &&
ip1->physdev == ip2->physdev &&
ip1->iface == ip2->iface;
}
static inline int
hash_netiface6_do_data_match(const struct hash_netiface6_elem *elem)
{
return elem->nomatch ? -ENOTEMPTY : 1;
}
static inline void
hash_netiface6_data_set_flags(struct hash_netiface6_elem *elem, u32 flags)
{
elem->nomatch = (flags >> 16) & IPSET_FLAG_NOMATCH;
}
static inline void
hash_netiface6_data_reset_flags(struct hash_netiface6_elem *elem, u8 *flags)
{
swap(*flags, elem->nomatch);
}
static inline void
hash_netiface6_data_netmask(struct hash_netiface6_elem *elem, u8 cidr)
{
ip6_netmask(&elem->ip, cidr);
elem->cidr = cidr;
}
static bool
hash_netiface6_data_list(struct sk_buff *skb,
const struct hash_netiface6_elem *data)
{
u32 flags = data->physdev ? IPSET_FLAG_PHYSDEV : 0;
if (data->nomatch)
flags |= IPSET_FLAG_NOMATCH;
if (nla_put_ipaddr6(skb, IPSET_ATTR_IP, &data->ip.in6) ||
nla_put_u8(skb, IPSET_ATTR_CIDR, data->cidr) ||
nla_put_string(skb, IPSET_ATTR_IFACE, data->iface) ||
(flags &&
nla_put_net32(skb, IPSET_ATTR_CADT_FLAGS, htonl(flags))))
goto nla_put_failure;
return 0;
nla_put_failure:
return 1;
}
static inline void
hash_netiface6_data_next(struct hash_netiface4_elem *next,
const struct hash_netiface6_elem *d)
{
}
#undef MTYPE
#undef PF
#undef HOST_MASK
#undef HKEY_DATALEN
#define MTYPE hash_netiface6
#define PF 6
#define HOST_MASK 128
#define HKEY_DATALEN sizeof(struct hash_netiface6_elem_hashed)
#define IP_SET_EMIT_CREATE
#include "ip_set_hash_gen.h"
static int
h
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ash_netiface6_kadt(struct ip_set *set, const struct sk_buff *skb,
const struct xt_action_param *par,
enum ipset_adt adt, struct ip_set_adt_opt *opt)
{
struct hash_netiface *h = set->data;
ipset_adtfn adtfn = set->variant->adt[adt];
struct hash_netiface6_elem e = {
.cidr = IP_SET_INIT_CIDR(h->nets[0].cidr[0], HOST_MASK),
.elem = 1,
};
struct ip_set_ext ext = IP_SET_INIT_KEXT(skb, opt, set);
int ret;
if (e.cidr == 0)
return -EINVAL;
if (adt == IPSET_TEST)
e.cidr = HOST_MASK;
ip6addrptr(skb, opt->flags & IPSET_DIM_ONE_SRC, &e.ip.in6);
ip6_netmask(&e.ip, e.cidr);
if (opt->cmdflags & IPSET_FLAG_PHYSDEV) {
#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
const struct nf_bridge_info *nf_bridge = skb->nf_bridge;
if (!nf_bridge)
return -EINVAL;
e.iface = SRCDIR ? PHYSDEV(physindev) : PHYSDEV(physoutdev);
e.physdev = 1;
#else
e.iface = NULL;
#endif
} else
e.iface = SRCDIR ? IFACE(in) : IFACE(out);
if (!e.iface)
return -EINVAL;
ret = iface_test(&h->rbtree, &e.iface);
if (adt == IPSET_ADD) {
if (!ret) {
ret = iface_add(&h->rbtree, &e.iface);
if (ret)
return ret;
}
} else if (!ret)
return ret;
return adtfn(set, &e, &ext, &opt->ext, opt->cmdflags);
}
static int
hash_netiface6_uadt(struct ip_set *set, struct nlattr *tb[],
enum ipset_adt adt, u32 *lineno, u32 flags, bool retried)
{
struct hash_netiface *h = set->data;
ipset_adtfn adtfn = set->variant->adt[adt];
struct hash_netiface6_elem e = { .cidr = HOST_MASK, .elem = 1 };
struct ip_set_ext ext = IP_SET_INIT_UEXT(set);
char iface[IFNAMSIZ];
int ret;
if (unlikely(!tb[IPSET_ATTR_IP] ||
!tb[IPSET_ATTR_IFACE] ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_TIMEOUT) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_CADT_FLAGS) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_PACKETS) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_BYTES) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_SKBMARK) ||
!ip_set_optattr_netorder(tb, IPSET_ATTR_SKBPRIO) ||
!ip_set_optattr_netorder(tb
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
, IPSET_ATTR_SKBQUEUE)))
return -IPSET_ERR_PROTOCOL;
if (unlikely(tb[IPSET_ATTR_IP_TO]))
return -IPSET_ERR_HASH_RANGE_UNSUPPORTED;
if (tb[IPSET_ATTR_LINENO])
*lineno = nla_get_u32(tb[IPSET_ATTR_LINENO]);
ret = ip_set_get_ipaddr6(tb[IPSET_ATTR_IP], &e.ip) ||
ip_set_get_extensions(set, tb, &ext);
if (ret)
return ret;
if (tb[IPSET_ATTR_CIDR])
e.cidr = nla_get_u8(tb[IPSET_ATTR_CIDR]);
if (e.cidr > HOST_MASK)
return -IPSET_ERR_INVALID_CIDR;
ip6_netmask(&e.ip, e.cidr);
strcpy(iface, nla_data(tb[IPSET_ATTR_IFACE]));
e.iface = iface;
ret = iface_test(&h->rbtree, &e.iface);
if (adt == IPSET_ADD) {
if (!ret) {
ret = iface_add(&h->rbtree, &e.iface);
if (ret)
return ret;
}
} else if (!ret)
return ret;
if (tb[IPSET_ATTR_CADT_FLAGS]) {
u32 cadt_flags = ip_set_get_h32(tb[IPSET_ATTR_CADT_FLAGS]);
if (cadt_flags & IPSET_FLAG_PHYSDEV)
e.physdev = 1;
if (cadt_flags & IPSET_FLAG_NOMATCH)
flags |= (IPSET_FLAG_NOMATCH << 16);
}
ret = adtfn(set, &e, &ext, &ext, flags);
return ip_set_enomatch(ret, flags, adt, set) ? -ret :
ip_set_eexist(ret, flags) ? 0 : ret;
}
static struct ip_set_type hash_netiface_type __read_mostly = {
.name = "hash:net,iface",
.protocol = IPSET_PROTOCOL,
.features = IPSET_TYPE_IP | IPSET_TYPE_IFACE |
IPSET_TYPE_NOMATCH,
.dimension = IPSET_DIM_TWO,
.family = NFPROTO_UNSPEC,
.revision_min = IPSET_TYPE_REV_MIN,
.revision_max = IPSET_TYPE_REV_MAX,
.create = hash_netiface_create,
.create_policy = {
[IPSET_ATTR_HASHSIZE] = { .type = NLA_U32 },
[IPSET_ATTR_MAXELEM] = { .type = NLA_U32 },
[IPSET_ATTR_PROBES] = { .type = NLA_U8 },
[IPSET_ATTR_RESIZE] = { .type = NLA_U8 },
[IPSET_ATTR_PROTO] = { .type = NLA_U8 },
[IPSET_ATTR_TIMEOUT] = { .type = NLA_U32 },
[IPSET_ATTR_CADT_FLAGS] = { .type = NLA_U32 },
},
.adt_policy = {
[IPSET_ATTR_IP] = { .type = NLA_NESTED },
[IPSET_ATTR_IP_TO] = { .type = NLA_NESTED },
[IPSET_ATTR_IFACE] = { .type = NLA_NUL_STRING,
.len = IFNAMSIZ - 1 },
[IPSET_ATTR_CADT_FLA
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
GS] = { .type = NLA_U32 },
[IPSET_ATTR_CIDR] = { .type = NLA_U8 },
[IPSET_ATTR_TIMEOUT] = { .type = NLA_U32 },
[IPSET_ATTR_LINENO] = { .type = NLA_U32 },
[IPSET_ATTR_BYTES] = { .type = NLA_U64 },
[IPSET_ATTR_PACKETS] = { .type = NLA_U64 },
[IPSET_ATTR_COMMENT] = { .type = NLA_NUL_STRING },
[IPSET_ATTR_SKBMARK] = { .type = NLA_U64 },
[IPSET_ATTR_SKBPRIO] = { .type = NLA_U32 },
[IPSET_ATTR_SKBQUEUE] = { .type = NLA_U16 },
},
.me = THIS_MODULE,
};
static int __init
hash_netiface_init(void)
{
return ip_set_type_register(&hash_netiface_type);
}
static void __exit
hash_netiface_fini(void)
{
ip_set_type_unregister(&hash_netiface_type);
}
module_init(hash_netiface_init);
module_exit(hash_netiface_fini);
<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fitsSystemWindows="true"
tools:context="com.ocnyang.contourviewdemo.ContourActivity">
<android.support.design.widget.AppBarLayout
android:id="@+id/app_bar"
android:layout_width="match_parent"
android:layout_height="@dimen/app_bar_height"
android:fitsSystemWindows="true"
android:theme="@style/AppBarOverlay">
<android.support.design.widget.CollapsingToolbarLayout
android:id="@+id/toolbar_layout"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fitsSystemWindows="true"
app:contentScrim="?attr/colorPrimary"
app:layout_scrollFlags="scroll|exitUntilCollapsed"
app:toolbarId="@+id/toolbar">
<android.support.v7.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
"
app:layout_collapseMode="pin"
app:popupTheme="@style/PopupOverlay"/>
</android.support.design.widget.CollapsingToolbarLayout>
</android.support.design.widget.AppBarLayout>
<include layout="@layout/content_contour"/>
<android.support.design.widget.FloatingActionButton
android:id="@+id/fab"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_margin="@dimen/fab_margin"
app:layout_anchor="@id/app_bar"
app:layout_anchorGravity="bottom|end"
app:srcCompat="@drawable/github"/>
</android.support.design.widget.CoordinatorLayout>
<bx_include_base:../modules/base/profile/template/cover.html />
function y = rescale(x,a,b)
% rescale - rescale data in [a,b]
%
% y = rescale(x,a,b);
%
% Copyright (c) 2004 Gabriel Peyr?
if nargin<2
a = 0;
end
if nargin<3
b = 1;
end
m = min(x(:));
M = max(x(:));
if M-m<eps
y = x;
else
y = (b-a) * (x-m)/(M-m) + a;
end
class C {
x match {
case (x: T) :: Nil =>
}
}
#include <windows.h>
typedef void *HMEMORYMODULE;
HMEMORYMODULE MemoryLoadLibrary(const void *);
FARPROC MemoryGetProcAddress(HMEMORYMODULE, const char *);
void MemoryFreeLibrary(HMEMORYMODULE);
Shader "Hidden/Noise Shader YUV" {
Properties {
_MainTex ("Base (RGB)", 2D) = "white" {}
_GrainTex ("Base (RGB)", 2D) = "gray" {}
_ScratchTex ("Base (RGB)", 2D) = "gray" {}
}
SubShader {
Pass {
ZTest Always Cull Off ZWrite Off
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct v2f {
float4 pos : SV_POSITION;
float2 uv : TEXCOORD0;
float2 uvg : TEXCOORD1; // grain
float2 uvs : TEXCOORD2; // scratch
};
uniform sampler2D _MainTex;
uniform sampler2D _GrainTex;
uniform sampler2D _ScratchTex;
uniform float4 _GrainOffsetScale;
uniform float4 _ScratchOffsetScale;
uniform fixed4 _Intensity; // x=grain, y=scratch
half4 _MainTex_ST;
v2f vert (appdata_img v)
{
v2f o;
o.pos = mul (
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
UNITY_MATRIX_MVP, v.vertex);
o.uv = UnityStereoScreenSpaceUVAdjust(MultiplyUV (UNITY_MATRIX_TEXTURE0, v.texcoord), _MainTex_ST);
o.uvg = v.texcoord.xy * _GrainOffsetScale.zw + _GrainOffsetScale.xy;
o.uvs = v.texcoord.xy * _ScratchOffsetScale.zw + _ScratchOffsetScale.xy;
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 col = tex2D(_MainTex, i.uv);
// convert to YUV
fixed3 yuv;
yuv.x = dot( col.rgb, half3(0.299,0.587,0.114) );
yuv.y = (col.b-yuv.x)*0.492;
yuv.z = (col.r-yuv.x)*0.877;
// sample noise texture and do a signed add
fixed3 grain = tex2D(_GrainTex, i.uvg).rgb * 2 - 1;
yuv.rgb += grain * _Intensity.x;
// convert back to rgb
col.r = yuv.z * 1.140 + yuv.x;
col.g = yuv.z * (-0.581) + yuv.y * (-0.395) + yuv.x;
col.b = yuv.y * 2.032 + yuv.x;
// sample scratch texture and add
fixed3 scratch = tex2D(_ScratchTex, i.uvs).rgb * 2 - 1;
col.rgb += scratch * _Intensity.y;
return col;
}
ENDCG
}
}
Fallback off
}
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview Defines the {@link CKEDITOR.lang} object, for the
* Khmer language.
*/
/**#@+
@type String
@example
*/
/**
* Contains the dictionary of language entries.
* @namespace
*/
CKEDITOR.lang['km'] =
{
/**
* The language reading direction. Possible values are "rtl" for
* Right-To-Left languages (like Arabic) and "ltr" for Left-To-Right
* languages (like English).
* @default 'ltr'
*/
dir : 'ltr',
/*
* Screenreader titles. Please note that screenreaders are not always capable
* of reading non-English words. So be careful while translating it.
*/
editorTitle : 'Rich text editor, %1', // MISSING
editorHelp : 'Press ALT 0 for help', // MISSING
// ARIA descriptions.
toolbars : 'Editor toolbars', // MISSING
editor : 'Rich Text Editor', // MISSING
// Toolbar buttons without dialogs.
source : 'កូត',
newPage : 'ទំព័រថ្មី',
save : 'រក្សាទុ�
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
��',
preview : 'មើលសាកល្បង',
cut : 'កាត់យក',
copy : 'ចំលងយក',
paste : 'ចំលងដាក់',
print : 'បោះពុម្ភ',
underline : 'ដិតបន្ទាត់ពីក្រោមអក្សរ',
bold : 'អក្សរដិតធំ',
italic : 'អក្សរផ្តេក',
selectAll : 'ជ្រើសរើសទាំងអស់',
removeFormat : 'លប់ចោល ការរចនា',
strike : 'ដិតបន្ទាត់ពាក់កណ្តាលអក្សរ',
subscript : 'អក្សរតូចក្រោម',
superscript : 'អក្សរតូចលើ',
horizontalrule : 'បន្ថែមបន្ទាត់ផ្តេក',
pagebreak : 'បន្ថែម ការផ្តាច់ទំព័រ',
pagebreakAlt : 'Page Break', // MISSING
unlink : 'លប់ឈ្នាប់',
undo : 'សារឡើងវិញ',
redo : 'ធ្វើឡើងវិញ',
// Common messages and labels.
common :
{
browseServer : 'មើល',
url : 'URL',
protocol : 'ប្រូតូកូល',
upload : 'ទាញយក',
uploadSubmit : 'បញ្ជូនទៅកាន់ម៉ាស៊ីនផ្តល់សេវា',
image : 'រូបភាព',
flash : 'Flash',
form : 'បែបបទ',
checkbox : 'ប្រអប់ជ្រើសរើស',
radio : 'ប៉ូតុនរង្វង់មូល',
textField : 'ជួរសរសេរអត្ថបទ',
textarea : 'តំបន់សរសេរអត្ថបទ',
hiddenField : 'ជួរលាក់',
button : 'ប៉ូតុន',
select : 'ជួរជ្រើសរើស',
imageButton : 'ប៉ូតុនរូបភាព',
notSet : '<មិនមែន>',
id : 'Id',
name : 'ឈ្មោះ',
langDir : 'ទិសដៅភាសា',
langDirLtr : 'ពីឆ្វេងទៅស្តាំ(LTR)',
langDirRtl : 'ពីស្តាំទៅ�
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
�្វេង(RTL)',
langCode : 'លេខកូតភាសា',
longDescr : 'អធិប្បាយ URL វែង',
cssClass : 'Stylesheet Classes',
advisoryTitle : 'ចំណងជើង ប្រឹក្សា',
cssStyle : 'ម៉ូត',
ok : 'យល់ព្រម',
cancel : 'មិនយល់ព្រម',
close : 'Close', // MISSING
preview : 'Preview', // MISSING
generalTab : 'General', // MISSING
advancedTab : 'កំរិតខ្ពស់',
validateNumberFailed : 'This value is not a number.', // MISSING
confirmNewPage : 'Any unsaved changes to this content will be lost. Are you sure you want to load new page?', // MISSING
confirmCancel : 'Some of the options have been changed. Are you sure to close the dialog?', // MISSING
options : 'Options', // MISSING
target : 'Target', // MISSING
targetNew : 'New Window (_blank)', // MISSING
targetTop : 'Topmost Window (_top)', // MISSING
targetSelf : 'Same Window (_self)', // MISSING
targetParent : 'Parent Window (_parent)', // MISSING
langDirLTR : 'Left to Right (LTR)', // MISSING
langDirRTL : 'Right to Left (RTL)', // MISSING
styles : 'Style', // MISSING
cssClasses : 'Stylesheet Classes', // MISSING
width : 'ទទឹង',
height : 'កំពស់',
align : 'កំណត់ទីតាំង',
alignLeft : 'ខាងឆ្វង',
alignRight : 'ខាងស្តាំ',
alignCenter : 'កណ្តាល',
alignTop : 'ខាងលើ',
alignMiddle : 'កណ្តាល',
alignBottom : 'ខាងក្រោម',
invalidHeight : 'Height must be a number.', // MISSING
invalidWidth : 'Width must be a number.', // MISSING
invalidCssLength : 'Value specified for the "%1" field must be a positive number with or without a valid CSS measurement unit (px, %, in, cm, mm, em, ex, pt, or pc).', // MISSING
invalidHtmlLength : 'Value specified for the "%1" field must be a positive number with or without a valid HTML measurement unit (px or %).', // MISSING
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
invalidInlineStyle : 'Value specified for the inline style must consist of one or more tuples with the format of "name : value", separated by semi-colons.', // MISSING
cssLengthTooltip : 'Enter a number for a value in pixels or a number with a valid CSS unit (px, %, in, cm, mm, em, ex, pt, or pc).', // MISSING
// Put the voice-only part of the label in the span.
unavailable : '%1<span class="cke_accessibility">, unavailable</span>' // MISSING
},
contextmenu :
{
options : 'Context Menu Options' // MISSING
},
// Special char dialog.
specialChar :
{
toolbar : 'បន្ថែមអក្សរពិសេស',
title : 'តូអក្សរពិសេស',
options : 'Special Character Options' // MISSING
},
// Link dialog.
link :
{
toolbar : 'បន្ថែម/កែប្រែ ឈ្នាប់',
other : '<other>', // MISSING
menu : 'កែប្រែឈ្នាប់',
title : 'ឈ្នាប់',
info : 'ពត៌មានអំពីឈ្នាប់',
target : 'គោលដៅ',
upload : 'ទាញយក',
advanced : 'កំរិតខ្ពស់',
type : 'ប្រភេទឈ្នាប់',
toUrl : 'URL', // MISSING
toAnchor : 'យុថ្កានៅក្នុងទំព័រនេះ',
toEmail : 'អ៊ីមែល',
targetFrame : '<ហ្វ្រេម>',
targetPopup : '<វីនដូវ លោត>',
targetFrameName : 'ឈ្មោះហ្រ្វេមដែលជាគោលដៅ',
targetPopupName : 'ឈ្មោះវីនដូវលោត',
popupFeatures : 'លក្ខណះរបស់វីនដូលលោត',
popupResizable : 'Resizable', // MISSING
popupStatusBar : 'របា ពត៌មាន',
popupLocationBar: 'របា ទីតាំង',
popupToolbar : 'របា ឩបករណ៍',
popupMenuBar : 'របា មឺនុយ',
popupFullScreen : 'អេក្រុងពេញ(IE)',
popupScrollBars : 'របា ទាញ',
popupDependent : 'អាស្រ័យលើ
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
(Netscape)',
popupLeft : 'ទីតាំងខាងឆ្វេង',
popupTop : 'ទីតាំងខាងលើ',
id : 'Id', // MISSING
langDir : 'ទិសដៅភាសា',
langDirLTR : 'ពីឆ្វេងទៅស្តាំ(LTR)',
langDirRTL : 'ពីស្តាំទៅឆ្វេង(RTL)',
acccessKey : 'ឃី សំរាប់ចូល',
name : 'ឈ្មោះ',
langCode : 'ទិសដៅភាសា',
tabIndex : 'លេខ Tab',
advisoryTitle : 'ចំណងជើង ប្រឹក្សា',
advisoryContentType : 'ប្រភេទអត្ថបទ ប្រឹក្សា',
cssClasses : 'Stylesheet Classes',
charset : 'លេខកូតអក្សររបស់ឈ្នាប់',
styles : 'ម៉ូត',
rel : 'Relationship', // MISSING
selectAnchor : 'ជ្រើសរើសយុថ្កា',
anchorName : 'តាមឈ្មោះរបស់យុថ្កា',
anchorId : 'តាម Id',
emailAddress : 'អ៊ីមែល',
emailSubject : 'ចំណងជើងអត្ថបទ',
emailBody : 'អត្ថបទ',
noAnchors : '(No anchors available in the document)', // MISSING
noUrl : 'សូមសរសេរ អាស័យដ្ឋាន URL',
noEmail : 'សូមសរសេរ អាស័យដ្ឋាន អ៊ីមែល'
},
// Anchor dialog
anchor :
{
toolbar : 'បន្ថែម/កែប្រែ យុថ្កា',
menu : 'ការកំណត់យុថ្កា',
title : 'ការកំណត់យុថ្កា',
name : 'ឈ្មោះយុទ្ធថ្កា',
errorName : 'សូមសរសេរ ឈ្មោះយុទ្ធថ្កា',
remove : 'Remove Anchor' // MISSING
},
// List style dialog
list:
{
numberedTitle : 'Numbered List Properties', // MISSING
bulletedTitle : 'Bulleted List Properties', // MISSING
type : 'Type', // MISSING
start : 'Start', // MISSING
validateStartNumber :'List start number must b
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
e a whole number.', // MISSING
circle : 'Circle', // MISSING
disc : 'Disc', // MISSING
square : 'Square', // MISSING
none : 'None', // MISSING
notset : '<not set>', // MISSING
armenian : 'Armenian numbering', // MISSING
georgian : 'Georgian numbering (an, ban, gan, etc.)', // MISSING
lowerRoman : 'Lower Roman (i, ii, iii, iv, v, etc.)', // MISSING
upperRoman : 'Upper Roman (I, II, III, IV, V, etc.)', // MISSING
lowerAlpha : 'Lower Alpha (a, b, c, d, e, etc.)', // MISSING
upperAlpha : 'Upper Alpha (A, B, C, D, E, etc.)', // MISSING
lowerGreek : 'Lower Greek (alpha, beta, gamma, etc.)', // MISSING
decimal : 'Decimal (1, 2, 3, etc.)', // MISSING
decimalLeadingZero : 'Decimal leading zero (01, 02, 03, etc.)' // MISSING
},
// Find And Replace Dialog
findAndReplace :
{
title : 'Find and Replace', // MISSING
find : 'ស្វែងរក',
replace : 'ជំនួស',
findWhat : 'ស្វែងរកអ្វី:',
replaceWith : 'ជំនួសជាមួយ:',
notFoundMsg : 'ពាក្យនេះ រកមិនឃើញទេ ។',
findOptions : 'Find Options', // MISSING
matchCase : 'ករណ៉ត្រូវរក',
matchWord : 'ត្រូវពាក្យទាំងអស់',
matchCyclic : 'Match cyclic', // MISSING
replaceAll : 'ជំនួសទាំងអស់',
replaceSuccessMsg : '%1 occurrence(s) replaced.' // MISSING
},
// Table Dialog
table :
{
toolbar : 'តារាង',
title : 'ការកំណត់ តារាង',
menu : 'ការកំណត់ តារាង',
deleteTable : 'លប់តារាង',
rows : 'ជួរផ្តេក',
columns : 'ជួរឈរ',
border : 'ទំហំស៊ុម',
widthPx : 'ភីកសែល',
widthPc : 'ភាគរយ',
widthUnit : 'width unit', // MISSING
cellSpace : 'គំលាតសែល',
cellPad : 'គែមសែល',
caption : 'ចំណងជើង',
summary : 'សេច�
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
��្តីសង្ខេប',
headers : 'Headers', // MISSING
headersNone : 'None', // MISSING
headersColumn : 'First column', // MISSING
headersRow : 'First Row', // MISSING
headersBoth : 'Both', // MISSING
invalidRows : 'Number of rows must be a number greater than 0.', // MISSING
invalidCols : 'Number of columns must be a number greater than 0.', // MISSING
invalidBorder : 'Border size must be a number.', // MISSING
invalidWidth : 'Table width must be a number.', // MISSING
invalidHeight : 'Table height must be a number.', // MISSING
invalidCellSpacing : 'Cell spacing must be a positive number.', // MISSING
invalidCellPadding : 'Cell padding must be a positive number.', // MISSING
cell :
{
menu : 'Cell', // MISSING
insertBefore : 'Insert Cell Before', // MISSING
insertAfter : 'Insert Cell After', // MISSING
deleteCell : 'លប់សែល',
merge : 'បញ្ជូលសែល',
mergeRight : 'Merge Right', // MISSING
mergeDown : 'Merge Down', // MISSING
splitHorizontal : 'Split Cell Horizontally', // MISSING
splitVertical : 'Split Cell Vertically', // MISSING
title : 'Cell Properties', // MISSING
cellType : 'Cell Type', // MISSING
rowSpan : 'Rows Span', // MISSING
colSpan : 'Columns Span', // MISSING
wordWrap : 'Word Wrap', // MISSING
hAlign : 'Horizontal Alignment', // MISSING
vAlign : 'Vertical Alignment', // MISSING
alignBaseline : 'Baseline', // MISSING
bgColor : 'Background Color', // MISSING
borderColor : 'Border Color', // MISSING
data : 'Data', // MISSING
header : 'Header', // MISSING
yes : 'Yes', // MISSING
no : 'No', // MISSING
invalidWidth : 'Cell width must be a number.', // MISSING
invalidHeight : 'Cell height must be a number.', // MISSING
invalidRowSpan : 'Rows span must be a whole number.', // MISSING
invalidColSpan : 'Columns span must be a whole number.', // MISSING
chooseColor : 'Choose' // MISSING
},
row :
{
menu : 'Row', //
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
MISSING
insertBefore : 'Insert Row Before', // MISSING
insertAfter : 'Insert Row After', // MISSING
deleteRow : 'លប់ជួរផ្តេក'
},
column :
{
menu : 'Column', // MISSING
insertBefore : 'Insert Column Before', // MISSING
insertAfter : 'Insert Column After', // MISSING
deleteColumn : 'លប់ជួរឈរ'
}
},
// Button Dialog.
button :
{
title : 'ការកំណត់ ប៉ូតុន',
text : 'អត្ថបទ(តំលៃ)',
type : 'ប្រភេទ',
typeBtn : 'Button', // MISSING
typeSbm : 'Submit', // MISSING
typeRst : 'Reset' // MISSING
},
// Checkbox and Radio Button Dialogs.
checkboxAndRadio :
{
checkboxTitle : 'ការកំណត់ប្រអប់ជ្រើសរើស',
radioTitle : 'ការកំណត់ប៉ូតុនរង្វង់',
value : 'តំលៃ',
selected : 'បានជ្រើសរើស'
},
// Form Dialog.
form :
{
title : 'ការកំណត់បែបបទ',
menu : 'ការកំណត់បែបបទ',
action : 'សកម្មភាព',
method : 'វិធី',
encoding : 'Encoding' // MISSING
},
// Select Field Dialog.
select :
{
title : 'ការកំណត់ជួរជ្រើសរើស',
selectInfo : 'ពត៌មាន',
opAvail : 'ការកំណត់ជ្រើសរើស ដែលអាចកំណត់បាន',
value : 'តំលៃ',
size : 'ទំហំ',
lines : 'បន្ទាត់',
chkMulti : 'អនុញ្ញាតអោយជ្រើសរើសច្រើន',
opText : 'ពាក្យ',
opValue : 'តំលៃ',
btnAdd : 'បន្ថែម',
btnModify : 'ផ្លាស់ប្តូរ',
btnUp : 'លើ',
btnDown : 'ក្រោម',
btnSetValue : 'Set as selected value', // MISSING
btnDelete : 'លប់'
},
// Textarea Dialog.
textarea :
{
title : 'ការកំណត់កន្លែងសរសេរអត្ថបទ',
cols :
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
'ជូរឈរ',
rows : 'ជូរផ្តេក'
},
// Text Field Dialog.
textfield :
{
title : 'ការកំណត់ជួរអត្ថបទ',
name : 'ឈ្មោះ',
value : 'តំលៃ',
charWidth : 'ទទឹង អក្សរ',
maxChars : 'អក្សរអតិបរិមា',
type : 'ប្រភេទ',
typeText : 'ពាក្យ',
typePass : 'ពាក្យសំងាត់'
},
// Hidden Field Dialog.
hidden :
{
title : 'ការកំណត់ជួរលាក់',
name : 'ឈ្មោះ',
value : 'តំលៃ'
},
// Image Dialog.
image :
{
title : 'ការកំណត់រូបភាព',
titleButton : 'ការកំណត់ប៉ូតុនរូបភាព',
menu : 'ការកំណត់រូបភាព',
infoTab : 'ពត៌មានអំពីរូបភាព',
btnUpload : 'បញ្ជូនទៅកាន់ម៉ាស៊ីនផ្តល់សេវា',
upload : 'ទាញយក',
alt : 'អត្ថបទជំនួស',
lockRatio : 'អត្រាឡុក',
resetSize : 'កំណត់ទំហំឡើងវិញ',
border : 'ស៊ុម',
hSpace : 'គំលាតទទឹង',
vSpace : 'គំលាតបណ្តោយ',
alertUrl : 'សូមសរសេរងាស័យដ្ឋានរបស់រូបភាព',
linkTab : 'ឈ្នាប់',
button2Img : 'Do you want to transform the selected image button on a simple image?', // MISSING
img2Button : 'Do you want to transform the selected image on a image button?', // MISSING
urlMissing : 'Image source URL is missing.', // MISSING
validateBorder : 'Border must be a whole number.', // MISSING
validateHSpace : 'HSpace must be a whole number.', // MISSING
validateVSpace : 'VSpace must be a whole number.' // MISSING
},
// Flash Dialog
flash :
{
properties : 'ការកំណត់ Flash',
propertiesTab : 'Properties', // MISSING
title : 'ការកំណត់ Flash',
chkPlay
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
: 'លេងដោយស្វ័យប្រវត្ត',
chkLoop : 'ចំនួនដង',
chkMenu : 'បង្ហាញ មឺនុយរបស់ Flash',
chkFull : 'Allow Fullscreen', // MISSING
scale : 'ទំហំ',
scaleAll : 'បង្ហាញទាំងអស់',
scaleNoBorder : 'មិនបង្ហាញស៊ុម',
scaleFit : 'ត្រូវល្មម',
access : 'Script Access', // MISSING
accessAlways : 'Always', // MISSING
accessSameDomain: 'Same domain', // MISSING
accessNever : 'Never', // MISSING
alignAbsBottom : 'Abs Bottom', // MISSING
alignAbsMiddle : 'Abs Middle', // MISSING
alignBaseline : 'បន្ទាត់ជាមូលដ្ឋាន',
alignTextTop : 'លើអត្ថបទ',
quality : 'Quality', // MISSING
qualityBest : 'Best', // MISSING
qualityHigh : 'High', // MISSING
qualityAutoHigh : 'Auto High', // MISSING
qualityMedium : 'Medium', // MISSING
qualityAutoLow : 'Auto Low', // MISSING
qualityLow : 'Low', // MISSING
windowModeWindow: 'Window', // MISSING
windowModeOpaque: 'Opaque', // MISSING
windowModeTransparent : 'Transparent', // MISSING
windowMode : 'Window mode', // MISSING
flashvars : 'Variables for Flash', // MISSING
bgcolor : 'ពណ៌ផ្ទៃខាងក្រោយ',
hSpace : 'គំលាតទទឹង',
vSpace : 'គំលាតបណ្តោយ',
validateSrc : 'សូមសរសេរ អាស័យដ្ឋាន URL',
validateHSpace : 'HSpace must be a number.', // MISSING
validateVSpace : 'VSpace must be a number.' // MISSING
},
// Speller Pages Dialog
spellCheck :
{
toolbar : 'ពិនិត្យអក្ខរាវិរុទ្ធ',
title : 'Spell Check', // MISSING
notAvailable : 'Sorry, but service is unavailable now.', // MISSING
errorLoading : 'Error loading application service host: %s.', // MISSING
notInDic : 'គ្មានក្នុងវចនានុក្រម',
changeTo : 'ផ្លាស់ប្�
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
�ូរទៅ',
btnIgnore : 'មិនផ្លាស់ប្តូរ',
btnIgnoreAll : 'មិនផ្លាស់ប្តូរ ទាំងអស់',
btnReplace : 'ជំនួស',
btnReplaceAll : 'ជំនួសទាំងអស់',
btnUndo : 'សារឡើងវិញ',
noSuggestions : '- គ្មានសំណើរ -',
progress : 'កំពុងពិនិត្យអក្ខរាវិរុទ្ធ...',
noMispell : 'ការពិនិត្យអក្ខរាវិរុទ្ធបានចប់: គ្មានកំហុស',
noChanges : 'ការពិនិត្យអក្ខរាវិរុទ្ធបានចប់: ពុំមានផ្លាស់ប្តូរ',
oneChange : 'ការពិនិត្យអក្ខរាវិរុទ្ធបានចប់: ពាក្យមួយត្រូចបានផ្លាស់ប្តូរ',
manyChanges : 'ការពិនិត្យអក្ខរាវិរុទ្ធបានចប់: %1 ពាក្យបានផ្លាស់ប្តូរ',
ieSpellDownload : 'ពុំមានកម្មវិធីពិនិត្យអក្ខរាវិរុទ្ធ ។ តើចង់ទាញយកពីណា?'
},
smiley :
{
toolbar : 'រូបភាព',
title : 'បញ្ជូលរូបភាព',
options : 'Smiley Options' // MISSING
},
elementsPath :
{
eleLabel : 'Elements path', // MISSING
eleTitle : '%1 element' // MISSING
},
numberedlist : 'បញ្ជីជាអក្សរ',
bulletedlist : 'បញ្ជីជារង្វង់មូល',
indent : 'បន្ថែមការចូលបន្ទាត់',
outdent : 'បន្ថយការចូលបន្ទាត់',
justify :
{
left : 'តំរឹមឆ្វេង',
center : 'តំរឹមកណ្តាល',
right : 'តំរឹមស្តាំ',
block : 'តំរឹមសងខាង'
},
blockquote : 'Block Quote', // MISSING
clipboard
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
:
{
title : 'ចំលងដាក់',
cutError : 'ការកំណត់សុវត្ថភាពរបស់កម្មវិធីរុករករបស់លោកអ្នក នេះ\u200bមិនអាចធ្វើកម្មវិធីតាក់តែងអត្ថបទ កាត់អត្ថបទយកដោយស្វ័យប្រវត្តបានឡើយ ។ សូមប្រើប្រាស់បន្សំ ឃីដូចនេះ (Ctrl/Cmd+X) ។',
copyError : 'ការកំណត់សុវត្ថភាពរបស់កម្មវិធីរុករករបស់លោកអ្នក នេះ\u200bមិនអាចធ្វើកម្មវិធីតាក់តែងអត្ថបទ ចំលងអត្ថបទយកដោយស្វ័យប្រវត្តបានឡើយ ។ សូមប្រើប្រាស់បន្សំ ឃីដូចនេះ (Ctrl/Cmd+C)។',
pasteMsg : 'សូមចំលងអត្ថបទទៅដាក់ក្នុងប្រអប់ដូចខាងក្រោមដោយប្រើប្រាស់ ឃី \u200b(<STRONG>Ctrl/Cmd+V</STRONG>) ហើយចុច <STRONG>OK</STRONG> ។',
securityMsg : 'Because of your browser security settings, the editor is not able to access your clipboard data directly. You are required to paste it again in this window.', // MISSING
pasteArea : 'Paste Area' // MISSING
},
pastefromword :
{
confirmCleanup : 'The text you want to paste seems to be copied from Word. Do you want to clean it before pasting?', // MISSING
toolbar : 'ចំលងដាក់ពី Word',
title : 'ចំលងដាក់ពី Word',
error : 'It was not possible to clean up the pasted data due to an internal error' // MISSING
},
pasteText :
{
button : 'ចំលងដាក់អត្ថបទធម្មតា',
title : 'ចំលងដាក់អត្ថបទធម្មតា'
},
templates :
{
button : 'ឯកសារគំរូ'
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
,
title : 'ឯកសារគំរូ របស់អត្ថន័យ',
options : 'Template Options', // MISSING
insertOption : 'Replace actual contents', // MISSING
selectPromptMsg : 'សូមជ្រើសរើសឯកសារគំរូ ដើម្បីបើកនៅក្នុងកម្មវិធីតាក់តែងអត្ថបទ<br>(អត្ថបទនឹងបាត់បង់):',
emptyListMsg : '(ពុំមានឯកសារគំរូត្រូវបានកំណត់)'
},
showBlocks : 'Show Blocks', // MISSING
stylesCombo :
{
label : 'ម៉ូត',
panelTitle : 'Formatting Styles', // MISSING
panelTitle1 : 'Block Styles', // MISSING
panelTitle2 : 'Inline Styles', // MISSING
panelTitle3 : 'Object Styles' // MISSING
},
format :
{
label : 'រចនា',
panelTitle : 'រចនា',
tag_p : 'Normal',
tag_pre : 'Formatted',
tag_address : 'Address',
tag_h1 : 'Heading 1',
tag_h2 : 'Heading 2',
tag_h3 : 'Heading 3',
tag_h4 : 'Heading 4',
tag_h5 : 'Heading 5',
tag_h6 : 'Heading 6',
tag_div : 'Normal (DIV)'
},
div :
{
title : 'Create Div Container', // MISSING
toolbar : 'Create Div Container', // MISSING
cssClassInputLabel : 'Stylesheet Classes', // MISSING
styleSelectLabel : 'Style', // MISSING
IdInputLabel : 'Id', // MISSING
languageCodeInputLabel : ' Language Code', // MISSING
inlineStyleInputLabel : 'Inline Style', // MISSING
advisoryTitleInputLabel : 'Advisory Title', // MISSING
langDirLabel : 'Language Direction', // MISSING
langDirLTRLabel : 'Left to Right (LTR)', // MISSING
langDirRTLLabel : 'Right to Left (RTL)', // MISSING
edit : 'Edit Div', // MISSING
remove : 'Remove Div' // MISSING
},
iframe :
{
title : 'IFrame Properties', // MISSING
toolbar : 'IFrame', // MISSING
noUrl : 'Please type the iframe URL', // MISSING
scrolling : 'Enable scrollbars', // MISSING
border : 'Show frame border' // MISSING
},
font :
{
label : 'ហ្
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
វុង',
voiceLabel : 'Font', // MISSING
panelTitle : 'ហ្វុង'
},
fontSize :
{
label : 'ទំហំ',
voiceLabel : 'Font Size', // MISSING
panelTitle : 'ទំហំ'
},
colorButton :
{
textColorTitle : 'ពណ៌អក្សរ',
bgColorTitle : 'ពណ៌ផ្ទៃខាងក្រោយ',
panelTitle : 'Colors', // MISSING
auto : 'ស្វ័យប្រវត្ត',
more : 'ពណ៌ផ្សេងទៀត..'
},
colors :
{
'000' : 'Black', // MISSING
'800000' : 'Maroon', // MISSING
'8B4513' : 'Saddle Brown', // MISSING
'2F4F4F' : 'Dark Slate Gray', // MISSING
'008080' : 'Teal', // MISSING
'000080' : 'Navy', // MISSING
'4B0082' : 'Indigo', // MISSING
'696969' : 'Dark Gray', // MISSING
'B22222' : 'Fire Brick', // MISSING
'A52A2A' : 'Brown', // MISSING
'DAA520' : 'Golden Rod', // MISSING
'006400' : 'Dark Green', // MISSING
'40E0D0' : 'Turquoise', // MISSING
'0000CD' : 'Medium Blue', // MISSING
'800080' : 'Purple', // MISSING
'808080' : 'Gray', // MISSING
'F00' : 'Red', // MISSING
'FF8C00' : 'Dark Orange', // MISSING
'FFD700' : 'Gold', // MISSING
'008000' : 'Green', // MISSING
'0FF' : 'Cyan', // MISSING
'00F' : 'Blue', // MISSING
'EE82EE' : 'Violet', // MISSING
'A9A9A9' : 'Dim Gray', // MISSING
'FFA07A' : 'Light Salmon', // MISSING
'FFA500' : 'Orange', // MISSING
'FFFF00' : 'Yellow', // MISSING
'00FF00' : 'Lime', // MISSING
'AFEEEE' : 'Pale Turquoise', // MISSING
'ADD8E6' : 'Light Blue', // MISSING
'DDA0DD' : 'Plum', // MISSING
'D3D3D3' : 'Light Grey', // MISSING
'FFF0F5' : 'Lavender Blush', // MISSING
'FAEBD7' : 'Antique White', // MISSING
'FFFFE0' : 'Light Yellow', // MISSING
'F0FFF0' : 'Honeydew', // MISSING
'F0FFFF' : 'Azure', // MISSING
'F0F8FF' : 'Alice Blue', // MISSING
'E6E6FA' : 'Lavender', // MISSING
'FFF' : 'White' // MISSING
},
scayt :
{
title : 'Spell Check As You Type', // MISSING
opera_title : 'Not supported by Opera', // MISSING
enable : 'Enable SCAY
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
T', // MISSING
disable : 'Disable SCAYT', // MISSING
about : 'About SCAYT', // MISSING
toggle : 'Toggle SCAYT', // MISSING
options : 'Options', // MISSING
langs : 'Languages', // MISSING
moreSuggestions : 'More suggestions', // MISSING
ignore : 'Ignore', // MISSING
ignoreAll : 'Ignore All', // MISSING
addWord : 'Add Word', // MISSING
emptyDic : 'Dictionary name should not be empty.', // MISSING
optionsTab : 'Options', // MISSING
allCaps : 'Ignore All-Caps Words', // MISSING
ignoreDomainNames : 'Ignore Domain Names', // MISSING
mixedCase : 'Ignore Words with Mixed Case', // MISSING
mixedWithDigits : 'Ignore Words with Numbers', // MISSING
languagesTab : 'Languages', // MISSING
dictionariesTab : 'Dictionaries', // MISSING
dic_field_name : 'Dictionary name', // MISSING
dic_create : 'Create', // MISSING
dic_restore : 'Restore', // MISSING
dic_delete : 'Delete', // MISSING
dic_rename : 'Rename', // MISSING
dic_info : 'Initially the User Dictionary is stored in a Cookie. However, Cookies are limited in size. When the User Dictionary grows to a point where it cannot be stored in a Cookie, then the dictionary may be stored on our server. To store your personal dictionary on our server you should specify a name for your dictionary. If you already have a stored dictionary, please type its name and click the Restore button.', // MISSING
aboutTab : 'About' // MISSING
},
about :
{
title : 'About CKEditor', // MISSING
dlgTitle : 'About CKEditor', // MISSING
help : 'Check $1 for help.', // MISSING
userGuide : 'CKEditor User\'s Guide', // MISSING
moreInfo : 'For licensing information please visit our web site:', // MISSING
copy : 'Copyright © $1. All rights reserved.' // MISSING
},
maximize : 'Maximize', // MISSING
minimize : 'Minimize', // MISSING
fakeobjects :
{
anchor : 'Anchor', // MISSING
flash : 'Flash Animation', // MISSING
iframe : 'IFrame', // MISSING
hiddenfield : 'Hidden Field', // MISSING
unknown
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
: 'Unknown Object' // MISSING
},
resize : 'Drag to resize', // MISSING
colordialog :
{
title : 'Select color', // MISSING
options : 'Color Options', // MISSING
highlight : 'Highlight', // MISSING
selected : 'Selected Color', // MISSING
clear : 'Clear' // MISSING
},
toolbarCollapse : 'Collapse Toolbar', // MISSING
toolbarExpand : 'Expand Toolbar', // MISSING
toolbarGroups :
{
document : 'Document', // MISSING
clipboard : 'Clipboard/Undo', // MISSING
editing : 'Editing', // MISSING
forms : 'Forms', // MISSING
basicstyles : 'Basic Styles', // MISSING
paragraph : 'Paragraph', // MISSING
links : 'Links', // MISSING
insert : 'Insert', // MISSING
styles : 'Styles', // MISSING
colors : 'Colors', // MISSING
tools : 'Tools' // MISSING
},
bidi :
{
ltr : 'Text direction from left to right', // MISSING
rtl : 'Text direction from right to left' // MISSING
},
docprops :
{
label : 'ការកំណត់ ឯកសារ',
title : 'ការកំណត់ ឯកសារ',
design : 'Design', // MISSING
meta : 'ទិន្នន័យមេ',
chooseColor : 'Choose', // MISSING
other : '<other>',
docTitle : 'ចំណងជើងទំព័រ',
charset : 'កំណត់លេខកូតភាសា',
charsetOther : 'កំណត់លេខកូតភាសាផ្សេងទៀត',
charsetASCII : 'ASCII', // MISSING
charsetCE : 'Central European', // MISSING
charsetCT : 'Chinese Traditional (Big5)', // MISSING
charsetCR : 'Cyrillic', // MISSING
charsetGR : 'Greek', // MISSING
charsetJP : 'Japanese', // MISSING
charsetKR : 'Korean', // MISSING
charsetTR : 'Turkish', // MISSING
charsetUN : 'Unicode (UTF-8)', // MISSING
charsetWE : 'Western European', // MISSING
docType : 'ប្រភេទក្បាលទំព័រ',
docTypeOther : 'ប្រភេទក្បាលទំព័រផ្សេងទៀត',
xhtmlDec : 'បញ្ជូល XHTML',
bgColor : 'ពណ៌ខាងក្រោម',
bgImage : 'URL រ�
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
��ស់រូបភាពខាងក្រោម',
bgFixed : 'ទំព័រក្រោមមិនប្តូរ',
txtColor : 'ពណ៌អក្សរ',
margin : 'ស៊ុមទំព័រ',
marginTop : 'លើ',
marginLeft : 'ឆ្វេង',
marginRight : 'ស្ដាំ',
marginBottom : 'ក្រោម',
metaKeywords : 'ពាក្យនៅក្នុងឯកសារ (ផ្តាច់ពីគ្នាដោយក្បៀស)',
metaDescription : 'សេចក្តីអត្ថាធិប្បាយអំពីឯកសារ',
metaAuthor : 'អ្នកនិពន្ធ',
metaCopyright : 'រក្សាសិទ្ធិ៏',
previewHtml : '<p>This is some <strong>sample text</strong>. You are using <a href="javascript:void(0)">CKEditor</a>.</p>' // MISSING
}
};
package io.ray.streaming.runtime.demo;
import io.ray.api.Ray;
import io.ray.streaming.api.context.StreamingContext;
import io.ray.streaming.api.function.impl.SinkFunction;
import io.ray.streaming.api.stream.DataStreamSource;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.Assert;
import org.testng.annotations.Test;
public class UnionStreamTest {
private static final Logger LOG = LoggerFactory.getLogger(UnionStreamTest.class);
@Test(timeOut = 60000)
public void testUnionStream() throws Exception {
Ray.shutdown();
String sinkFileName = "/tmp/testUnionStream.txt";
Files.deleteIfExists(Paths.get(sinkFileName));
StreamingContext context = StreamingContext.buildContext();
DataStreamSource<Integer> streamSource1 =
DataStreamSource.fromCollection(context, Arrays.asList(1, 1));
DataStreamSource<Integer> streamSource2 =
DataStreamSource.fromCollection(context, Arrays.asList(1, 1));
DataStreamSource<In
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
teger> streamSource3 =
DataStreamSource.fromCollection(context, Arrays.asList(1, 1));
streamSource1
.union(streamSource2, streamSource3)
.sink((SinkFunction<Integer>) value -> {
LOG.info("UnionStreamTest, sink: {}", value);
try {
if (!Files.exists(Paths.get(sinkFileName))) {
Files.createFile(Paths.get(sinkFileName));
}
Files.write(Paths.get(sinkFileName), value.toString().getBytes(),
StandardOpenOption.APPEND);
} catch (IOException e) {
throw new RuntimeException(e);
}
});
context.execute("UnionStreamTest");
int sleptTime = 0;
TimeUnit.SECONDS.sleep(3);
while (true) {
if (Files.exists(Paths.get(sinkFileName))) {
TimeUnit.SECONDS.sleep(3);
String text = String.join(", ", Files.readAllLines(Paths.get(sinkFileName)));
Assert.assertEquals(text, StringUtils.repeat("1", 6));
LOG.info("Execution succeed");
break;
}
sleptTime += 1;
if (sleptTime >= 60) {
throw new RuntimeException("Execution not finished");
}
LOG.info("Wait finish...");
TimeUnit.SECONDS.sleep(1);
}
context.stop();
LOG.info("HybridStreamTest succeed");
}
}
issuerepo: golang/go
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _NodeCollapseOutlined = _interopRequireDefault(require('./lib/icons/NodeCollapseOutlined'));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
var _default = _NodeCollapseOutlined;
exports.default = _default;
module.exports = _default;
#!/usr/bin/ruby
x,y=gets.split.map(&:to_i)
w=[0,3,16,34,55,80,108,139,172,208,245,285,327].take_while{|e|(y+3)/6>=e}.size-1
puts (w==0?'C':['N','NNE','NE','ENE','E','ESE','SE','SSE','S','SSW','SW','WSW','W','WNW','NW','NNW'][(x+112)%3600/225])+" #{w}"
//>>built
define(
//begin v1.x content
({
w
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
idgetLabel: "Wsadowe sprawdzanie pisowni",
unfound: "Nie znaleziono",
skip: "Pomiń",
skipAll: "Pomiń wszystko",
toDic: "Dodaj do słownika",
suggestions: "Propozycje",
replace: "Zastąp",
replaceWith: "Zastąp przez",
replaceAll: "Zastąp wszystko",
cancel: "Anuluj",
msg: "Nie znaleziono błędów pisowni",
iSkip: "Pomiń tę pozycję",
iSkipAll: "Pomiń wszystkie pozycje podobne do tej",
iMsg: "Brak propozycji pisowni"
})
//end v1.x content
);
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2014 Christoph Hellwig.
*/
#undef TRACE_SYSTEM
#define TRACE_SYSTEM nfsd
#if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
#define _NFSD_TRACE_H
#include <linux/tracepoint.h>
#include "export.h"
#include "nfsfh.h"
TRACE_EVENT(nfsd_compound,
TP_PROTO(const struct svc_rqst *rqst,
u32 args_opcnt),
TP_ARGS(rqst, args_opcnt),
TP_STRUCT__entry(
__field(u32, xid)
__field(u32, args_opcnt)
),
TP_fast_assign(
__entry->xid = be32_to_cpu(rqst->rq_xid);
__entry->args_opcnt = args_opcnt;
),
TP_printk("xid=0x%08x opcnt=%u",
__entry->xid, __entry->args_opcnt)
)
TRACE_EVENT(nfsd_compound_status,
TP_PROTO(u32 args_opcnt,
u32 resp_opcnt,
__be32 status,
const char *name),
TP_ARGS(args_opcnt, resp_opcnt, status, name),
TP_STRUCT__entry(
__field(u32, args_opcnt)
__field(u32, resp_opcnt)
__field(int, status)
__string(name, name)
),
TP_fast_assign(
__entry->args_opcnt = args_opcnt;
__entry->resp_opcnt = resp_opcnt;
__entry->status = be32_to_cpu(status);
__assign_str(name, name);
),
TP_printk("op=%u/%u %s status=%d",
__entry->resp_opcnt, __entry->args_opcnt,
__get_str(name), __entry->status)
)
DECLARE_EVENT_CLASS(nfsd_fh_err_class,
TP_PROTO(struct svc_rqst *rqstp,
struct svc_fh *fhp,
int status),
TP_ARGS(rqstp, fhp, status),
TP_STRUCT__entry(
__field(u32, xid)
__field(u32, fh_hash)
__field(int, status)
),
TP_fast_assign(
__entry->xid = be32_to_cpu(rqstp->rq_xid);
__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
__entry->s
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
tatus = status;
),
TP_printk("xid=0x%08x fh_hash=0x%08x status=%d",
__entry->xid, __entry->fh_hash,
__entry->status)
)
#define DEFINE_NFSD_FH_ERR_EVENT(name) \
DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \
TP_PROTO(struct svc_rqst *rqstp, \
struct svc_fh *fhp, \
int status), \
TP_ARGS(rqstp, fhp, status))
DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport);
DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle);
TRACE_EVENT(nfsd_exp_find_key,
TP_PROTO(const struct svc_expkey *key,
int status),
TP_ARGS(key, status),
TP_STRUCT__entry(
__field(int, fsidtype)
__array(u32, fsid, 6)
__string(auth_domain, key->ek_client->name)
__field(int, status)
),
TP_fast_assign(
__entry->fsidtype = key->ek_fsidtype;
memcpy(__entry->fsid, key->ek_fsid, 4*6);
__assign_str(auth_domain, key->ek_client->name);
__entry->status = status;
),
TP_printk("fsid=%x::%s domain=%s status=%d",
__entry->fsidtype,
__print_array(__entry->fsid, 6, 4),
__get_str(auth_domain),
__entry->status
)
);
TRACE_EVENT(nfsd_expkey_update,
TP_PROTO(const struct svc_expkey *key, const char *exp_path),
TP_ARGS(key, exp_path),
TP_STRUCT__entry(
__field(int, fsidtype)
__array(u32, fsid, 6)
__string(auth_domain, key->ek_client->name)
__string(path, exp_path)
__field(bool, cache)
),
TP_fast_assign(
__entry->fsidtype = key->ek_fsidtype;
memcpy(__entry->fsid, key->ek_fsid, 4*6);
__assign_str(auth_domain, key->ek_client->name);
__assign_str(path, exp_path);
__entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
),
TP_printk("fsid=%x::%s domain=%s path=%s cache=%s",
__entry->fsidtype,
__print_array(__entry->fsid, 6, 4),
__get_str(auth_domain),
__get_str(path),
__entry->cache ? "pos" : "neg"
)
);
TRACE_EVENT(nfsd_exp_get_by_name,
TP_PROTO(const struct svc_export *key,
int status),
TP_ARGS(key, status),
TP_STRUCT__entry(
__string(path, key->ex_path.dentry->d_name.name)
__string(auth_domain, key->ex_client->name)
__field(int, status)
),
TP_fast_assign(
__assign_str(p
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ath, key->ex_path.dentry->d_name.name);
__assign_str(auth_domain, key->ex_client->name);
__entry->status = status;
),
TP_printk("path=%s domain=%s status=%d",
__get_str(path),
__get_str(auth_domain),
__entry->status
)
);
TRACE_EVENT(nfsd_export_update,
TP_PROTO(const struct svc_export *key),
TP_ARGS(key),
TP_STRUCT__entry(
__string(path, key->ex_path.dentry->d_name.name)
__string(auth_domain, key->ex_client->name)
__field(bool, cache)
),
TP_fast_assign(
__assign_str(path, key->ex_path.dentry->d_name.name);
__assign_str(auth_domain, key->ex_client->name);
__entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
),
TP_printk("path=%s domain=%s cache=%s",
__get_str(path),
__get_str(auth_domain),
__entry->cache ? "pos" : "neg"
)
);
DECLARE_EVENT_CLASS(nfsd_io_class,
TP_PROTO(struct svc_rqst *rqstp,
struct svc_fh *fhp,
loff_t offset,
unsigned long len),
TP_ARGS(rqstp, fhp, offset, len),
TP_STRUCT__entry(
__field(u32, xid)
__field(u32, fh_hash)
__field(loff_t, offset)
__field(unsigned long, len)
),
TP_fast_assign(
__entry->xid = be32_to_cpu(rqstp->rq_xid);
__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
__entry->offset = offset;
__entry->len = len;
),
TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld len=%lu",
__entry->xid, __entry->fh_hash,
__entry->offset, __entry->len)
)
#define DEFINE_NFSD_IO_EVENT(name) \
DEFINE_EVENT(nfsd_io_class, nfsd_##name, \
TP_PROTO(struct svc_rqst *rqstp, \
struct svc_fh *fhp, \
loff_t offset, \
unsigned long len), \
TP_ARGS(rqstp, fhp, offset, len))
DEFINE_NFSD_IO_EVENT(read_start);
DEFINE_NFSD_IO_EVENT(read_splice);
DEFINE_NFSD_IO_EVENT(read_vector);
DEFINE_NFSD_IO_EVENT(read_io_done);
DEFINE_NFSD_IO_EVENT(read_done);
DEFINE_NFSD_IO_EVENT(write_start);
DEFINE_NFSD_IO_EVENT(write_opened);
DEFINE_NFSD_IO_EVENT(write_io_done);
DEFINE_NFSD_IO_EVENT(write_done);
DECLARE_EVENT_CLASS(nfsd_err_class,
TP_PROTO(struct svc_rqst *rqstp,
struct svc_fh *fhp,
loff_t offset,
int status),
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
TP_ARGS(rqstp, fhp, offset, status),
TP_STRUCT__entry(
__field(u32, xid)
__field(u32, fh_hash)
__field(loff_t, offset)
__field(int, status)
),
TP_fast_assign(
__entry->xid = be32_to_cpu(rqstp->rq_xid);
__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
__entry->offset = offset;
__entry->status = status;
),
TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d",
__entry->xid, __entry->fh_hash,
__entry->offset, __entry->status)
)
#define DEFINE_NFSD_ERR_EVENT(name) \
DEFINE_EVENT(nfsd_err_class, nfsd_##name, \
TP_PROTO(struct svc_rqst *rqstp, \
struct svc_fh *fhp, \
loff_t offset, \
int len), \
TP_ARGS(rqstp, fhp, offset, len))
DEFINE_NFSD_ERR_EVENT(read_err);
DEFINE_NFSD_ERR_EVENT(write_err);
#include "state.h"
#include "filecache.h"
#include "vfs.h"
DECLARE_EVENT_CLASS(nfsd_stateid_class,
TP_PROTO(stateid_t *stp),
TP_ARGS(stp),
TP_STRUCT__entry(
__field(u32, cl_boot)
__field(u32, cl_id)
__field(u32, si_id)
__field(u32, si_generation)
),
TP_fast_assign(
__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
__entry->cl_id = stp->si_opaque.so_clid.cl_id;
__entry->si_id = stp->si_opaque.so_id;
__entry->si_generation = stp->si_generation;
),
TP_printk("client %08x:%08x stateid %08x:%08x",
__entry->cl_boot,
__entry->cl_id,
__entry->si_id,
__entry->si_generation)
)
#define DEFINE_STATEID_EVENT(name) \
DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \
TP_PROTO(stateid_t *stp), \
TP_ARGS(stp))
DEFINE_STATEID_EVENT(layoutstate_alloc);
DEFINE_STATEID_EVENT(layoutstate_unhash);
DEFINE_STATEID_EVENT(layoutstate_free);
DEFINE_STATEID_EVENT(layout_get_lookup_fail);
DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
DEFINE_STATEID_EVENT(layout_return_lookup_fail);
DEFINE_STATEID_EVENT(layout_recall);
DEFINE_STATEID_EVENT(layout_recall_done);
DEFINE_STATEID_EVENT(layout_recall_fail);
DEFINE_STATEID_EVENT(layout_recall_release);
DEFINE_STATEID_EVENT(deleg_open);
DEFINE_STATEID_EVENT(deleg_none);
DEFINE_STATEID_EVENT(deleg_break);
DEFINE_STATEID_EV
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ENT(deleg_recall);
DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
TP_PROTO(u32 seqid, const stateid_t *stp),
TP_ARGS(seqid, stp),
TP_STRUCT__entry(
__field(u32, seqid)
__field(u32, cl_boot)
__field(u32, cl_id)
__field(u32, si_id)
__field(u32, si_generation)
),
TP_fast_assign(
__entry->seqid = seqid;
__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
__entry->cl_id = stp->si_opaque.so_clid.cl_id;
__entry->si_id = stp->si_opaque.so_id;
__entry->si_generation = stp->si_generation;
),
TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
__entry->seqid, __entry->cl_boot, __entry->cl_id,
__entry->si_id, __entry->si_generation)
)
#define DEFINE_STATESEQID_EVENT(name) \
DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
TP_PROTO(u32 seqid, const stateid_t *stp), \
TP_ARGS(seqid, stp))
DEFINE_STATESEQID_EVENT(preprocess);
DEFINE_STATESEQID_EVENT(open_confirm);
DECLARE_EVENT_CLASS(nfsd_clientid_class,
TP_PROTO(const clientid_t *clid),
TP_ARGS(clid),
TP_STRUCT__entry(
__field(u32, cl_boot)
__field(u32, cl_id)
),
TP_fast_assign(
__entry->cl_boot = clid->cl_boot;
__entry->cl_id = clid->cl_id;
),
TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
)
#define DEFINE_CLIENTID_EVENT(name) \
DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
TP_PROTO(const clientid_t *clid), \
TP_ARGS(clid))
DEFINE_CLIENTID_EVENT(expired);
DEFINE_CLIENTID_EVENT(purged);
DEFINE_CLIENTID_EVENT(renew);
DEFINE_CLIENTID_EVENT(stale);
DECLARE_EVENT_CLASS(nfsd_net_class,
TP_PROTO(const struct nfsd_net *nn),
TP_ARGS(nn),
TP_STRUCT__entry(
__field(unsigned long long, boot_time)
),
TP_fast_assign(
__entry->boot_time = nn->boot_time;
),
TP_printk("boot_time=%16llx", __entry->boot_time)
)
#define DEFINE_NET_EVENT(name) \
DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
TP_PROTO(const struct nfsd_net *nn), \
TP_ARGS(nn))
DEFINE_NET_EVENT(grace_start);
DEFINE_NET_EVENT(grace_complete);
DECLARE_EVENT_CLASS(nfsd_clid_class,
TP_PROTO(const struct nfsd_net *nn,
unsigned int namele
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
n,
const unsigned char *namedata),
TP_ARGS(nn, namelen, namedata),
TP_STRUCT__entry(
__field(unsigned long long, boot_time)
__field(unsigned int, namelen)
__dynamic_array(unsigned char, name, namelen)
),
TP_fast_assign(
__entry->boot_time = nn->boot_time;
__entry->namelen = namelen;
memcpy(__get_dynamic_array(name), namedata, namelen);
),
TP_printk("boot_time=%16llx nfs4_clientid=%.*s",
__entry->boot_time, __entry->namelen, __get_str(name))
)
#define DEFINE_CLID_EVENT(name) \
DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
TP_PROTO(const struct nfsd_net *nn, \
unsigned int namelen, \
const unsigned char *namedata), \
TP_ARGS(nn, namelen, namedata))
DEFINE_CLID_EVENT(find);
DEFINE_CLID_EVENT(reclaim);
TRACE_EVENT(nfsd_clid_inuse_err,
TP_PROTO(const struct nfs4_client *clp),
TP_ARGS(clp),
TP_STRUCT__entry(
__field(u32, cl_boot)
__field(u32, cl_id)
__array(unsigned char, addr, sizeof(struct sockaddr_in6))
__field(unsigned int, namelen)
__dynamic_array(unsigned char, name, clp->cl_name.len)
),
TP_fast_assign(
__entry->cl_boot = clp->cl_clientid.cl_boot;
__entry->cl_id = clp->cl_clientid.cl_id;
memcpy(__entry->addr, &clp->cl_addr,
sizeof(struct sockaddr_in6));
__entry->namelen = clp->cl_name.len;
memcpy(__get_dynamic_array(name), clp->cl_name.data,
clp->cl_name.len);
),
TP_printk("nfs4_clientid %.*s already in use by %pISpc, client %08x:%08x",
__entry->namelen, __get_str(name), __entry->addr,
__entry->cl_boot, __entry->cl_id)
)
TRACE_DEFINE_ENUM(NFSD_FILE_HASHED);
TRACE_DEFINE_ENUM(NFSD_FILE_PENDING);
TRACE_DEFINE_ENUM(NFSD_FILE_BREAK_READ);
TRACE_DEFINE_ENUM(NFSD_FILE_BREAK_WRITE);
TRACE_DEFINE_ENUM(NFSD_FILE_REFERENCED);
#define show_nf_flags(val) \
__print_flags(val, "|", \
{ 1 << NFSD_FILE_HASHED, "HASHED" }, \
{ 1 << NFSD_FILE_PENDING, "PENDING" }, \
{ 1 << NFSD_FILE_BREAK_READ, "BREAK_READ" }, \
{ 1 << NFSD_FILE_BREAK_WRITE, "BREAK_WRITE" }, \
{ 1 << NFSD_FILE_REFERENCED, "REFERENCED"})
/* FIXME: This should prob
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
ably be fleshed out in the future. */
#define show_nf_may(val) \
__print_flags(val, "|", \
{ NFSD_MAY_READ, "READ" }, \
{ NFSD_MAY_WRITE, "WRITE" }, \
{ NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" })
DECLARE_EVENT_CLASS(nfsd_file_class,
TP_PROTO(struct nfsd_file *nf),
TP_ARGS(nf),
TP_STRUCT__entry(
__field(unsigned int, nf_hashval)
__field(void *, nf_inode)
__field(int, nf_ref)
__field(unsigned long, nf_flags)
__field(unsigned char, nf_may)
__field(struct file *, nf_file)
),
TP_fast_assign(
__entry->nf_hashval = nf->nf_hashval;
__entry->nf_inode = nf->nf_inode;
__entry->nf_ref = refcount_read(&nf->nf_ref);
__entry->nf_flags = nf->nf_flags;
__entry->nf_may = nf->nf_may;
__entry->nf_file = nf->nf_file;
),
TP_printk("hash=0x%x inode=0x%p ref=%d flags=%s may=%s file=%p",
__entry->nf_hashval,
__entry->nf_inode,
__entry->nf_ref,
show_nf_flags(__entry->nf_flags),
show_nf_may(__entry->nf_may),
__entry->nf_file)
)
#define DEFINE_NFSD_FILE_EVENT(name) \
DEFINE_EVENT(nfsd_file_class, name, \
TP_PROTO(struct nfsd_file *nf), \
TP_ARGS(nf))
DEFINE_NFSD_FILE_EVENT(nfsd_file_alloc);
DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final);
DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_release_locked);
TRACE_EVENT(nfsd_file_acquire,
TP_PROTO(struct svc_rqst *rqstp, unsigned int hash,
struct inode *inode, unsigned int may_flags,
struct nfsd_file *nf, __be32 status),
TP_ARGS(rqstp, hash, inode, may_flags, nf, status),
TP_STRUCT__entry(
__field(u32, xid)
__field(unsigned int, hash)
__field(void *, inode)
__field(unsigned int, may_flags)
__field(int, nf_ref)
__field(unsigned long, nf_flags)
__field(unsigned char, nf_may)
__field(struct file *, nf_file)
__field(u32, status)
),
TP_fast_assign(
__entry->xid = be32_to_cpu(rqstp->rq_xid);
__entry->hash = hash;
__entry->inode = inode;
__entry->may_flags = may_flags;
__entry->nf_ref = nf ? refcount_read(&nf->nf_ref)
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
: 0;
__entry->nf_flags = nf ? nf->nf_flags : 0;
__entry->nf_may = nf ? nf->nf_may : 0;
__entry->nf_file = nf ? nf->nf_file : NULL;
__entry->status = be32_to_cpu(status);
),
TP_printk("xid=0x%x hash=0x%x inode=0x%p may_flags=%s ref=%d nf_flags=%s nf_may=%s nf_file=0x%p status=%u",
__entry->xid, __entry->hash, __entry->inode,
show_nf_may(__entry->may_flags), __entry->nf_ref,
show_nf_flags(__entry->nf_flags),
show_nf_may(__entry->nf_may), __entry->nf_file,
__entry->status)
);
DECLARE_EVENT_CLASS(nfsd_file_search_class,
TP_PROTO(struct inode *inode, unsigned int hash, int found),
TP_ARGS(inode, hash, found),
TP_STRUCT__entry(
__field(struct inode *, inode)
__field(unsigned int, hash)
__field(int, found)
),
TP_fast_assign(
__entry->inode = inode;
__entry->hash = hash;
__entry->found = found;
),
TP_printk("hash=0x%x inode=0x%p found=%d", __entry->hash,
__entry->inode, __entry->found)
);
#define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \
DEFINE_EVENT(nfsd_file_search_class, name, \
TP_PROTO(struct inode *inode, unsigned int hash, int found), \
TP_ARGS(inode, hash, found))
DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync);
DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode);
DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_is_cached);
TRACE_EVENT(nfsd_file_fsnotify_handle_event,
TP_PROTO(struct inode *inode, u32 mask),
TP_ARGS(inode, mask),
TP_STRUCT__entry(
__field(struct inode *, inode)
__field(unsigned int, nlink)
__field(umode_t, mode)
__field(u32, mask)
),
TP_fast_assign(
__entry->inode = inode;
__entry->nlink = inode->i_nlink;
__entry->mode = inode->i_mode;
__entry->mask = mask;
),
TP_printk("inode=0x%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
__entry->nlink, __entry->mode, __entry->mask)
);
#include "cache.h"
TRACE_DEFINE_ENUM(RC_DROPIT);
TRACE_DEFINE_ENUM(RC_REPLY);
TRACE_DEFINE_ENUM(RC_DOIT);
#define show_drc_retval(x) \
__print_symbolic(x, \
{ RC_DROPIT, "DROPIT" }, \
{ RC_REPLY, "REPLY" }, \
{ RC_
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
DOIT, "DOIT" })
TRACE_EVENT(nfsd_drc_found,
TP_PROTO(
const struct nfsd_net *nn,
const struct svc_rqst *rqstp,
int result
),
TP_ARGS(nn, rqstp, result),
TP_STRUCT__entry(
__field(unsigned long long, boot_time)
__field(unsigned long, result)
__field(u32, xid)
),
TP_fast_assign(
__entry->boot_time = nn->boot_time;
__entry->result = result;
__entry->xid = be32_to_cpu(rqstp->rq_xid);
),
TP_printk("boot_time=%16llx xid=0x%08x result=%s",
__entry->boot_time, __entry->xid,
show_drc_retval(__entry->result))
);
TRACE_EVENT(nfsd_drc_mismatch,
TP_PROTO(
const struct nfsd_net *nn,
const struct svc_cacherep *key,
const struct svc_cacherep *rp
),
TP_ARGS(nn, key, rp),
TP_STRUCT__entry(
__field(unsigned long long, boot_time)
__field(u32, xid)
__field(u32, cached)
__field(u32, ingress)
),
TP_fast_assign(
__entry->boot_time = nn->boot_time;
__entry->xid = be32_to_cpu(key->c_key.k_xid);
__entry->cached = (__force u32)key->c_key.k_csum;
__entry->ingress = (__force u32)rp->c_key.k_csum;
),
TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
__entry->boot_time, __entry->xid, __entry->cached,
__entry->ingress)
);
TRACE_EVENT(nfsd_cb_args,
TP_PROTO(
const struct nfs4_client *clp,
const struct nfs4_cb_conn *conn
),
TP_ARGS(clp, conn),
TP_STRUCT__entry(
__field(u32, cl_boot)
__field(u32, cl_id)
__field(u32, prog)
__field(u32, ident)
__array(unsigned char, addr, sizeof(struct sockaddr_in6))
),
TP_fast_assign(
__entry->cl_boot = clp->cl_clientid.cl_boot;
__entry->cl_id = clp->cl_clientid.cl_id;
__entry->prog = conn->cb_prog;
__entry->ident = conn->cb_ident;
memcpy(__entry->addr, &conn->cb_addr,
sizeof(struct sockaddr_in6));
),
TP_printk("client %08x:%08x callback addr=%pISpc prog=%u ident=%u",
__entry->cl_boot, __entry->cl_id,
__entry->addr, __entry->prog, __entry->ident)
);
TRACE_EVENT(nfsd_cb_nodelegs,
TP_PROTO(const struct nfs4_client *clp),
TP_ARGS(clp),
TP_STRUCT__entry(
__field(u32, cl_boot)
_
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
_field(u32, cl_id)
),
TP_fast_assign(
__entry->cl_boot = clp->cl_clientid.cl_boot;
__entry->cl_id = clp->cl_clientid.cl_id;
),
TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
)
TRACE_DEFINE_ENUM(NFSD4_CB_UP);
TRACE_DEFINE_ENUM(NFSD4_CB_UNKNOWN);
TRACE_DEFINE_ENUM(NFSD4_CB_DOWN);
TRACE_DEFINE_ENUM(NFSD4_CB_FAULT);
#define show_cb_state(val) \
__print_symbolic(val, \
{ NFSD4_CB_UP, "UP" }, \
{ NFSD4_CB_UNKNOWN, "UNKNOWN" }, \
{ NFSD4_CB_DOWN, "DOWN" }, \
{ NFSD4_CB_FAULT, "FAULT"})
DECLARE_EVENT_CLASS(nfsd_cb_class,
TP_PROTO(const struct nfs4_client *clp),
TP_ARGS(clp),
TP_STRUCT__entry(
__field(unsigned long, state)
__field(u32, cl_boot)
__field(u32, cl_id)
__array(unsigned char, addr, sizeof(struct sockaddr_in6))
),
TP_fast_assign(
__entry->state = clp->cl_cb_state;
__entry->cl_boot = clp->cl_clientid.cl_boot;
__entry->cl_id = clp->cl_clientid.cl_id;
memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr,
sizeof(struct sockaddr_in6));
),
TP_printk("addr=%pISpc client %08x:%08x state=%s",
__entry->addr, __entry->cl_boot, __entry->cl_id,
show_cb_state(__entry->state))
);
#define DEFINE_NFSD_CB_EVENT(name) \
DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \
TP_PROTO(const struct nfs4_client *clp), \
TP_ARGS(clp))
DEFINE_NFSD_CB_EVENT(setup);
DEFINE_NFSD_CB_EVENT(state);
DEFINE_NFSD_CB_EVENT(shutdown);
TRACE_EVENT(nfsd_cb_setup_err,
TP_PROTO(
const struct nfs4_client *clp,
long error
),
TP_ARGS(clp, error),
TP_STRUCT__entry(
__field(long, error)
__field(u32, cl_boot)
__field(u32, cl_id)
__array(unsigned char, addr, sizeof(struct sockaddr_in6))
),
TP_fast_assign(
__entry->error = error;
__entry->cl_boot = clp->cl_clientid.cl_boot;
__entry->cl_id = clp->cl_clientid.cl_id;
memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr,
sizeof(struct sockaddr_in6));
),
TP_printk("addr=%pISpc client %08x:%08x error=%ld",
__entry->addr, __entry->cl_boot, __entry->cl_id, __entry->error)
);
TRACE_EVENT(nfsd_cb_work,
TP_PROTO(
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
const struct nfs4_client *clp,
const char *procedure
),
TP_ARGS(clp, procedure),
TP_STRUCT__entry(
__field(u32, cl_boot)
__field(u32, cl_id)
__string(procedure, procedure)
__array(unsigned char, addr, sizeof(struct sockaddr_in6))
),
TP_fast_assign(
__entry->cl_boot = clp->cl_clientid.cl_boot;
__entry->cl_id = clp->cl_clientid.cl_id;
__assign_str(procedure, procedure)
memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr,
sizeof(struct sockaddr_in6));
),
TP_printk("addr=%pISpc client %08x:%08x procedure=%s",
__entry->addr, __entry->cl_boot, __entry->cl_id,
__get_str(procedure))
);
TRACE_EVENT(nfsd_cb_done,
TP_PROTO(
const struct nfs4_client *clp,
int status
),
TP_ARGS(clp, status),
TP_STRUCT__entry(
__field(u32, cl_boot)
__field(u32, cl_id)
__field(int, status)
__array(unsigned char, addr, sizeof(struct sockaddr_in6))
),
TP_fast_assign(
__entry->cl_boot = clp->cl_clientid.cl_boot;
__entry->cl_id = clp->cl_clientid.cl_id;
__entry->status = status;
memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr,
sizeof(struct sockaddr_in6));
),
TP_printk("addr=%pISpc client %08x:%08x status=%d",
__entry->addr, __entry->cl_boot, __entry->cl_id,
__entry->status)
);
#endif /* _NFSD_TRACE_H */
#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .
#define TRACE_INCLUDE_FILE trace
#include <trace/define_trace.h>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>ActivePerspectiveName</key>
<string>Project</string>
<key>AllowedModules</key>
<array>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>PBXSmartGroupTreeModule</string>
<key>Name</key>
<string>Groups and Files Outline View</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>PBXNavigatorGr
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
oup</string>
<key>Name</key>
<string>Editor</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>XCTaskListModule</string>
<key>Name</key>
<string>Task List</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>XCDetailModule</string>
<key>Name</key>
<string>File and Smart Group Detail Viewer</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>1</string>
<key>Module</key>
<string>PBXBuildResultsModule</string>
<key>Name</key>
<string>Detailed Build Results Viewer</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>1</string>
<key>Module</key>
<string>PBXProjectFindModule</string>
<key>Name</key>
<string>Project Batch Find Tool</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>XCProjectFormatConflictsModule</string>
<key>Name</key>
<string>Project Format Conflicts List</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>PBXBookmarksModule</string>
<key>Name</key>
<string>Bookmarks Tool</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>PBXClassBrowserModule</string>
<key>Name</key>
<string>Class Browser</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>PBXCVSModule</string>
<key>Name</key>
<string>Source Code Control Tool</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></s
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
tring>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>PBXDebugBreakpointsModule</string>
<key>Name</key>
<string>Debug Breakpoints Tool</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>XCDockableInspector</string>
<key>Name</key>
<string>Inspector</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>PBXOpenQuicklyModule</string>
<key>Name</key>
<string>Open Quickly Tool</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>1</string>
<key>Module</key>
<string>PBXDebugSessionModule</string>
<key>Name</key>
<string>Debugger</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>1</string>
<key>Module</key>
<string>PBXDebugCLIModule</string>
<key>Name</key>
<string>Debug Console</string>
</dict>
<dict>
<key>BundleLoadPath</key>
<string></string>
<key>MaxInstances</key>
<string>n</string>
<key>Module</key>
<string>XCSnapshotModule</string>
<key>Name</key>
<string>Snapshots Tool</string>
</dict>
</array>
<key>BundlePath</key>
<string>/Developer32/Library/PrivateFrameworks/DevToolsInterface.framework/Resources</string>
<key>Description</key>
<string>DefaultDescriptionKey</string>
<key>DockingSystemVisible</key>
<false/>
<key>Extension</key>
<string>mode1v3</string>
<key>FavBarConfig</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>8EA3E1E61128601100889321</string>
<key>XCBarModuleItemNames</key>
<dict/>
<key>XCBarModuleItems</key>
<array/>
</dict>
<key>FirstTimeWindowDisplayed</key>
<false/>
<key>Identifier</key>
<string>com.apple.perspectives.project.mode1v3</string>
<key>MajorVersion</key>
<integer>33</integer>
<key>MinorVersion</key>
<integer>0
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
</integer>
<key>Name</key>
<string>Default</string>
<key>Notifications</key>
<array/>
<key>OpenEditors</key>
<array/>
<key>PerspectiveWidths</key>
<array>
<integer>-1</integer>
<integer>-1</integer>
</array>
<key>Perspectives</key>
<array>
<dict>
<key>ChosenToolbarItems</key>
<array>
<string>active-combo-popup</string>
<string>action</string>
<string>NSToolbarFlexibleSpaceItem</string>
<string>debugger-enable-breakpoints</string>
<string>build-and-go</string>
<string>com.apple.ide.PBXToolbarStopButton</string>
<string>get-info</string>
<string>NSToolbarFlexibleSpaceItem</string>
<string>com.apple.pbx.toolbar.searchfield</string>
</array>
<key>ControllerClassBaseName</key>
<string></string>
<key>IconName</key>
<string>WindowOfProjectWithEditor</string>
<key>Identifier</key>
<string>perspective.project</string>
<key>IsVertical</key>
<false/>
<key>Layout</key>
<array>
<dict>
<key>ContentConfiguration</key>
<dict>
<key>PBXBottomSmartGroupGIDs</key>
<array>
<string>1C37FBAC04509CD000000102</string>
<string>1C37FAAC04509CD000000102</string>
<string>1C37FABC05509CD000000102</string>
<string>1C37FABC05539CD112110102</string>
<string>E2644B35053B69B200211256</string>
<string>1C37FABC04509CD000100104</string>
<string>1CC0EA4004350EF90044410B</string>
<string>1CC0EA4004350EF90041110B</string>
</array>
<key>PBXProjectModuleGUID</key>
<string>1CE0B1FE06471DED0097A5F4</string>
<key>PBXProjectModuleLabel</key>
<string>Files</string>
<key>PBXProjectStructureProvided</key>
<string>yes</string>
<key>PBXSmartGroupTreeModuleColumnData</key>
<dict>
<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
<array>
<real>186</real>
</array>
<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
<array>
<string>MainColumn</string>
</array>
</dict>
<key>PBXSma
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
rtGroupTreeModuleOutlineStateKey_v7</key>
<dict>
<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
<array>
<string>29B97314FDCFA39411CA2CEA</string>
<string>29B97317FDCFA39411CA2CEA</string>
<string>8E7D47441128F52000B184C5</string>
<string>1C37FBAC04509CD000000102</string>
<string>1C37FABC05509CD000000102</string>
</array>
<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
<array>
<array>
<integer>5</integer>
<integer>4</integer>
<integer>2</integer>
<integer>0</integer>
</array>
</array>
<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
<string>{{0, 0}, {186, 557}}</string>
</dict>
<key>PBXTopSmartGroupGIDs</key>
<array/>
<key>XCIncludePerspectivesSwitch</key>
<true/>
<key>XCSharingToken</key>
<string>com.apple.Xcode.GFSharingToken</string>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>Frame</key>
<string>{{0, 0}, {203, 575}}</string>
<key>GroupTreeTableConfiguration</key>
<array>
<string>MainColumn</string>
<real>186</real>
</array>
<key>RubberWindowFrame</key>
<string>311 160 796 616 0 0 1920 1058 </string>
</dict>
<key>Module</key>
<string>PBXSmartGroupTreeModule</string>
<key>Proportion</key>
<string>203pt</string>
</dict>
<dict>
<key>Dock</key>
<array>
<dict>
<key>ContentConfiguration</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>1CE0B20306471E060097A5F4</string>
<key>PBXProjectModuleLabel</key>
<string>main.m</string>
<key>PBXSplitModuleInNavigatorKey</key>
<dict>
<key>Split0</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>1CE0B20406471E060097A5F4</string>
<key>PBXProjectModuleLabel</key>
<string>main.m</string>
<key>_his
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
toryCapacity</key>
<integer>0</integer>
<key>bookmark</key>
<string>8EE2C169139AA0F6007E4557</string>
<key>history</key>
<array>
<string>8EA3E27C112862FC00889321</string>
<string>8E312744113440B00096DE87</string>
<string>8E25E54B1390143500962DEF</string>
</array>
</dict>
<key>SplitCount</key>
<string>1</string>
</dict>
<key>StatusBarVisibility</key>
<true/>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>Frame</key>
<string>{{0, 0}, {588, 0}}</string>
<key>RubberWindowFrame</key>
<string>311 160 796 616 0 0 1920 1058 </string>
</dict>
<key>Module</key>
<string>PBXNavigatorGroup</string>
<key>Proportion</key>
<string>0pt</string>
</dict>
<dict>
<key>BecomeActive</key>
<true/>
<key>ContentConfiguration</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>1CE0B20506471E060097A5F4</string>
<key>PBXProjectModuleLabel</key>
<string>Detail</string>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>Frame</key>
<string>{{0, 5}, {588, 570}}</string>
<key>RubberWindowFrame</key>
<string>311 160 796 616 0 0 1920 1058 </string>
</dict>
<key>Module</key>
<string>XCDetailModule</string>
<key>Proportion</key>
<string>570pt</string>
</dict>
</array>
<key>Proportion</key>
<string>588pt</string>
</dict>
</array>
<key>Name</key>
<string>Project</string>
<key>ServiceClasses</key>
<array>
<string>XCModuleDock</string>
<string>PBXSmartGroupTreeModule</string>
<string>XCModuleDock</string>
<string>PBXNavigatorGroup</string>
<string>XCDetailModule</string>
</array>
<key>TableOfContents</key>
<array>
<string>8EE2C16A139AA0F6007E4557</string>
<string>1CE0B1FE06471DED0097A
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
5F4</string>
<string>8EE2C16B139AA0F6007E4557</string>
<string>1CE0B20306471E060097A5F4</string>
<string>1CE0B20506471E060097A5F4</string>
</array>
<key>ToolbarConfigUserDefaultsMinorVersion</key>
<string>2</string>
<key>ToolbarConfiguration</key>
<string>xcode.toolbar.config.defaultV3</string>
</dict>
<dict>
<key>ControllerClassBaseName</key>
<string></string>
<key>IconName</key>
<string>WindowOfProject</string>
<key>Identifier</key>
<string>perspective.morph</string>
<key>IsVertical</key>
<integer>0</integer>
<key>Layout</key>
<array>
<dict>
<key>BecomeActive</key>
<integer>1</integer>
<key>ContentConfiguration</key>
<dict>
<key>PBXBottomSmartGroupGIDs</key>
<array>
<string>1C37FBAC04509CD000000102</string>
<string>1C37FAAC04509CD000000102</string>
<string>1C08E77C0454961000C914BD</string>
<string>1C37FABC05509CD000000102</string>
<string>1C37FABC05539CD112110102</string>
<string>E2644B35053B69B200211256</string>
<string>1C37FABC04509CD000100104</string>
<string>1CC0EA4004350EF90044410B</string>
<string>1CC0EA4004350EF90041110B</string>
</array>
<key>PBXProjectModuleGUID</key>
<string>11E0B1FE06471DED0097A5F4</string>
<key>PBXProjectModuleLabel</key>
<string>Files</string>
<key>PBXProjectStructureProvided</key>
<string>yes</string>
<key>PBXSmartGroupTreeModuleColumnData</key>
<dict>
<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
<array>
<real>186</real>
</array>
<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
<array>
<string>MainColumn</string>
</array>
</dict>
<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
<dict>
<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
<array>
<string>29B97314FDCFA39411CA2CEA</string>
<string>1C37FABC05509CD000000102</string>
</array>
<ke
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
y>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
<array>
<array>
<integer>0</integer>
</array>
</array>
<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
<string>{{0, 0}, {186, 337}}</string>
</dict>
<key>PBXTopSmartGroupGIDs</key>
<array/>
<key>XCIncludePerspectivesSwitch</key>
<integer>1</integer>
<key>XCSharingToken</key>
<string>com.apple.Xcode.GFSharingToken</string>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>Frame</key>
<string>{{0, 0}, {203, 355}}</string>
<key>GroupTreeTableConfiguration</key>
<array>
<string>MainColumn</string>
<real>186</real>
</array>
<key>RubberWindowFrame</key>
<string>373 269 690 397 0 0 1440 878 </string>
</dict>
<key>Module</key>
<string>PBXSmartGroupTreeModule</string>
<key>Proportion</key>
<string>100%</string>
</dict>
</array>
<key>Name</key>
<string>Morph</string>
<key>PreferredWidth</key>
<integer>300</integer>
<key>ServiceClasses</key>
<array>
<string>XCModuleDock</string>
<string>PBXSmartGroupTreeModule</string>
</array>
<key>TableOfContents</key>
<array>
<string>11E0B1FE06471DED0097A5F4</string>
</array>
<key>ToolbarConfiguration</key>
<string>xcode.toolbar.config.default.shortV3</string>
</dict>
</array>
<key>PerspectivesBarVisible</key>
<false/>
<key>ShelfIsVisible</key>
<false/>
<key>SourceDescription</key>
<string>file at '/Developer32/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecificationMode1.xcperspec'</string>
<key>StatusbarIsVisible</key>
<true/>
<key>TimeStamp</key>
<real>0.0</real>
<key>ToolbarConfigUserDefaultsMinorVersion</key>
<string>2</string>
<key>ToolbarDisplayMode</key>
<integer>1</integer>
<key>ToolbarIsVisible</key>
<true/>
<key>ToolbarSizeMode</key>
<integer>1</integer>
<key>Type</key>
<string>Perspectives</string>
<key>Up
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
dateMessage</key>
<string>The Default Workspace in this version of Xcode now includes support to hide and show the detail view (what has been referred to as the "Metro-Morph" feature). You must discard your current Default Workspace settings and update to the latest Default Workspace in order to gain this feature. Do you wish to update to the latest Workspace defaults for project '%@'?</string>
<key>WindowJustification</key>
<integer>5</integer>
<key>WindowOrderList</key>
<array>
<string>8EA3E1E71128601100889321</string>
<string>/Users/ericasadun/Desktop/11-New Edition Sample Code/XX-Base Update/HelloWorld.xcodeproj</string>
</array>
<key>WindowString</key>
<string>311 160 796 616 0 0 1920 1058 </string>
<key>WindowToolsV3</key>
<array>
<dict>
<key>FirstTimeWindowDisplayed</key>
<false/>
<key>Identifier</key>
<string>windowTool.build</string>
<key>IsVertical</key>
<true/>
<key>Layout</key>
<array>
<dict>
<key>Dock</key>
<array>
<dict>
<key>ContentConfiguration</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>1CD0528F0623707200166675</string>
<key>PBXProjectModuleLabel</key>
<string></string>
<key>StatusBarVisibility</key>
<true/>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>Frame</key>
<string>{{0, 0}, {500, 218}}</string>
<key>RubberWindowFrame</key>
<string>528 408 500 500 0 0 1920 1058 </string>
</dict>
<key>Module</key>
<string>PBXNavigatorGroup</string>
<key>Proportion</key>
<string>218pt</string>
</dict>
<dict>
<key>ContentConfiguration</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>XCMainBuildResultsModuleGUID</string>
<key>PBXProjectModuleLabel</key>
<string>Build Results</string>
<key>XCBuildResultsTrigger_Collapse</key>
<integer>1021</integer>
<key>XCBuildResultsTrigger_Open</key>
<integer
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
>1011</integer>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>Frame</key>
<string>{{0, 223}, {500, 236}}</string>
<key>RubberWindowFrame</key>
<string>528 408 500 500 0 0 1920 1058 </string>
</dict>
<key>Module</key>
<string>PBXBuildResultsModule</string>
<key>Proportion</key>
<string>236pt</string>
</dict>
</array>
<key>Proportion</key>
<string>459pt</string>
</dict>
</array>
<key>Name</key>
<string>Build Results</string>
<key>ServiceClasses</key>
<array>
<string>PBXBuildResultsModule</string>
</array>
<key>StatusbarIsVisible</key>
<true/>
<key>TableOfContents</key>
<array>
<string>8EA3E1E71128601100889321</string>
<string>8EE2C16C139AA0F6007E4557</string>
<string>1CD0528F0623707200166675</string>
<string>XCMainBuildResultsModuleGUID</string>
</array>
<key>ToolbarConfiguration</key>
<string>xcode.toolbar.config.buildV3</string>
<key>WindowContentMinSize</key>
<string>486 300</string>
<key>WindowString</key>
<string>528 408 500 500 0 0 1920 1058 </string>
<key>WindowToolGUID</key>
<string>8EA3E1E71128601100889321</string>
<key>WindowToolIsVisible</key>
<false/>
</dict>
<dict>
<key>FirstTimeWindowDisplayed</key>
<false/>
<key>Identifier</key>
<string>windowTool.debugger</string>
<key>IsVertical</key>
<true/>
<key>Layout</key>
<array>
<dict>
<key>Dock</key>
<array>
<dict>
<key>ContentConfiguration</key>
<dict>
<key>Debugger</key>
<dict>
<key>HorizontalSplitView</key>
<dict>
<key>_collapsingFrameDimension</key>
<real>0.0</real>
<key>_indexOfCollapsedView</key>
<integer>0</integer>
<key>_percentageOfCollapsedView</key>
<real>0.0</real>
<key>isCollapsed</key>
<string>yes</string>
<key>sizes</key>
<array>
<string>{{0
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
, 0}, {316, 203}}</string>
<string>{{316, 0}, {378, 203}}</string>
</array>
</dict>
<key>VerticalSplitView</key>
<dict>
<key>_collapsingFrameDimension</key>
<real>0.0</real>
<key>_indexOfCollapsedView</key>
<integer>0</integer>
<key>_percentageOfCollapsedView</key>
<real>0.0</real>
<key>isCollapsed</key>
<string>yes</string>
<key>sizes</key>
<array>
<string>{{0, 0}, {694, 203}}</string>
<string>{{0, 203}, {694, 178}}</string>
</array>
</dict>
</dict>
<key>LauncherConfigVersion</key>
<string>8</string>
<key>PBXProjectModuleGUID</key>
<string>1C162984064C10D400B95A72</string>
<key>PBXProjectModuleLabel</key>
<string>Debug - GLUTExamples (Underwater)</string>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>DebugConsoleVisible</key>
<string>None</string>
<key>DebugConsoleWindowFrame</key>
<string>{{200, 200}, {500, 300}}</string>
<key>DebugSTDIOWindowFrame</key>
<string>{{200, 200}, {500, 300}}</string>
<key>Frame</key>
<string>{{0, 0}, {694, 381}}</string>
<key>PBXDebugSessionStackFrameViewKey</key>
<dict>
<key>DebugVariablesTableConfiguration</key>
<array>
<string>Name</string>
<real>120</real>
<string>Value</string>
<real>85</real>
<string>Summary</string>
<real>148</real>
</array>
<key>Frame</key>
<string>{{316, 0}, {378, 203}}</string>
<key>RubberWindowFrame</key>
<string>131 539 694 422 0 0 1920 1058 </string>
</dict>
<key>RubberWindowFrame</key>
<string>131 539 694 422 0 0 1920 1058 </string>
</dict>
<key>Module</key>
<string>PBXDebugSessionModule</string>
<key>Proportion</key>
<string>3
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
81pt</string>
</dict>
</array>
<key>Proportion</key>
<string>381pt</string>
</dict>
</array>
<key>Name</key>
<string>Debugger</string>
<key>ServiceClasses</key>
<array>
<string>PBXDebugSessionModule</string>
</array>
<key>StatusbarIsVisible</key>
<true/>
<key>TableOfContents</key>
<array>
<string>1CD10A99069EF8BA00B06720</string>
<string>8E6CE885120A029200A88205</string>
<string>1C162984064C10D400B95A72</string>
<string>8E6CE886120A029200A88205</string>
<string>8E6CE887120A029200A88205</string>
<string>8E6CE888120A029200A88205</string>
<string>8E6CE889120A029200A88205</string>
<string>8E6CE88A120A029200A88205</string>
</array>
<key>ToolbarConfiguration</key>
<string>xcode.toolbar.config.debugV3</string>
<key>WindowString</key>
<string>131 539 694 422 0 0 1920 1058 </string>
<key>WindowToolGUID</key>
<string>1CD10A99069EF8BA00B06720</string>
<key>WindowToolIsVisible</key>
<false/>
</dict>
<dict>
<key>Identifier</key>
<string>windowTool.find</string>
<key>Layout</key>
<array>
<dict>
<key>Dock</key>
<array>
<dict>
<key>Dock</key>
<array>
<dict>
<key>ContentConfiguration</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>1CDD528C0622207200134675</string>
<key>PBXProjectModuleLabel</key>
<string><No Editor></string>
<key>PBXSplitModuleInNavigatorKey</key>
<dict>
<key>Split0</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>1CD0528D0623707200166675</string>
</dict>
<key>SplitCount</key>
<string>1</string>
</dict>
<key>StatusBarVisibility</key>
<integer>1</integer>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>Frame</key>
<string>{{0, 0}, {781, 167}}</string>
<key>RubberWindowFrame</key>
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
<string>62 385 781 470 0 0 1440 878 </string>
</dict>
<key>Module</key>
<string>PBXNavigatorGroup</string>
<key>Proportion</key>
<string>781pt</string>
</dict>
</array>
<key>Proportion</key>
<string>50%</string>
</dict>
<dict>
<key>BecomeActive</key>
<integer>1</integer>
<key>ContentConfiguration</key>
<dict>
<key>PBXProjectModuleGUID</key>
<string>1CD0528E0623707200166675</string>
<key>PBXProjectModuleLabel</key>
<string>Project Find</string>
</dict>
<key>GeometryConfiguration</key>
<dict>
<key>Frame</key>
<string>{{8, 0}, {773, 254}}</string>
<key>RubberWindowFrame</key>
<string>62 385 781 470 0 0 1440 878 </string>
</dict>
<key>Module</key>
<string>PBXProjectFindModule</string>
<key>Proportion</key>
<string>50%</string>
</dict>
</array>
<key>Proportion</key>
<string>428pt</string>
</dict>
</array>
<key>Name</key>
<string>Project Find</string>
<key>ServiceClasses</key>
<array>
<string>PBXProjectFindModule</string>
</array>
<key>StatusbarIsVisible</key>
<integer>1</integer>
<key>TableOfContents</key>
<array>
<string>1C530D57069F1CE1000CFCEE</string>
<string>1C530D58069F1CE1000CFCEE</string>
<string>1C530D59069F1CE1000CFCEE</string>
<string>1CDD528C0622207200134675</string>
<string>1C530D5A069F1CE1000CFCEE</string>
<string>1CE0B1FE06471DED0097A5F4</string>
<string>1CD0528E0623707200166675</string>
</array>
<key>WindowString</key>
<string>62 385 781 470 0 0 1440 878 </string>
<key>WindowToolGUID</key>
<string>1C530D57069F1CE1000CFCEE</string>
<key>WindowToolIsVisible</key>
<integer>0</integer>
</dict>
<dict>
<key>Identifier</key>
<string>MENUSEPARATOR</string>
</dict>
<dict>
<key>FirstTimeWindowDisplayed</key>
<false/>
<key>Identifier</key>
<str
| null | null | null | null | null | null |
github_plus_top10pct_by_avg
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.