repo_name
stringlengths 4
116
| path
stringlengths 3
942
| size
stringlengths 1
7
| content
stringlengths 3
1.05M
| license
stringclasses 15
values |
|---|---|---|---|---|
bmildner/aws-sdk-cpp | aws-cpp-sdk-ecs/source/model/RegisterContainerInstanceRequest.cpp | 2594 | /*
* Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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.
*/
#include <aws/ecs/model/RegisterContainerInstanceRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::ECS::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
RegisterContainerInstanceRequest::RegisterContainerInstanceRequest() :
m_clusterHasBeenSet(false),
m_instanceIdentityDocumentHasBeenSet(false),
m_instanceIdentityDocumentSignatureHasBeenSet(false),
m_totalResourcesHasBeenSet(false),
m_versionInfoHasBeenSet(false),
m_containerInstanceArnHasBeenSet(false)
{
}
Aws::String RegisterContainerInstanceRequest::SerializePayload() const
{
JsonValue payload;
if(m_clusterHasBeenSet)
{
payload.WithString("cluster", m_cluster);
}
if(m_instanceIdentityDocumentHasBeenSet)
{
payload.WithString("instanceIdentityDocument", m_instanceIdentityDocument);
}
if(m_instanceIdentityDocumentSignatureHasBeenSet)
{
payload.WithString("instanceIdentityDocumentSignature", m_instanceIdentityDocumentSignature);
}
if(m_totalResourcesHasBeenSet)
{
Array<JsonValue> totalResourcesJsonList(m_totalResources.size());
for(unsigned totalResourcesIndex = 0; totalResourcesIndex < totalResourcesJsonList.GetLength(); ++totalResourcesIndex)
{
totalResourcesJsonList[totalResourcesIndex].AsObject(m_totalResources[totalResourcesIndex].Jsonize());
}
payload.WithArray("totalResources", std::move(totalResourcesJsonList));
}
if(m_versionInfoHasBeenSet)
{
payload.WithObject("versionInfo", m_versionInfo.Jsonize());
}
if(m_containerInstanceArnHasBeenSet)
{
payload.WithString("containerInstanceArn", m_containerInstanceArn);
}
return payload.WriteReadable();
}
Aws::Http::HeaderValueCollection RegisterContainerInstanceRequest::GetRequestSpecificHeaders() const
{
Aws::Http::HeaderValueCollection headers;
headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "AmazonEC2ContainerServiceV20141113.RegisterContainerInstance"));
return std::move(headers);
}
| apache-2.0 |
bryce-anderson/netty | common/src/main/java/io/netty/util/internal/svm/UnsafeRefArrayAccessSubstitution.java | 1194 | /*
* Copyright 2019 The Netty Project
*
* The Netty Project licenses this file to you 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 io.netty.util.internal.svm;
import com.oracle.svm.core.annotate.Alias;
import com.oracle.svm.core.annotate.RecomputeFieldValue;
import com.oracle.svm.core.annotate.TargetClass;
@TargetClass(className = "io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess")
final class UnsafeRefArrayAccessSubstitution {
private UnsafeRefArrayAccessSubstitution() {
}
@Alias
@RecomputeFieldValue(
kind = RecomputeFieldValue.Kind.ArrayIndexShift,
declClass = Object[].class)
public static int REF_ELEMENT_SHIFT;
}
| apache-2.0 |
justintung/hbase | hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestKeyValueScanFixture.java | 2727 | /*
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.hadoop.hbase.regionserver;
import java.io.IOException;
import junit.framework.TestCase;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.KeyValueTestUtil;
import org.apache.hadoop.hbase.KeyValueUtil;
import org.apache.hadoop.hbase.testclassification.RegionServerTests;
import org.apache.hadoop.hbase.testclassification.SmallTests;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.experimental.categories.Category;
@Category({RegionServerTests.class, SmallTests.class})
public class TestKeyValueScanFixture extends TestCase {
public void testKeyValueScanFixture() throws IOException {
KeyValue kvs[] = new KeyValue[]{
KeyValueTestUtil.create("RowA", "family", "qf1",
1, KeyValue.Type.Put, "value-1"),
KeyValueTestUtil.create("RowA", "family", "qf2",
1, KeyValue.Type.Put, "value-2"),
KeyValueTestUtil.create("RowB", "family", "qf1",
10, KeyValue.Type.Put, "value-10")
};
KeyValueScanner scan = new KeyValueScanFixture(
KeyValue.COMPARATOR, kvs);
KeyValue kv = KeyValueUtil.createFirstOnRow(Bytes.toBytes("RowA"));
// should seek to this:
assertTrue(scan.seek(kv));
Cell res = scan.peek();
assertEquals(kvs[0], res);
kv = KeyValueUtil.createFirstOnRow(Bytes.toBytes("RowB"));
assertTrue(scan.seek(kv));
res = scan.peek();
assertEquals(kvs[2], res);
// ensure we pull things out properly:
kv = KeyValueUtil.createFirstOnRow(Bytes.toBytes("RowA"));
assertTrue(scan.seek(kv));
assertEquals(kvs[0], scan.peek());
assertEquals(kvs[0], scan.next());
assertEquals(kvs[1], scan.peek());
assertEquals(kvs[1], scan.next());
assertEquals(kvs[2], scan.peek());
assertEquals(kvs[2], scan.next());
assertEquals(null, scan.peek());
assertEquals(null, scan.next());
}
}
| apache-2.0 |
android-ia/platform_tools_idea | platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/CustomizedBreakpointPresentation.java | 1141 | /*
* Copyright 2000-2009 JetBrains s.r.o.
*
* 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.intellij.xdebugger.impl.breakpoints;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
/**
* @author nik
*/
public class CustomizedBreakpointPresentation {
private Icon myIcon;
private String myErrorMessage;
public void setIcon(final Icon icon) {
myIcon = icon;
}
public void setErrorMessage(final String errorMessage) {
myErrorMessage = errorMessage;
}
@Nullable
public Icon getIcon() {
return myIcon;
}
public String getErrorMessage() {
return myErrorMessage;
}
}
| apache-2.0 |
50wu/gpdb | src/backend/gporca/libnaucrates/src/parser/CParseHandlerQueryOutput.cpp | 4849 | //---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2011 EMC Corp.
//
// @filename:
// CParseHandlerQueryOutput.cpp
//
// @doc:
// Implementation of the SAX parse handler class parsing the list of
// output column references in a DXL query.
//---------------------------------------------------------------------------
#include "naucrates/dxl/parser/CParseHandlerQueryOutput.h"
#include "naucrates/dxl/operators/CDXLOperatorFactory.h"
#include "naucrates/dxl/parser/CParseHandlerFactory.h"
#include "naucrates/dxl/parser/CParseHandlerScalarIdent.h"
using namespace gpdxl;
XERCES_CPP_NAMESPACE_USE
//---------------------------------------------------------------------------
// @function:
// CParseHandlerQueryOutput::CParseHandlerQueryOutput
//
// @doc:
// Constructor
//
//---------------------------------------------------------------------------
CParseHandlerQueryOutput::CParseHandlerQueryOutput(
CMemoryPool *mp, CParseHandlerManager *parse_handler_mgr,
CParseHandlerBase *parse_handler_root)
: CParseHandlerBase(mp, parse_handler_mgr, parse_handler_root),
m_dxl_array(nullptr)
{
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerQueryOutput::~CParseHandlerQueryOutput
//
// @doc:
// Destructor
//
//---------------------------------------------------------------------------
CParseHandlerQueryOutput::~CParseHandlerQueryOutput()
{
m_dxl_array->Release();
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerQueryOutput::GetOutputColumnsDXLArray
//
// @doc:
// Return the list of query output columns
//
//---------------------------------------------------------------------------
CDXLNodeArray *
CParseHandlerQueryOutput::GetOutputColumnsDXLArray()
{
GPOS_ASSERT(nullptr != m_dxl_array);
return m_dxl_array;
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerQueryOutput::StartElement
//
// @doc:
// Invoked by Xerces to process an opening tag
//
//---------------------------------------------------------------------------
void
CParseHandlerQueryOutput::StartElement(const XMLCh *const element_uri,
const XMLCh *const element_local_name,
const XMLCh *const element_qname,
const Attributes &attrs)
{
if (0 ==
XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenQueryOutput),
element_local_name))
{
// start the query output section in the DXL document
GPOS_ASSERT(nullptr == m_dxl_array);
m_dxl_array = GPOS_NEW(m_mp) CDXLNodeArray(m_mp);
}
else if (0 == XMLString::compareString(
CDXLTokens::XmlstrToken(EdxltokenScalarIdent),
element_local_name))
{
// we must have seen a proj list already and initialized the proj list node
GPOS_ASSERT(nullptr != m_dxl_array);
// start new scalar ident element
CParseHandlerBase *child_parse_handler =
CParseHandlerFactory::GetParseHandler(
m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarIdent),
m_parse_handler_mgr, this);
m_parse_handler_mgr->ActivateParseHandler(child_parse_handler);
// store parse handler
this->Append(child_parse_handler);
child_parse_handler->startElement(element_uri, element_local_name,
element_qname, attrs);
}
else
{
CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(
m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name);
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag,
str->GetBuffer());
}
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerQueryOutput::EndElement
//
// @doc:
// Invoked by Xerces to process a closing tag
//
//---------------------------------------------------------------------------
void
CParseHandlerQueryOutput::EndElement(const XMLCh *const, // element_uri,
const XMLCh *const element_local_name,
const XMLCh *const // element_qname
)
{
if (0 !=
XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenQueryOutput),
element_local_name))
{
CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(
m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name);
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag,
str->GetBuffer());
}
const ULONG size = this->Length();
for (ULONG ul = 0; ul < size; ul++)
{
CParseHandlerScalarIdent *child_parse_handler =
dynamic_cast<CParseHandlerScalarIdent *>((*this)[ul]);
GPOS_ASSERT(nullptr != child_parse_handler);
CDXLNode *pdxlnIdent = child_parse_handler->CreateDXLNode();
pdxlnIdent->AddRef();
m_dxl_array->Append(pdxlnIdent);
}
// deactivate handler
m_parse_handler_mgr->DeactivateHandler();
}
// EOF
| apache-2.0 |
gregory-nisbet/ack2 | README.md | 1107 | # ack 2.0
ack is a code-searching tool, similar to grep but optimized for
programmers searching large trees of source code. It runs in pure
Perl, is highly portable, and runs on any platform that runs Perl.
ack is written and maintained by Andy Lester ([email protected]).
* Project home page: http://beyondgrep.com/
* Code home page: https://github.com/petdance/ack2
* Issue tracker: https://github.com/petdance/ack2/issues
* Mailing list for users: https://groups.google.com/d/forum/ack-users
* Mailing list for developers: https://groups.google.com/d/forum/ack-dev
# Building
ack requires Perl 5.8.8 or higher. Perl 5.8.8 was released January 2006.
# Required
perl Makefile.PL
make
make test
sudo make install # for a system-wide installation (recommended)
# - or -
make ack-standalone
cp ack-standalone ~/bin/ack2 # for a personal installation
Build status: [](https://travis-ci.org/petdance/ack2)
# Development
[Developer's Guide](DEVELOPERS.md)
[Design Guide](DESIGN.md)
# Community
TODO
| artistic-2.0 |
sjackman/homebrew-core | Formula/perl-build.rb | 5489 | class PerlBuild < Formula
desc "Perl builder"
homepage "https://github.com/tokuhirom/Perl-Build"
url "https://github.com/tokuhirom/Perl-Build/archive/1.32.tar.gz"
sha256 "ba86d74ff9718977637806ef650c85615534f0b17023a72f447587676d7f66fd"
license any_of: ["Artistic-1.0", "GPL-1.0-or-later"]
head "https://github.com/tokuhirom/perl-build.git", branch: "master"
bottle do
sha256 cellar: :any_skip_relocation, arm64_monterey: "a9d4cdf8f97ae6c7aaafc8cb6e6d5099ec97f6ec0632a33af90e70766c9e497e"
sha256 cellar: :any_skip_relocation, arm64_big_sur: "b662afe3c5e833e08c5e0a425f5597ab159b808e6285e90f96ee48e1f8d8d9a8"
sha256 cellar: :any_skip_relocation, monterey: "e05da78d5eab2ca95b3bdc567a1d8ef81d60c932af55420958f2e6538b18c89e"
sha256 cellar: :any_skip_relocation, big_sur: "a24fadf986032226343c74378f0344b15729687d9b0679f64e859e41a4f165db"
sha256 cellar: :any_skip_relocation, catalina: "e2b99b05c34a89e8706810730e8ac6da7d98c76025b72d86eb2a6003a47a4b85"
sha256 cellar: :any_skip_relocation, mojave: "5ae631c827ab5b58f0e2bafa3b5470f3b2f2236802942c3d4454ab96fd212aa8"
sha256 cellar: :any_skip_relocation, x86_64_linux: "7e55952e9cc4849a4a6da657c0b9e52f93da495518b9c0db1da64efab51ced28"
end
uses_from_macos "perl"
resource "Module::Build" do
url "https://cpan.metacpan.org/authors/id/L/LE/LEONT/Module-Build-0.4231.tar.gz"
sha256 "7e0f4c692c1740c1ac84ea14d7ea3d8bc798b2fb26c09877229e04f430b2b717"
end
resource "Module::Build::Tiny" do
url "https://cpan.metacpan.org/authors/id/L/LE/LEONT/Module-Build-Tiny-0.039.tar.gz"
sha256 "7d580ff6ace0cbe555bf36b86dc8ea232581530cbeaaea09bccb57b55797f11c"
end
resource "ExtUtils::Config" do
url "https://cpan.metacpan.org/authors/id/L/LE/LEONT/ExtUtils-Config-0.008.tar.gz"
sha256 "ae5104f634650dce8a79b7ed13fb59d67a39c213a6776cfdaa3ee749e62f1a8c"
end
resource "ExtUtils::Helpers" do
url "https://cpan.metacpan.org/authors/id/L/LE/LEONT/ExtUtils-Helpers-0.026.tar.gz"
sha256 "de901b6790a4557cf4ec908149e035783b125bf115eb9640feb1bc1c24c33416"
end
resource "ExtUtils::InstallPaths" do
url "https://cpan.metacpan.org/authors/id/L/LE/LEONT/ExtUtils-InstallPaths-0.012.tar.gz"
sha256 "84735e3037bab1fdffa3c2508567ad412a785c91599db3c12593a50a1dd434ed"
end
resource "HTTP::Tinyish" do
url "https://cpan.metacpan.org/authors/id/M/MI/MIYAGAWA/HTTP-Tinyish-0.17.tar.gz"
sha256 "47bd111e474566d733c41870e2374c81689db5e0b5a43adc48adb665d89fb067"
end
resource "CPAN::Perl::Releases" do
url "https://cpan.metacpan.org/authors/id/B/BI/BINGOS/CPAN-Perl-Releases-5.20210220.tar.gz"
sha256 "c88ba6bba670bfc36bcb10adcceab83428ab3b3363ac9bb11f374a88f52466be"
end
resource "CPAN::Perl::Releases::MetaCPAN" do
url "https://cpan.metacpan.org/authors/id/S/SK/SKAJI/CPAN-Perl-Releases-MetaCPAN-0.006.tar.gz"
sha256 "d78ef4ee4f0bc6d95c38bbcb0d2af81cf59a31bde979431c1b54ec50d71d0e1b"
end
resource "File::pushd" do
url "https://cpan.metacpan.org/authors/id/D/DA/DAGOLDEN/File-pushd-1.016.tar.gz"
sha256 "d73a7f09442983b098260df3df7a832a5f660773a313ca273fa8b56665f97cdc"
end
resource "HTTP::Tiny" do
url "https://cpan.metacpan.org/authors/id/D/DA/DAGOLDEN/HTTP-Tiny-0.076.tar.gz"
sha256 "ddbdaa2fb511339fa621a80021bf1b9733fddafc4fe0245f26c8b92171ef9387"
end
# Devel::PatchPerl dependency
resource "Module::Pluggable" do
url "https://cpan.metacpan.org/authors/id/S/SI/SIMONW/Module-Pluggable-5.2.tar.gz"
sha256 "b3f2ad45e4fd10b3fb90d912d78d8b795ab295480db56dc64e86b9fa75c5a6df"
end
resource "Devel::PatchPerl" do
url "https://cpan.metacpan.org/authors/id/B/BI/BINGOS/Devel-PatchPerl-2.08.tar.gz"
sha256 "69c6e97016260f408e9d7e448f942b36a6d49df5af07340f1d65d7e230167419"
end
# Pod::Usage dependency
resource "Pod::Text" do
url "https://cpan.metacpan.org/authors/id/R/RR/RRA/podlators-4.12.tar.gz"
sha256 "948717da19630a5f003da4406da90fe1cbdec9ae493671c90dfb6d8b3d63b7eb"
end
resource "Pod::Usage" do
url "https://cpan.metacpan.org/authors/id/M/MA/MAREKR/Pod-Usage-1.69.tar.gz"
sha256 "1a920c067b3c905b72291a76efcdf1935ba5423ab0187b9a5a63cfc930965132"
end
def install
ENV.prepend_create_path "PERL5LIB", libexec/"lib/perl5"
# Ensure we don't install the pre-packed script
(buildpath/"perl-build").unlink
# Remove this apparently dead symlink.
(buildpath/"bin/perl-build").unlink
build_pl = ["Module::Build::Tiny", "CPAN::Perl::Releases::MetaCPAN"]
resources.each do |r|
r.stage do
next if build_pl.include? r.name
system "perl", "Makefile.PL", "INSTALL_BASE=#{libexec}"
system "make"
system "make", "install"
end
end
build_pl.each do |name|
resource(name).stage do
system "perl", "Build.PL", "--install_base", libexec
system "./Build"
system "./Build", "install"
end
end
ENV.prepend_path "PATH", libexec/"bin"
system "perl", "Build.PL", "--install_base", libexec
# Replace the dead symlink we removed earlier.
(buildpath/"bin").install_symlink buildpath/"script/perl-build"
system "./Build"
system "./Build", "install"
%w[perl-build plenv-install plenv-uninstall].each do |cmd|
(bin/cmd).write_env_script(libexec/"bin/#{cmd}", PERL5LIB: ENV["PERL5LIB"])
end
end
test do
assert_match version.to_s, shell_output("#{bin}/perl-build --version")
end
end
| bsd-2-clause |
sjackman/homebrew-core | Formula/git-absorb.rb | 2121 | class GitAbsorb < Formula
desc "Automatic git commit --fixup"
homepage "https://github.com/tummychow/git-absorb"
url "https://github.com/tummychow/git-absorb/archive/0.6.6.tar.gz"
sha256 "955069cc70a34816e6f4b6a6bd1892cfc0ae3d83d053232293366eb65599af2f"
license "BSD-3-Clause"
bottle do
rebuild 1
sha256 cellar: :any_skip_relocation, arm64_monterey: "a01139732b157c708bf13151074669105cca050159412fd781ed9be5b9afdb93"
sha256 cellar: :any_skip_relocation, arm64_big_sur: "50ec784cd0089d5840025d2b108ac75b9b87b4ec786e9e4766304fc012cb3507"
sha256 cellar: :any_skip_relocation, monterey: "73201ddb25921212ac430c95be693d7b65ab5c4221a5a18958be63af69eef95b"
sha256 cellar: :any_skip_relocation, big_sur: "5c90abd3d3058854758851749660bab97f06a9b60b01e6eb75da29c3c6fa3941"
sha256 cellar: :any_skip_relocation, catalina: "0d9b836c7c18d1284e31fe6d354cbfae95c513fae6855d7d8897dbaab3eacf0e"
sha256 cellar: :any_skip_relocation, mojave: "d5f13b0f733d6c2d1cd8c98008fcf51faccd3bd4312dd7742dc6a2cc695d0a34"
sha256 cellar: :any_skip_relocation, x86_64_linux: "96f90dd36ce015d992314e9e6b325f4b2549fd2ef6871356f96d8ade728980c0"
end
depends_on "rust" => :build
uses_from_macos "zlib"
def install
system "cargo", "install", *std_cargo_args
man1.install "Documentation/git-absorb.1"
(zsh_completion/"_git-absorb").write Utils.safe_popen_read("#{bin}/git-absorb", "--gen-completions", "zsh")
(bash_completion/"git-absorb").write Utils.safe_popen_read("#{bin}/git-absorb", "--gen-completions", "bash")
(fish_completion/"git-absorb.fish").write Utils.safe_popen_read("#{bin}/git-absorb", "--gen-completions", "fish")
end
test do
(testpath/".gitconfig").write <<~EOS
[user]
name = Real Person
email = [email protected]
EOS
system "git", "init"
(testpath/"test").write "foo"
system "git", "add", "test"
system "git", "commit", "--message", "Initial commit"
(testpath/"test").delete
(testpath/"test").write "bar"
system "git", "add", "test"
system "git", "absorb"
end
end
| bsd-2-clause |
josa42/homebrew-cask | Casks/astropad.rb | 649 | cask 'astropad' do
version '3.1'
sha256 '4082c09dd4aa440a2b8bd25104d98d3f431fbca2fc4f139d3e390632f4903f22'
url "https://astropad.com/downloads/Astropad-#{version}.zip"
appcast 'https://astropad.com/downloads/sparkle.xml'
name 'Astropad'
homepage 'https://astropad.com/'
app 'Astropad.app'
uninstall quit: 'com.astro-hq.AstropadMac'
zap trash: [
'~/Library/Caches/Astropad',
'~/Library/Caches/com.astro-hq.AstropadMac',
'~/Library/Preferences/com.astro-hq.AstropadMac.plist',
'~/Library/Saved Application State/com.astro-hq.AstropadMac.savedState',
]
end
| bsd-2-clause |
stephenwade/homebrew-cask | doc/cask_language_reference/all_stanzas.md | 9227 | # All stanzas
## Required Stanzas
Each of the following stanzas is required for every Cask.
| name | multiple occurrences allowed? | value |
| ---------- |------------------------------ | ------------------------------- |
| `version` | no | Application version.<br />See [Version Stanza Details](stanzas/version.md) for more information.
| `sha256` | no | SHA-256 checksum of the file downloaded from `url`, calculated by the command `shasum -a 256 <file>`. Can be suppressed by using the special value `:no_check`.<br />See [Checksum Stanza Details](stanzas/sha256.md) for more information.
| `url` | no | URL to the `.dmg`/`.zip`/`.tgz`/`.tbz2` file that contains the application.<br />A [comment](stanzas/url.md#when-url-and-homepage-hostnames-differ-add-a-comment) should be added if the hostnames in the `url` and `homepage` stanzas differ. Block syntax should be used for URLs that change on every visit.<br />See [URL Stanza Details](stanzas/url.md) for more information.
| `name` | yes | String providing the full and proper name defined by the vendor.<br />See [Name Stanza Details](stanzas/name.md) for more information.
| `desc` | no | One-line description of the Cask. Shows when running `brew info`.<br />See [Desc Stanza Details](stanzas/desc.md) for more information.
| `homepage` | no | Application homepage; used for the `brew home` command.
## At Least One Artifact Stanza Is Also Required
Each Cask must declare one or more *artifacts* (i.e. something to install).
| name | multiple occurrences allowed? | value |
| ------------------- |------------------------------ | ---------------------- |
| `app` | yes | Relative path to an `.app` that should be moved into the `/Applications` folder on installation.<br />See [App Stanza Details](stanzas/app.md) for more information.
| `pkg` | yes | Relative path to a `.pkg` file containing the distribution.<br />See [Pkg Stanza Details](stanzas/pkg.md) for more information.
| `binary` | yes | Relative path to a Binary that should be linked into the `$(brew --prefix)/bin` folder (typically `/usr/local/bin`) on installation.<br />See [Binary Stanza Details](stanzas/binary.md) for more information.
| `colorpicker` | yes | Relative path to a ColorPicker plugin that should be moved into the `~/Library/ColorPickers` folder on installation.
| `dictionary` | yes | Relative path to a Dictionary that should be moved into the `~/Library/Dictionaries` folder on installation.
| `font` | yes | Relative path to a Font that should be moved into the `~/Library/Fonts` folder on installation.
| `input_method` | yes | Relative path to a Input Method that should be moved into the `~/Library/Input Methods` folder on installation.
| `internet_plugin` | yes | Relative path to a Service that should be moved into the `~/Library/Internet Plug-Ins` folder on installation.
| `manpage` | yes | Relative path to a Man Page that should be linked into the respective man page folder on installation, e.g. `/usr/local/share/man/man3` for `my_app.3`.
| `prefpane` | yes | Relative path to a Preference Pane that should be moved into the `~/Library/PreferencePanes` folder on installation.
| `qlplugin` | yes | Relative path to a QuickLook Plugin that should be moved into the `~/Library/QuickLook` folder on installation.
| `mdimporter` | yes | Relative path to a Spotlight metadata importer that should be moved into the `~/Library/Spotlight` folder on installation.
| `screen_saver` | yes | Relative path to a Screen Saver that should be moved into the `~/Library/Screen Savers` folder on installation.
| `service` | yes | Relative path to a Service that should be moved into the `~/Library/Services` folder on installation.
| `audio_unit_plugin` | yes | Relative path to an Audio Unit plugin that should be moved into the `~/Library/Audio/Components` folder on installation.
| `vst_plugin` | yes | Relative path to a VST Plugin that should be moved into the `~/Library/Audio/VST` folder on installation.
| `vst3_plugin` | yes | Relative path to a VST3 Plugin that should be moved into the `~/Library/Audio/VST3` folder on installation.
| `suite` | yes | Relative path to a containing directory that should be moved into the `/Applications` folder on installation.<br />See [Suite Stanza Details](stanzas/suite.md) for more information.
| `artifact` | yes | Relative path to an arbitrary path that should be moved on installation. Must provide an absolute path as a `target` (example [alcatraz.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/alcatraz.rb#L12)). This is only for unusual cases. The `app` stanza is strongly preferred when moving `.app` bundles.
| `installer` | yes | Describes an executable which must be run to complete the installation.<br />See [Installer Stanza Details](stanzas/installer.md) for more information.
| `stage_only` | no | `true`. Assert that the Cask contains no activatable artifacts.
## Optional Stanzas
| name | multiple occurrences allowed? | value |
| ---------------------- |------------------------------ | ------------------- |
| `uninstall` | yes | Procedures to uninstall a Cask. Optional unless the `pkg` stanza is used.<br />See [Uninstall Stanza Details](stanzas/uninstall.md) for more information.
| `zap` | yes | Additional procedures for a more complete uninstall, including user files and shared resources.<br />See [Zap Stanza Details](stanzas/zap.md) for more information.
| `appcast` | no | URL providing an appcast feed to find updates for this Cask.<br />See [Appcast Stanza Details](stanzas/appcast.md) for more information.
| `depends_on` | yes | List of dependencies and requirements for this Cask.<br />See [Depends_on Stanza Details](stanzas/depends_on.md) for more information.
| `conflicts_with` | yes | List of conflicts with this Cask (*not yet functional*).<br />See [Conflicts_with Stanza Details](stanzas/conflicts_with.md) for more information.
| `caveats` | yes | String or Ruby block providing the user with Cask-specific information at install time.<br />See [Caveats Stanza Details](stanzas/caveats.md) for more information.
| `livecheck` | no | Ruby block describing how to find updates for this Cask.<br />See [Livecheck Stanza Details](stanzas/livecheck.md) for more information.
| `preflight` | yes | Ruby block containing preflight install operations (needed only in very rare cases).
| `postflight` | yes | Ruby block containing postflight install operations.<br />See [Postflight Stanza Details](stanzas/flight.md) for more information.
| `uninstall_preflight` | yes | Ruby block containing preflight uninstall operations (needed only in very rare cases).
| `uninstall_postflight` | yes | Ruby block containing postflight uninstall operations.
| `language` | required | Ruby block, called with language code parameters, containing other stanzas and/or a return value.<br />See [Language Stanza Details](stanzas/language.md) for more information.
| `container nested:` | no | Relative path to an inner container that must be extracted before moving on with the installation. This allows us to support dmg inside tar, zip inside dmg, etc.
| `container type:` | no | Symbol to override container-type autodetect. May be one of: `:air`, `:bz2`, `:cab`, `:dmg`, `:generic_unar`, `:gzip`, `:otf`, `:pkg`, `:rar`, `:seven_zip`, `:sit`, `:tar`, `:ttf`, `:xar`, `:zip`, `:naked`. (Example: [parse.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/parse.rb#L11))
| `auto_updates` | no | `true`. Assert the Cask artifacts auto-update. Use if `Check for Updates…` or similar is present in app menu, but not if it only opens a webpage and does not do the download and installation for you.
| bsd-2-clause |
wet-boew/openlayers-dist | test/spec/ol/extent.test.js | 27991 | goog.provide('ol.test.extent');
goog.require('ol.extent');
goog.require('ol.proj');
describe('ol.extent', function() {
describe('buffer', function() {
it('buffers an extent by some value', function() {
var extent = [-10, -20, 10, 20];
expect(ol.extent.buffer(extent, 15)).to.eql([-25, -35, 25, 35]);
});
});
describe('clone', function() {
it('creates a copy of an extent', function() {
var extent = ol.extent.createOrUpdate(1, 2, 3, 4);
var clone = ol.extent.clone(extent);
expect(ol.extent.equals(extent, clone)).to.be(true);
ol.extent.extendCoordinate(extent, [10, 20]);
expect(ol.extent.equals(extent, clone)).to.be(false);
});
});
describe('closestSquaredDistanceXY', function() {
it('returns correct result when x left of extent', function() {
var extent = ol.extent.createOrUpdate(0, 0, 1, 1);
var x = -2;
var y = 0;
expect(ol.extent.closestSquaredDistanceXY(extent, x, y)).to.be(4);
});
it('returns correct result when x right of extent', function() {
var extent = ol.extent.createOrUpdate(0, 0, 1, 1);
var x = 3;
var y = 0;
expect(ol.extent.closestSquaredDistanceXY(extent, x, y)).to.be(4);
});
it('returns correct result for other x values', function() {
var extent = ol.extent.createOrUpdate(0, 0, 1, 1);
var x = 0.5;
var y = 3;
expect(ol.extent.closestSquaredDistanceXY(extent, x, y)).to.be(4);
});
it('returns correct result when y below extent', function() {
var extent = ol.extent.createOrUpdate(0, 0, 1, 1);
var x = 0;
var y = -2;
expect(ol.extent.closestSquaredDistanceXY(extent, x, y)).to.be(4);
});
it('returns correct result when y above extent', function() {
var extent = ol.extent.createOrUpdate(0, 0, 1, 1);
var x = 0;
var y = 3;
expect(ol.extent.closestSquaredDistanceXY(extent, x, y)).to.be(4);
});
it('returns correct result for other y values', function() {
var extent = ol.extent.createOrUpdate(0, 0, 1, 1);
var x = 3;
var y = 0.5;
expect(ol.extent.closestSquaredDistanceXY(extent, x, y)).to.be(4);
});
});
describe('createOrUpdateFromCoordinate', function() {
it('works when no extent passed', function() {
var coords = [0, 1];
var expected = [0, 1, 0, 1];
var got = ol.extent.createOrUpdateFromCoordinate(coords);
expect(got).to.eql(expected);
});
it('updates a passed extent', function() {
var extent = ol.extent.createOrUpdate(-4, -7, -3, -6);
var coords = [0, 1];
var expected = [0, 1, 0, 1];
ol.extent.createOrUpdateFromCoordinate(coords, extent);
expect(extent).to.eql(expected);
});
});
describe('createOrUpdateFromCoordinates', function() {
it('works when single coordinate and no extent passed', function() {
var coords = [[0, 1]];
var expected = [0, 1, 0, 1];
var got = ol.extent.createOrUpdateFromCoordinates(coords);
expect(got).to.eql(expected);
});
it('changes the passed extent when single coordinate', function() {
var extent = ol.extent.createOrUpdate(-4, -7, -3, -6);
var coords = [[0, 1]];
var expected = [0, 1, 0, 1];
ol.extent.createOrUpdateFromCoordinates(coords, extent);
expect(extent).to.eql(expected);
});
it('works when multiple coordinates and no extent passed', function() {
var coords = [[0, 1], [2, 3]];
var expected = [0, 1, 2, 3];
var got = ol.extent.createOrUpdateFromCoordinates(coords);
expect(got).to.eql(expected);
});
it('changes the passed extent when multiple coordinates given', function() {
var extent = ol.extent.createOrUpdate(-4, -7, -3, -6);
var coords = [[0, 1], [-2, -1]];
var expected = [-2, -1, 0, 1];
ol.extent.createOrUpdateFromCoordinates(coords, extent);
expect(extent).to.eql(expected);
});
});
describe('createOrUpdateFromRings', function() {
it('works when single ring and no extent passed', function() {
var ring = [[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]];
var rings = [ring];
var expected = [0, 0, 2, 2];
var got = ol.extent.createOrUpdateFromRings(rings);
expect(got).to.eql(expected);
});
it('changes the passed extent when single ring given', function() {
var ring = [[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]];
var rings = [ring];
var extent = [1, 1, 4, 7];
var expected = [0, 0, 2, 2];
ol.extent.createOrUpdateFromRings(rings, extent);
expect(extent).to.eql(expected);
});
it('works when multiple rings and no extent passed', function() {
var ring1 = [[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]];
var ring2 = [[1, 1], [1, 3], [3, 3], [3, 1], [1, 1]];
var rings = [ring1, ring2];
var expected = [0, 0, 3, 3];
var got = ol.extent.createOrUpdateFromRings(rings);
expect(got).to.eql(expected);
});
it('changes the passed extent when multiple rings given', function() {
var ring1 = [[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]];
var ring2 = [[1, 1], [1, 3], [3, 3], [3, 1], [1, 1]];
var rings = [ring1, ring2];
var extent = [1, 1, 4, 7];
var expected = [0, 0, 3, 3];
ol.extent.createOrUpdateFromRings(rings, extent);
expect(extent).to.eql(expected);
});
});
describe('forEachCorner', function() {
var callbackFalse;
var callbackTrue;
beforeEach(function() {
callbackFalse = sinon.spy(function() {
return false;
});
callbackTrue = sinon.spy(function() {
return true;
});
});
it('calls the passed callback for each corner', function() {
var extent = [1, 2, 3, 4];
ol.extent.forEachCorner(extent, callbackFalse);
expect(callbackFalse.callCount).to.be(4);
});
it('calls the passed callback with each corner', function() {
var extent = [1, 2, 3, 4];
ol.extent.forEachCorner(extent, callbackFalse);
var firstCallFirstArg = callbackFalse.args[0][0];
var secondCallFirstArg = callbackFalse.args[1][0];
var thirdCallFirstArg = callbackFalse.args[2][0];
var fourthCallFirstArg = callbackFalse.args[3][0];
expect(firstCallFirstArg).to.eql([1, 2]); // bl
expect(secondCallFirstArg).to.eql([3, 2]); // br
expect(thirdCallFirstArg).to.eql([3, 4]); // tr
expect(fourthCallFirstArg).to.eql([1, 4]); // tl
});
it('calls a truthy callback only once', function() {
var extent = [1, 2, 3, 4];
ol.extent.forEachCorner(extent, callbackTrue);
expect(callbackTrue.callCount).to.be(1);
});
it('ensures that any corner can cancel the callback execution', function() {
var extent = [1, 2, 3, 4];
var bottomLeftSpy = sinon.spy(function(corner) {
return (corner[0] === 1 && corner[1] === 2) ? true : false;
});
var bottomRightSpy = sinon.spy(function(corner) {
return (corner[0] === 3 && corner[1] === 2) ? true : false;
});
var topRightSpy = sinon.spy(function(corner) {
return (corner[0] === 3 && corner[1] === 4) ? true : false;
});
var topLeftSpy = sinon.spy(function(corner) {
return (corner[0] === 1 && corner[1] === 4) ? true : false;
});
ol.extent.forEachCorner(extent, bottomLeftSpy);
ol.extent.forEachCorner(extent, bottomRightSpy);
ol.extent.forEachCorner(extent, topRightSpy);
ol.extent.forEachCorner(extent, topLeftSpy);
expect(bottomLeftSpy.callCount).to.be(1);
expect(bottomRightSpy.callCount).to.be(2);
expect(topRightSpy.callCount).to.be(3);
expect(topLeftSpy.callCount).to.be(4);
});
it('returns false eventually, if no invocation returned a truthy value',
function() {
var extent = [1, 2, 3, 4];
var spy = sinon.spy(); // will return undefined for each corner
var got = ol.extent.forEachCorner(extent, spy);
expect(spy.callCount).to.be(4);
expect(got).to.be(false);
}
);
it('calls the callback with given scope', function() {
var extent = [1, 2, 3, 4];
var scope = {humpty: 'dumpty'};
ol.extent.forEachCorner(extent, callbackTrue, scope);
expect(callbackTrue.calledOn(scope)).to.be(true);
});
});
describe('getArea', function() {
it('returns zero for empty extents', function() {
var emptyExtent = ol.extent.createEmpty();
var areaEmpty = ol.extent.getArea(emptyExtent);
expect(areaEmpty).to.be(0);
var extentDeltaXZero = [45, 67, 45, 78];
var areaDeltaXZero = ol.extent.getArea(extentDeltaXZero);
expect(areaDeltaXZero).to.be(0);
var extentDeltaYZero = [11, 67, 45, 67];
var areaDeltaYZero = ol.extent.getArea(extentDeltaYZero);
expect(areaDeltaYZero).to.be(0);
});
it('calculates correct area for other extents', function() {
var extent = [0, 0, 10, 10];
var area = ol.extent.getArea(extent);
expect(area).to.be(100);
});
});
describe('getIntersection()', function() {
it('returns the intersection of two extents', function() {
var world = [-180, -90, 180, 90];
var north = [-180, 0, 180, 90];
var farNorth = [-180, 45, 180, 90];
var east = [0, -90, 180, 90];
var farEast = [90, -90, 180, 90];
var south = [-180, -90, 180, 0];
var farSouth = [-180, -90, 180, -45];
var west = [-180, -90, 0, 90];
var farWest = [-180, -90, -90, 90];
var none = ol.extent.createEmpty();
expect(ol.extent.getIntersection(world, none)).to.eql(none);
expect(ol.extent.getIntersection(world, north)).to.eql(north);
expect(ol.extent.getIntersection(world, east)).to.eql(east);
expect(ol.extent.getIntersection(world, south)).to.eql(south);
expect(ol.extent.getIntersection(world, west)).to.eql(west);
expect(ol.extent.getIntersection(farEast, farWest)).to.eql(none);
expect(ol.extent.getIntersection(farNorth, farSouth)).to.eql(none);
expect(ol.extent.getIntersection(north, west)).to.eql([-180, 0, 0, 90]);
expect(ol.extent.getIntersection(east, south)).to.eql([0, -90, 180, 0]);
});
});
describe('containsCoordinate', function() {
describe('positive', function() {
it('returns true', function() {
var extent = [1, 2, 3, 4];
expect(ol.extent.containsCoordinate(extent, [1, 2])).to.be.ok();
expect(ol.extent.containsCoordinate(extent, [1, 3])).to.be.ok();
expect(ol.extent.containsCoordinate(extent, [1, 4])).to.be.ok();
expect(ol.extent.containsCoordinate(extent, [2, 2])).to.be.ok();
expect(ol.extent.containsCoordinate(extent, [2, 3])).to.be.ok();
expect(ol.extent.containsCoordinate(extent, [2, 4])).to.be.ok();
expect(ol.extent.containsCoordinate(extent, [3, 2])).to.be.ok();
expect(ol.extent.containsCoordinate(extent, [3, 3])).to.be.ok();
expect(ol.extent.containsCoordinate(extent, [3, 4])).to.be.ok();
});
});
describe('negative', function() {
it('returns false', function() {
var extent = [1, 2, 3, 4];
expect(ol.extent.containsCoordinate(extent, [0, 1])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [0, 2])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [0, 3])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [0, 4])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [0, 5])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [1, 1])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [1, 5])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [2, 1])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [2, 5])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [3, 1])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [3, 5])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [4, 1])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [4, 2])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [4, 3])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [4, 4])).to.not.be();
expect(ol.extent.containsCoordinate(extent, [4, 5])).to.not.be();
});
});
});
describe('coordinateRelationship()', function() {
var extent = [-180, -90, 180, 90];
var INTERSECTING = 1;
var ABOVE = 2;
var RIGHT = 4;
var BELOW = 8;
var LEFT = 16;
it('returns intersecting for within', function() {
var rel = ol.extent.coordinateRelationship(extent, [0, 0]);
expect(rel).to.be(INTERSECTING);
});
it('returns intersecting for touching top', function() {
var rel = ol.extent.coordinateRelationship(extent, [0, 90]);
expect(rel).to.be(INTERSECTING);
});
it('returns intersecting for touching right', function() {
var rel = ol.extent.coordinateRelationship(extent, [180, 0]);
expect(rel).to.be(INTERSECTING);
});
it('returns intersecting for touching bottom', function() {
var rel = ol.extent.coordinateRelationship(extent, [0, -90]);
expect(rel).to.be(INTERSECTING);
});
it('returns intersecting for touching left', function() {
var rel = ol.extent.coordinateRelationship(extent, [-180, 0]);
expect(rel).to.be(INTERSECTING);
});
it('above for north', function() {
var rel = ol.extent.coordinateRelationship(extent, [0, 100]);
expect(rel).to.be(ABOVE);
});
it('above and right for northeast', function() {
var rel = ol.extent.coordinateRelationship(extent, [190, 100]);
expect(rel & ABOVE).to.be(ABOVE);
expect(rel & RIGHT).to.be(RIGHT);
});
it('right for east', function() {
var rel = ol.extent.coordinateRelationship(extent, [190, 0]);
expect(rel).to.be(RIGHT);
});
it('below and right for southeast', function() {
var rel = ol.extent.coordinateRelationship(extent, [190, -100]);
expect(rel & BELOW).to.be(BELOW);
expect(rel & RIGHT).to.be(RIGHT);
});
it('below for south', function() {
var rel = ol.extent.coordinateRelationship(extent, [0, -100]);
expect(rel).to.be(BELOW);
});
it('below and left for southwest', function() {
var rel = ol.extent.coordinateRelationship(extent, [-190, -100]);
expect(rel & BELOW).to.be(BELOW);
expect(rel & LEFT).to.be(LEFT);
});
it('left for west', function() {
var rel = ol.extent.coordinateRelationship(extent, [-190, 0]);
expect(rel).to.be(LEFT);
});
it('above and left for northwest', function() {
var rel = ol.extent.coordinateRelationship(extent, [-190, 100]);
expect(rel & ABOVE).to.be(ABOVE);
expect(rel & LEFT).to.be(LEFT);
});
});
describe('getCenter', function() {
it('returns the expected center', function() {
var extent = [1, 2, 3, 4];
var center = ol.extent.getCenter(extent);
expect(center[0]).to.eql(2);
expect(center[1]).to.eql(3);
});
it('returns [NaN, NaN] for empty extents', function() {
var extent = ol.extent.createEmpty();
var center = ol.extent.getCenter(extent);
expect('' + center[0]).to.be('NaN');
expect('' + center[1]).to.be('NaN');
});
});
describe('getCorner', function() {
var extent = [1, 2, 3, 4];
it('gets the bottom left', function() {
var corner = 'bottom-left';
expect(ol.extent.getCorner(extent, corner)).to.eql([1, 2]);
});
it('gets the bottom right', function() {
var corner = 'bottom-right';
expect(ol.extent.getCorner(extent, corner)).to.eql([3, 2]);
});
it('gets the top left', function() {
var corner = 'top-left';
expect(ol.extent.getCorner(extent, corner)).to.eql([1, 4]);
});
it('gets the top right', function() {
var corner = 'top-right';
expect(ol.extent.getCorner(extent, corner)).to.eql([3, 4]);
});
it('throws exception for unexpected corner', function() {
expect(function() {
ol.extent.getCorner(extent, 'foobar');
}).to.throwException();
});
});
describe('getEnlargedArea', function() {
it('returns enlarged area of two extents', function() {
var extent1 = [-1, -1, 0, 0];
var extent2 = [0, 0, 1, 1];
var enlargedArea = ol.extent.getEnlargedArea(extent1, extent2);
expect(enlargedArea).to.be(4);
});
});
describe('getForViewAndSize', function() {
it('works for a unit square', function() {
var extent = ol.extent.getForViewAndSize(
[0, 0], 1, 0, [1, 1]);
expect(extent[0]).to.be(-0.5);
expect(extent[2]).to.be(0.5);
expect(extent[1]).to.be(-0.5);
expect(extent[3]).to.be(0.5);
});
it('works for center', function() {
var extent = ol.extent.getForViewAndSize(
[5, 10], 1, 0, [1, 1]);
expect(extent[0]).to.be(4.5);
expect(extent[2]).to.be(5.5);
expect(extent[1]).to.be(9.5);
expect(extent[3]).to.be(10.5);
});
it('works for rotation', function() {
var extent = ol.extent.getForViewAndSize(
[0, 0], 1, Math.PI / 4, [1, 1]);
expect(extent[0]).to.roughlyEqual(-Math.sqrt(0.5), 1e-9);
expect(extent[2]).to.roughlyEqual(Math.sqrt(0.5), 1e-9);
expect(extent[1]).to.roughlyEqual(-Math.sqrt(0.5), 1e-9);
expect(extent[3]).to.roughlyEqual(Math.sqrt(0.5), 1e-9);
});
it('works for resolution', function() {
var extent = ol.extent.getForViewAndSize(
[0, 0], 2, 0, [1, 1]);
expect(extent[0]).to.be(-1);
expect(extent[2]).to.be(1);
expect(extent[1]).to.be(-1);
expect(extent[3]).to.be(1);
});
it('works for size', function() {
var extent = ol.extent.getForViewAndSize(
[0, 0], 1, 0, [10, 5]);
expect(extent[0]).to.be(-5);
expect(extent[2]).to.be(5);
expect(extent[1]).to.be(-2.5);
expect(extent[3]).to.be(2.5);
});
});
describe('getSize', function() {
it('returns the expected size', function() {
var extent = [0, 1, 2, 4];
var size = ol.extent.getSize(extent);
expect(size).to.eql([2, 3]);
});
});
describe('getIntersectionArea', function() {
it('returns correct area when extents intersect', function() {
var extent1 = [0, 0, 2, 2];
var extent2 = [1, 1, 3, 3];
var intersectionArea = ol.extent.getIntersectionArea(extent1, extent2);
expect(intersectionArea).to.be(1);
});
it('returns 0 when extents do not intersect', function() {
var extent1 = [0, 0, 1, 1];
var extent2 = [2, 2, 3, 3];
var intersectionArea = ol.extent.getIntersectionArea(extent1, extent2);
expect(intersectionArea).to.be(0);
});
});
describe('getMargin', function() {
it('returns the correct margin (sum of width and height)', function() {
var extent = [1, 2, 3, 4];
expect(ol.extent.getMargin(extent)).to.be(4);
});
});
describe('intersects', function() {
it('returns the expected value', function() {
var intersects = ol.extent.intersects;
var extent = [50, 50, 100, 100];
expect(intersects(extent, extent)).to.be(true);
expect(intersects(extent, [20, 20, 80, 80])).to.be(true);
expect(intersects(extent, [20, 50, 80, 100])).to.be(true);
expect(intersects(extent, [20, 80, 80, 120])).to.be(true);
expect(intersects(extent, [50, 20, 100, 80])).to.be(true);
expect(intersects(extent, [50, 80, 100, 120])).to.be(true);
expect(intersects(extent, [80, 20, 120, 80])).to.be(true);
expect(intersects(extent, [80, 50, 120, 100])).to.be(true);
expect(intersects(extent, [80, 80, 120, 120])).to.be(true);
expect(intersects(extent, [20, 20, 120, 120])).to.be(true);
expect(intersects(extent, [70, 70, 80, 80])).to.be(true);
expect(intersects(extent, [10, 10, 30, 30])).to.be(false);
expect(intersects(extent, [30, 10, 70, 30])).to.be(false);
expect(intersects(extent, [50, 10, 100, 30])).to.be(false);
expect(intersects(extent, [80, 10, 120, 30])).to.be(false);
expect(intersects(extent, [120, 10, 140, 30])).to.be(false);
expect(intersects(extent, [10, 30, 30, 70])).to.be(false);
expect(intersects(extent, [120, 30, 140, 70])).to.be(false);
expect(intersects(extent, [10, 50, 30, 100])).to.be(false);
expect(intersects(extent, [120, 50, 140, 100])).to.be(false);
expect(intersects(extent, [10, 80, 30, 120])).to.be(false);
expect(intersects(extent, [120, 80, 140, 120])).to.be(false);
expect(intersects(extent, [10, 120, 30, 140])).to.be(false);
expect(intersects(extent, [30, 120, 70, 140])).to.be(false);
expect(intersects(extent, [50, 120, 100, 140])).to.be(false);
expect(intersects(extent, [80, 120, 120, 140])).to.be(false);
expect(intersects(extent, [120, 120, 140, 140])).to.be(false);
});
});
describe('scaleFromCenter', function() {
it('scales the extent from its center', function() {
var extent = [1, 1, 3, 3];
ol.extent.scaleFromCenter(extent, 2);
expect(extent[0]).to.eql(0);
expect(extent[2]).to.eql(4);
expect(extent[1]).to.eql(0);
expect(extent[3]).to.eql(4);
});
});
describe('intersectsSegment()', function() {
var extent = [-180, -90, 180, 90];
var north = [0, 100];
var northeast = [190, 100];
var east = [190, 0];
var southeast = [190, -100];
var south = [0, -100];
var southwest = [-190, -100];
var west = [-190, 0];
var northwest = [-190, 100];
var center = [0, 0];
var top = [0, 90];
var right = [180, 0];
var bottom = [-90, 0];
var left = [-180, 0];
var inside = [10, 10];
it('returns true if contained', function() {
var intersects = ol.extent.intersectsSegment(extent, center, inside);
expect(intersects).to.be(true);
});
it('returns true if crosses top', function() {
var intersects = ol.extent.intersectsSegment(extent, center, north);
expect(intersects).to.be(true);
});
it('returns true if crosses right', function() {
var intersects = ol.extent.intersectsSegment(extent, center, east);
expect(intersects).to.be(true);
});
it('returns true if crosses bottom', function() {
var intersects = ol.extent.intersectsSegment(extent, center, south);
expect(intersects).to.be(true);
});
it('returns true if crosses left', function() {
var intersects = ol.extent.intersectsSegment(extent, center, west);
expect(intersects).to.be(true);
});
it('returns false if above', function() {
var intersects = ol.extent.intersectsSegment(extent, northwest, north);
expect(intersects).to.be(false);
});
it('returns false if right', function() {
var intersects = ol.extent.intersectsSegment(extent, northeast, east);
expect(intersects).to.be(false);
});
it('returns false if below', function() {
var intersects = ol.extent.intersectsSegment(extent, south, southwest);
expect(intersects).to.be(false);
});
it('returns false if left', function() {
var intersects = ol.extent.intersectsSegment(extent, west, southwest);
expect(intersects).to.be(false);
});
it('returns true if crosses top to bottom', function() {
var intersects = ol.extent.intersectsSegment(extent, north, south);
expect(intersects).to.be(true);
});
it('returns true if crosses bottom to top', function() {
var intersects = ol.extent.intersectsSegment(extent, south, north);
expect(intersects).to.be(true);
});
it('returns true if crosses left to right', function() {
var intersects = ol.extent.intersectsSegment(extent, west, east);
expect(intersects).to.be(true);
});
it('returns true if crosses right to left', function() {
var intersects = ol.extent.intersectsSegment(extent, east, west);
expect(intersects).to.be(true);
});
it('returns true if crosses northwest to east', function() {
var intersects = ol.extent.intersectsSegment(extent, northwest, east);
expect(intersects).to.be(true);
});
it('returns true if crosses south to west', function() {
var intersects = ol.extent.intersectsSegment(extent, south, west);
expect(intersects).to.be(true);
});
it('returns true if touches top', function() {
var intersects = ol.extent.intersectsSegment(extent, northwest, top);
expect(intersects).to.be(true);
});
it('returns true if touches right', function() {
var intersects = ol.extent.intersectsSegment(extent, southeast, right);
expect(intersects).to.be(true);
});
it('returns true if touches bottom', function() {
var intersects = ol.extent.intersectsSegment(extent, bottom, south);
expect(intersects).to.be(true);
});
it('returns true if touches left', function() {
var intersects = ol.extent.intersectsSegment(extent, left, west);
expect(intersects).to.be(true);
});
it('works for zero length inside', function() {
var intersects = ol.extent.intersectsSegment(extent, center, center);
expect(intersects).to.be(true);
});
it('works for zero length outside', function() {
var intersects = ol.extent.intersectsSegment(extent, north, north);
expect(intersects).to.be(false);
});
it('works for left/right intersection spanning top to bottom', function() {
var extent = [2, 1, 3, 4];
var start = [0, 0];
var end = [5, 5];
expect(ol.extent.intersectsSegment(extent, start, end)).to.be(true);
expect(ol.extent.intersectsSegment(extent, end, start)).to.be(true);
});
it('works for top/bottom intersection spanning left to right', function() {
var extent = [1, 2, 4, 3];
var start = [0, 0];
var end = [5, 5];
expect(ol.extent.intersectsSegment(extent, start, end)).to.be(true);
expect(ol.extent.intersectsSegment(extent, end, start)).to.be(true);
});
});
describe('#applyTransform()', function() {
it('does transform', function() {
var transformFn = ol.proj.getTransform('EPSG:4326', 'EPSG:3857');
var sourceExtent = [-15, -30, 45, 60];
var destinationExtent = ol.extent.applyTransform(
sourceExtent, transformFn);
expect(destinationExtent).not.to.be(undefined);
expect(destinationExtent).not.to.be(null);
// FIXME check values with third-party tool
expect(destinationExtent[0])
.to.roughlyEqual(-1669792.3618991037, 1e-9);
expect(destinationExtent[2]).to.roughlyEqual(5009377.085697311, 1e-9);
expect(destinationExtent[1]).to.roughlyEqual(-3503549.843504376, 1e-8);
expect(destinationExtent[3]).to.roughlyEqual(8399737.889818361, 1e-8);
});
it('takes arbitrary function', function() {
var transformFn = function(input, output, opt_dimension) {
var dimension = opt_dimension !== undefined ? opt_dimension : 2;
if (output === undefined) {
output = new Array(input.length);
}
var n = input.length;
var i;
for (i = 0; i < n; i += dimension) {
output[i] = -input[i];
output[i + 1] = -input[i + 1];
}
return output;
};
var sourceExtent = [-15, -30, 45, 60];
var destinationExtent = ol.extent.applyTransform(
sourceExtent, transformFn);
expect(destinationExtent).not.to.be(undefined);
expect(destinationExtent).not.to.be(null);
expect(destinationExtent[0]).to.be(-45);
expect(destinationExtent[2]).to.be(15);
expect(destinationExtent[1]).to.be(-60);
expect(destinationExtent[3]).to.be(30);
});
});
});
| bsd-2-clause |
nhejazi/scikit-learn | doc/conf.py | 9924 | # -*- coding: utf-8 -*-
#
# scikit-learn documentation build configuration file, created by
# sphinx-quickstart on Fri Jan 8 09:13:42 2010.
#
# This file is execfile()d with the current directory set to its containing
# dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
from __future__ import print_function
import sys
import os
from sklearn.externals.six import u
# If extensions (or modules to document with autodoc) are in another
# directory, add these directories to sys.path here. If the directory
# is relative to the documentation root, use os.path.abspath to make it
# absolute, like shown here.
sys.path.insert(0, os.path.abspath('sphinxext'))
from github_link import make_linkcode_resolve
import sphinx_gallery
# -- General configuration ---------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
'sphinx.ext.autodoc', 'sphinx.ext.autosummary',
'numpydoc',
'sphinx.ext.linkcode', 'sphinx.ext.doctest',
'sphinx_gallery.gen_gallery',
'sphinx_issues',
]
# this is needed for some reason...
# see https://github.com/numpy/numpydoc/issues/69
numpydoc_class_members_toctree = False
# pngmath / imgmath compatibility layer for different sphinx versions
import sphinx
from distutils.version import LooseVersion
if LooseVersion(sphinx.__version__) < LooseVersion('1.4'):
extensions.append('sphinx.ext.pngmath')
else:
extensions.append('sphinx.ext.imgmath')
autodoc_default_flags = ['members', 'inherited-members']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['templates']
# generate autosummary even if no references
autosummary_generate = True
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8'
# Generate the plots for the gallery
plot_gallery = True
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u('scikit-learn')
copyright = u('2007 - 2017, scikit-learn developers (BSD License)')
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
import sklearn
version = sklearn.__version__
# The full version, including alpha/beta/rc tags.
release = sklearn.__version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of documents that shouldn't be included in the build.
#unused_docs = []
# List of directories, relative to source directory, that shouldn't be
# searched for source files.
exclude_trees = ['_build', 'templates', 'includes']
# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
add_function_parentheses = False
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. Major themes that come with
# Sphinx are currently 'default' and 'sphinxdoc'.
html_theme = 'scikit-learn'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
html_theme_options = {'oldversion': False, 'collapsiblesidebar': True,
'google_analytics': True, 'surveybanner': False,
'sprintbanner': True}
# Add any paths that contain custom themes here, relative to this directory.
html_theme_path = ['themes']
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
html_short_title = 'scikit-learn'
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
html_logo = 'logos/scikit-learn-logo-small.png'
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
html_favicon = 'logos/favicon.ico'
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['images']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
html_domain_indices = False
# If false, no index is generated.
html_use_index = False
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = ''
# Output file base name for HTML help builder.
htmlhelp_basename = 'scikit-learndoc'
# -- Options for LaTeX output ------------------------------------------------
# The paper size ('letter' or 'a4').
#latex_paper_size = 'letter'
# The font size ('10pt', '11pt' or '12pt').
#latex_font_size = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass
# [howto/manual]).
latex_documents = [('index', 'user_guide.tex', u('scikit-learn user guide'),
u('scikit-learn developers'), 'manual'), ]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
latex_logo = "logos/scikit-learn-logo.png"
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# Additional stuff for the LaTeX preamble.
latex_preamble = r"""
\usepackage{amsmath}\usepackage{amsfonts}\usepackage{bm}\usepackage{morefloats}
\usepackage{enumitem} \setlistdepth{10}
"""
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
latex_domain_indices = False
trim_doctests_flags = True
sphinx_gallery_conf = {
'doc_module': 'sklearn',
'backreferences_dir': os.path.join('modules', 'generated'),
'reference_url': {
'sklearn': None,
'matplotlib': 'http://matplotlib.org',
'numpy': 'http://docs.scipy.org/doc/numpy-1.8.1',
'scipy': 'http://docs.scipy.org/doc/scipy-0.13.3/reference'}
}
# The following dictionary contains the information used to create the
# thumbnails for the front page of the scikit-learn home page.
# key: first image in set
# values: (number of plot in set, height of thumbnail)
carousel_thumbs = {'sphx_glr_plot_classifier_comparison_001.png': 600,
'sphx_glr_plot_outlier_detection_003.png': 372,
'sphx_glr_plot_gpr_co2_001.png': 350,
'sphx_glr_plot_adaboost_twoclass_001.png': 372,
'sphx_glr_plot_compare_methods_001.png': 349}
def make_carousel_thumbs(app, exception):
"""produces the final resized carousel images"""
if exception is not None:
return
print('Preparing carousel images')
image_dir = os.path.join(app.builder.outdir, '_images')
for glr_plot, max_width in carousel_thumbs.items():
image = os.path.join(image_dir, glr_plot)
if os.path.exists(image):
c_thumb = os.path.join(image_dir, glr_plot[:-4] + '_carousel.png')
sphinx_gallery.gen_rst.scale_image(image, c_thumb, max_width, 190)
# Config for sphinx_issues
issues_uri = 'https://github.com/scikit-learn/scikit-learn/issues/{issue}'
issues_github_path = 'scikit-learn/scikit-learn'
issues_user_uri = 'https://github.com/{user}'
def setup(app):
# to hide/show the prompt in code examples:
app.add_javascript('js/copybutton.js')
app.connect('build-finished', make_carousel_thumbs)
# The following is used by sphinx.ext.linkcode to provide links to github
linkcode_resolve = make_linkcode_resolve('sklearn',
u'https://github.com/scikit-learn/'
'scikit-learn/blob/{revision}/'
'{package}/{path}#L{lineno}')
| bsd-3-clause |
safarijv/urlrewritefilter | src/main/java/org/tuckey/web/filters/urlrewrite/Conf.java | 23779 | /**
* Copyright (c) 2005-2007, Paul Tuckey
* All rights reserved.
* ====================================================================
* Licensed under the BSD License. Text as follows.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* - Neither the name tuckey.org nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*/
package org.tuckey.web.filters.urlrewrite;
import org.tuckey.web.filters.urlrewrite.gzip.GzipFilter;
import org.tuckey.web.filters.urlrewrite.utils.Log;
import org.tuckey.web.filters.urlrewrite.utils.ModRewriteConfLoader;
import org.tuckey.web.filters.urlrewrite.utils.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXParseException;
import javax.servlet.ServletContext;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* Configuration object for urlrewrite filter.
*
* @author Paul Tuckey
* @version $Revision: 43 $ $Date: 2006-10-31 17:29:59 +1300 (Tue, 31 Oct 2006) $
*/
public class Conf {
private static Log log = Log.getLog(Conf.class);
private final List errors = new ArrayList();
private final List rules = new ArrayList(50);
private final List catchElems = new ArrayList(10);
private List outboundRules = new ArrayList(50);
private boolean ok = false;
private Date loadedDate = null;
private int ruleIdCounter = 0;
private int outboundRuleIdCounter = 0;
private String fileName;
private String confSystemId;
protected boolean useQueryString;
protected boolean useContext;
private static final String NONE_DECODE_USING = "null";
private static final String HEADER_DECODE_USING = "header";
private static final String DEFAULT_DECODE_USING = "header,utf-8";
protected String decodeUsing = DEFAULT_DECODE_USING;
private boolean decodeUsingEncodingHeader;
protected String defaultMatchType = null;
private ServletContext context;
private boolean docProcessed = false;
private boolean engineEnabled = true;
/**
* Empty const for testing etc.
*/
public Conf() {
loadedDate = new Date();
}
/**
* Constructor for use only when loading XML style configuration.
*
* @param fileName to display on status screen
*/
public Conf(ServletContext context, final InputStream inputStream, String fileName, String systemId) {
this(context, inputStream, fileName, systemId, false);
}
/**
* Normal constructor.
*
* @param fileName to display on status screen
* @param modRewriteStyleConf true if loading mod_rewrite style conf
*/
public Conf(ServletContext context, final InputStream inputStream, String fileName, String systemId,
boolean modRewriteStyleConf) {
// make sure context is setup before calling initialise()
this.context = context;
this.fileName = fileName;
this.confSystemId = systemId;
if (modRewriteStyleConf) {
loadModRewriteStyle(inputStream);
} else {
loadDom(inputStream);
}
if (docProcessed) initialise();
loadedDate = new Date();
}
protected void loadModRewriteStyle(InputStream inputStream) {
ModRewriteConfLoader loader = new ModRewriteConfLoader();
try {
loader.process(inputStream, this);
docProcessed = true; // fixed
} catch (IOException e) {
addError("Exception loading conf " + " " + e.getMessage(), e);
}
}
/**
* Constructor when run elements don't need to be initialised correctly, for docuementation etc.
*/
public Conf(URL confUrl) {
// make sure context is setup before calling initialise()
this.context = null;
this.fileName = confUrl.getFile();
this.confSystemId = confUrl.toString();
try {
loadDom(confUrl.openStream());
} catch (IOException e) {
addError("Exception loading conf " + " " + e.getMessage(), e);
}
if (docProcessed) initialise();
loadedDate = new Date();
}
/**
* Constructor when run elements don't need to be initialised correctly, for docuementation etc.
*/
public Conf(InputStream inputStream, String conffile) {
this(null, inputStream, conffile, conffile);
}
/**
* Load the dom document from the inputstream
* <p/>
* Note, protected so that is can be extended.
*
* @param inputStream stream of the conf file to load
*/
protected synchronized void loadDom(final InputStream inputStream) {
if (inputStream == null) {
log.error("inputstream is null");
return;
}
DocumentBuilder parser;
/**
* the thing that resolves dtd's and other xml entities.
*/
ConfHandler handler = new ConfHandler(confSystemId);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
log.debug("XML builder factory is: " + factory.getClass().getName());
factory.setValidating(true);
factory.setNamespaceAware(true);
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(true);
try {
parser = factory.newDocumentBuilder();
} catch (ParserConfigurationException e) {
log.error("Unable to setup XML parser for reading conf", e);
return;
}
log.debug("XML Parser: " + parser.getClass().getName());
parser.setErrorHandler(handler);
parser.setEntityResolver(handler);
try {
log.debug("about to parse conf");
Document doc = parser.parse(inputStream, confSystemId);
processConfDoc(doc);
} catch (SAXParseException e) {
addError("Parse error on line " + e.getLineNumber() + " " + e.getMessage(), e);
} catch (Exception e) {
addError("Exception loading conf " + " " + e.getMessage(), e);
}
}
/**
* Process dom document and populate Conf object.
* <p/>
* Note, protected so that is can be extended.
*/
protected void processConfDoc(Document doc) {
Element rootElement = doc.getDocumentElement();
if ("true".equalsIgnoreCase(getAttrValue(rootElement, "use-query-string"))) setUseQueryString(true);
if ("true".equalsIgnoreCase(getAttrValue(rootElement, "use-context"))) {
log.debug("use-context set to true");
setUseContext(true);
}
setDecodeUsing(getAttrValue(rootElement, "decode-using"));
setDefaultMatchType(getAttrValue(rootElement, "default-match-type"));
NodeList rootElementList = rootElement.getChildNodes();
for (int i = 0; i < rootElementList.getLength(); i++) {
Node node = rootElementList.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE &&
((Element) node).getTagName().equals("rule")) {
Element ruleElement = (Element) node;
// we have a rule node
NormalRule rule = new NormalRule();
processRuleBasics(ruleElement, rule);
procesConditions(ruleElement, rule);
processRuns(ruleElement, rule);
Node toNode = ruleElement.getElementsByTagName("to").item(0);
rule.setTo(getNodeValue(toNode));
rule.setToType(getAttrValue(toNode, "type"));
rule.setToContextStr(getAttrValue(toNode, "context"));
rule.setToLast(getAttrValue(toNode, "last"));
rule.setQueryStringAppend(getAttrValue(toNode, "qsappend"));
if ("true".equalsIgnoreCase(getAttrValue(toNode, "encode"))) rule.setEncodeToUrl(true);
processSetAttributes(ruleElement, rule);
addRule(rule);
} else if (node.getNodeType() == Node.ELEMENT_NODE &&
((Element) node).getTagName().equals("class-rule")) {
Element ruleElement = (Element) node;
ClassRule classRule = new ClassRule();
if ("false".equalsIgnoreCase(getAttrValue(ruleElement, "enabled"))) classRule.setEnabled(false);
if ("false".equalsIgnoreCase(getAttrValue(ruleElement, "last"))) classRule.setLast(false);
classRule.setClassStr(getAttrValue(ruleElement, "class"));
classRule.setMethodStr(getAttrValue(ruleElement, "method"));
addRule(classRule);
} else if (node.getNodeType() == Node.ELEMENT_NODE &&
((Element) node).getTagName().equals("outbound-rule")) {
Element ruleElement = (Element) node;
// we have a rule node
OutboundRule rule = new OutboundRule();
processRuleBasics(ruleElement, rule);
if ("true".equalsIgnoreCase(getAttrValue(ruleElement, "encodefirst"))) rule.setEncodeFirst(true);
procesConditions(ruleElement, rule);
processRuns(ruleElement, rule);
Node toNode = ruleElement.getElementsByTagName("to").item(0);
rule.setTo(getNodeValue(toNode));
rule.setToLast(getAttrValue(toNode, "last"));
if ("false".equalsIgnoreCase(getAttrValue(toNode, "encode"))) rule.setEncodeToUrl(false);
processSetAttributes(ruleElement, rule);
addOutboundRule(rule);
} else if (node.getNodeType() == Node.ELEMENT_NODE &&
((Element) node).getTagName().equals("catch")) {
Element catchXMLElement = (Element) node;
// we have a rule node
CatchElem catchElem = new CatchElem();
catchElem.setClassStr(getAttrValue(catchXMLElement, "class"));
processRuns(catchXMLElement, catchElem);
catchElems.add(catchElem);
}
}
docProcessed = true;
}
private void processRuleBasics(Element ruleElement, RuleBase rule) {
if ("false".equalsIgnoreCase(getAttrValue(ruleElement, "enabled"))) rule.setEnabled(false);
String ruleMatchType = getAttrValue(ruleElement, "match-type");
if (StringUtils.isBlank(ruleMatchType)) ruleMatchType = defaultMatchType;
rule.setMatchType(ruleMatchType);
Node nameNode = ruleElement.getElementsByTagName("name").item(0);
rule.setName(getNodeValue(nameNode));
Node noteNode = ruleElement.getElementsByTagName("note").item(0);
rule.setNote(getNodeValue(noteNode));
Node fromNode = ruleElement.getElementsByTagName("from").item(0);
rule.setFrom(getNodeValue(fromNode));
if ("true".equalsIgnoreCase(getAttrValue(fromNode, "casesensitive"))) rule.setFromCaseSensitive(true);
}
private static void processSetAttributes(Element ruleElement, RuleBase rule) {
NodeList setNodes = ruleElement.getElementsByTagName("set");
for (int j = 0; j < setNodes.getLength(); j++) {
Node setNode = setNodes.item(j);
if (setNode == null) continue;
SetAttribute setAttribute = new SetAttribute();
setAttribute.setValue(getNodeValue(setNode));
setAttribute.setType(getAttrValue(setNode, "type"));
setAttribute.setName(getAttrValue(setNode, "name"));
rule.addSetAttribute(setAttribute);
}
}
private static void processRuns(Element ruleElement, Runnable runnable) {
NodeList runNodes = ruleElement.getElementsByTagName("run");
for (int j = 0; j < runNodes.getLength(); j++) {
Node runNode = runNodes.item(j);
if (runNode == null) continue;
Run run = new Run();
processInitParams(runNode, run);
run.setClassStr(getAttrValue(runNode, "class"));
run.setMethodStr(getAttrValue(runNode, "method"));
run.setJsonHandler("true".equalsIgnoreCase(getAttrValue(runNode, "jsonhandler")));
run.setNewEachTime("true".equalsIgnoreCase(getAttrValue(runNode, "neweachtime")));
runnable.addRun(run);
}
// gzip element is just a shortcut to run: org.tuckey.web.filters.urlrewrite.gzip.GzipFilter
NodeList gzipNodes = ruleElement.getElementsByTagName("gzip");
for (int j = 0; j < gzipNodes.getLength(); j++) {
Node runNode = gzipNodes.item(j);
if (runNode == null) continue;
Run run = new Run();
run.setClassStr(GzipFilter.class.getName());
run.setMethodStr("doFilter(ServletRequest, ServletResponse, FilterChain)");
processInitParams(runNode, run);
runnable.addRun(run);
}
}
private static void processInitParams(Node runNode, Run run) {
if (runNode.getNodeType() == Node.ELEMENT_NODE) {
Element runElement = (Element) runNode;
NodeList initParamsNodeList = runElement.getElementsByTagName("init-param");
for (int k = 0; k < initParamsNodeList.getLength(); k++) {
Node initParamNode = initParamsNodeList.item(k);
if (initParamNode == null) continue;
if (initParamNode.getNodeType() != Node.ELEMENT_NODE) continue;
Element initParamElement = (Element) initParamNode;
Node paramNameNode = initParamElement.getElementsByTagName("param-name").item(0);
Node paramValueNode = initParamElement.getElementsByTagName("param-value").item(0);
run.addInitParam(getNodeValue(paramNameNode), getNodeValue(paramValueNode));
}
}
}
private static void procesConditions(Element ruleElement, RuleBase rule) {
NodeList conditionNodes = ruleElement.getElementsByTagName("condition");
for (int j = 0; j < conditionNodes.getLength(); j++) {
Node conditionNode = conditionNodes.item(j);
if (conditionNode == null) continue;
Condition condition = new Condition();
condition.setValue(getNodeValue(conditionNode));
condition.setType(getAttrValue(conditionNode, "type"));
condition.setName(getAttrValue(conditionNode, "name"));
condition.setNext(getAttrValue(conditionNode, "next"));
condition.setCaseSensitive("true".equalsIgnoreCase(getAttrValue(conditionNode, "casesensitive")));
condition.setOperator(getAttrValue(conditionNode, "operator"));
rule.addCondition(condition);
}
}
private static String getNodeValue(Node node) {
if (node == null) return null;
NodeList nodeList = node.getChildNodes();
if (nodeList == null) return null;
Node child = nodeList.item(0);
if (child == null) return null;
if ((child.getNodeType() == Node.TEXT_NODE)) {
String value = ((Text) child).getData();
return value.trim();
}
return null;
}
private static String getAttrValue(Node n, String attrName) {
if (n == null) return null;
NamedNodeMap attrs = n.getAttributes();
if (attrs == null) return null;
Node attr = attrs.getNamedItem(attrName);
if (attr == null) return null;
String val = attr.getNodeValue();
if (val == null) return null;
return val.trim();
}
/**
* Initialise the conf file. This will run initialise on each rule and condition in the conf file.
*/
public void initialise() {
if (log.isDebugEnabled()) {
log.debug("now initialising conf");
}
initDecodeUsing(decodeUsing);
boolean rulesOk = true;
for (int i = 0; i < rules.size(); i++) {
final Rule rule = (Rule) rules.get(i);
if (!rule.initialise(context)) {
// if we failed to initialise anything set the status to bad
rulesOk = false;
}
}
for (int i = 0; i < outboundRules.size(); i++) {
final OutboundRule outboundRule = (OutboundRule) outboundRules.get(i);
if (!outboundRule.initialise(context)) {
// if we failed to initialise anything set the status to bad
rulesOk = false;
}
}
for (int i = 0; i < catchElems.size(); i++) {
final CatchElem catchElem = (CatchElem) catchElems.get(i);
if (!catchElem.initialise(context)) {
// if we failed to initialise anything set the status to bad
rulesOk = false;
}
}
if (rulesOk) {
ok = true;
}
if (log.isDebugEnabled()) {
log.debug("conf status " + ok);
}
}
private void initDecodeUsing(String decodeUsingSetting) {
decodeUsingSetting = StringUtils.trimToNull(decodeUsingSetting);
if (decodeUsingSetting == null) decodeUsingSetting = DEFAULT_DECODE_USING;
if ( decodeUsingSetting.equalsIgnoreCase(HEADER_DECODE_USING)) { // is 'header'
decodeUsingEncodingHeader = true;
decodeUsingSetting = null;
} else if ( decodeUsingSetting.startsWith(HEADER_DECODE_USING + ",")) { // is 'header,xxx'
decodeUsingEncodingHeader = true;
decodeUsingSetting = decodeUsingSetting.substring((HEADER_DECODE_USING + ",").length());
}
if (NONE_DECODE_USING.equalsIgnoreCase(decodeUsingSetting)) {
decodeUsingSetting = null;
}
if ( decodeUsingSetting != null ) {
try {
URLDecoder.decode("testUrl", decodeUsingSetting);
this.decodeUsing = decodeUsingSetting;
} catch (UnsupportedEncodingException e) {
addError("unsupported 'decodeusing' " + decodeUsingSetting + " see Java SDK docs for supported encodings");
}
} else {
this.decodeUsing = null;
}
}
/**
* Destory the conf gracefully.
*/
public void destroy() {
for (int i = 0; i < rules.size(); i++) {
final Rule rule = (Rule) rules.get(i);
rule.destroy();
}
}
/**
* Will add the rule to the rules list.
*
* @param rule The Rule to add
*/
public void addRule(final Rule rule) {
rule.setId(ruleIdCounter++);
rules.add(rule);
}
/**
* Will add the rule to the rules list.
*
* @param outboundRule The outbound rule to add
*/
public void addOutboundRule(final OutboundRule outboundRule) {
outboundRule.setId(outboundRuleIdCounter++);
outboundRules.add(outboundRule);
}
/**
* Will get the List of errors.
*
* @return the List of errors
*/
public List getErrors() {
return errors;
}
/**
* Will get the List of rules.
*
* @return the List of rules
*/
public List getRules() {
return rules;
}
/**
* Will get the List of outbound rules.
*
* @return the List of outbound rules
*/
public List getOutboundRules() {
return outboundRules;
}
/**
* true if the conf has been loaded ok.
*
* @return boolean
*/
public boolean isOk() {
return ok;
}
private void addError(final String errorMsg, final Exception e) {
errors.add(errorMsg);
log.error(errorMsg, e);
}
private void addError(final String errorMsg) {
errors.add(errorMsg);
}
public Date getLoadedDate() {
return (Date) loadedDate.clone();
}
public String getFileName() {
return fileName;
}
public boolean isUseQueryString() {
return useQueryString;
}
public void setUseQueryString(boolean useQueryString) {
this.useQueryString = useQueryString;
}
public boolean isUseContext() {
return useContext;
}
public void setUseContext(boolean useContext) {
this.useContext = useContext;
}
public String getDecodeUsing() {
return decodeUsing;
}
public void setDecodeUsing(String decodeUsing) {
this.decodeUsing = decodeUsing;
}
public void setDefaultMatchType(String defaultMatchType) {
if (RuleBase.MATCH_TYPE_WILDCARD.equalsIgnoreCase(defaultMatchType)) {
this.defaultMatchType = RuleBase.MATCH_TYPE_WILDCARD;
} else {
this.defaultMatchType = RuleBase.DEFAULT_MATCH_TYPE;
}
}
public String getDefaultMatchType() {
return defaultMatchType;
}
public List getCatchElems() {
return catchElems;
}
public boolean isDecodeUsingCustomCharsetRequired() {
return decodeUsing != null;
}
public boolean isEngineEnabled() {
return engineEnabled;
}
public void setEngineEnabled(boolean engineEnabled) {
this.engineEnabled = engineEnabled;
}
public boolean isLoadedFromFile() {
return fileName != null;
}
public boolean isDecodeUsingEncodingHeader() {
return decodeUsingEncodingHeader;
}
}
| bsd-3-clause |
youtube/cobalt | third_party/llvm-project/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp | 669 | //===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <string>
// template<> struct char_traits<char32_t>
// static constexpr int_type eof();
#include <string>
#include <cassert>
int main()
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
std::char_traits<char32_t>::int_type i = std::char_traits<char32_t>::eof();
((void)i); // Prevent unused warning
#endif
}
| bsd-3-clause |
gcds/project_xxx | nuttx/arch/avr/src/at32uc3/at32uc3_gpioirq.c | 11677 | /****************************************************************************
* arch/avr/src/at32uc3/at32uc3_gpioirq.c
* arch/avr/src/chip/at32uc3_gpioirq.c
*
* Copyright (C) 2010 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <[email protected]>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include "at32uc3_config.h"
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <arch/irq.h>
#include "up_arch.h"
#include "os_internal.h"
#include "irq_internal.h"
#include "at32uc3_internal.h"
#include "at32uc3_gpio.h"
#ifdef CONFIG_AVR32_GPIOIRQ
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/* A table of handlers for each GPIO interrupt */
static FAR xcpt_t g_gpiohandler[NR_GPIO_IRQS];
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: gpio_baseaddress
*
* Input:
* irq - A IRQ number in the range of 0 to NR_GPIO_IRQS.
*
* Description:
* Given a IRQ number, return the base address of the associated GPIO
* registers.
*
****************************************************************************/
static inline uint32_t gpio_baseaddress(unsigned int irq)
{
#if CONFIG_AVR32_GPIOIRQSETA != 0
if (irq < __IRQ_GPIO_PB0)
{
return AVR32_GPIO0_BASE;
}
else
#endif
#if CONFIG_AVR32_GPIOIRQSETB != 0
if (irq < NR_GPIO_IRQS)
{
return AVR32_GPIO1_BASE;
}
else
#endif
{
return 0;
}
}
/****************************************************************************
* Name: gpio_pin
*
* Input:
* irq - A IRQ number in the range of 0 to NR_GPIO_IRQS.
*
* Description:
* Given a GPIO number, return the pin number in the range of 0-31 on the
* corresponding port
*
****************************************************************************/
static inline int gpio_pin(unsigned int irq)
{
uint32_t pinset;
int pinirq;
int pin;
#if CONFIG_AVR32_GPIOIRQSETA != 0
if (irq < __IRQ_GPIO_PB0)
{
pinset = CONFIG_AVR32_GPIOIRQSETA;
pinirq = __IRQ_GPIO_PA0;
}
else
#endif
#if CONFIG_AVR32_GPIOIRQSETB != 0
if (irq < NR_GPIO_IRQS)
{
pinset = CONFIG_AVR32_GPIOIRQSETB;
pinirq = __IRQ_GPIO_PB0;
}
else
#endif
{
return -EINVAL;
}
/* Now we have to search for the pin with matching IRQ. Yech! We made
* life difficult here by choosing a sparse representation of IRQs on
* GPIO pins.
*/
for (pin = 0; pin < 32 && pinset != 0; pin++)
{
/* Is this pin at bit 0 configured for interrupt support? */
if ((pinset & 1) != 0)
{
/* Is it the on IRQ we are looking for? */
if (pinirq == irq)
{
/* Yes, return the associated pin number */
return pin;
}
/* No.. Increment the IRQ number for the next configured pin */
pinirq++;
}
/* Shift the next pin to position bit 0 */
pinset >>= 1;
}
return -EINVAL;
}
/****************************************************************************
* Name: gpio_porthandler
*
* Description:
* Dispatch GPIO interrupts on a specific GPIO port
*
****************************************************************************/
static void gpio_porthandler(uint32_t regbase, int irqbase, uint32_t irqset, void *context)
{
uint32_t ifr;
int irq;
int pin;
/* Check each bit and dispatch each pending interrupt in the interrupt flag
* register for this port.
*/
ifr = getreg32(regbase + AVR32_GPIO_IFR_OFFSET);
/* Dispatch each pending interrupt */
irq = irqbase;
for (pin = 0; pin < 32 && ifr != 0; pin++)
{
/* Is this pin configured for interrupt support? */
uint32_t bit = (1 << pin);
if ((irqset & bit) != 0)
{
/* Is an interrupt pending on this pin? */
if ((ifr & bit) != 0)
{
/* Yes.. Clear the pending interrupt */
putreg32(bit, regbase + AVR32_GPIO_IFRC_OFFSET);
ifr &= ~bit;
/* Dispatch handling for this pin */
xcpt_t handler = g_gpiohandler[irq];
if (handler)
{
handler(irq, context);
}
else
{
lldbg("No handler: pin=%d ifr=%08x irqset=%08x",
pin, ifr, irqset);
}
}
/* Increment the IRQ number on all configured pins */
irq++;
}
/* Not configured. An interrupt on this pin would be an error. */
else if ((ifr & bit) != 0)
{
/* Clear the pending interrupt */
putreg32(bit, regbase + AVR32_GPIO_IFRC_OFFSET);
ifr &= ~bit;
lldbg("IRQ on unconfigured pin: pin=%d ifr=%08x irqset=%08x",
pin, ifr, irqset);
}
}
}
/****************************************************************************
* Name: gpio0/1_interrupt
*
* Description:
* Handle GPIO0/1 interrupts
*
****************************************************************************/
#if CONFIG_AVR32_GPIOIRQSETA != 0
static int gpio0_interrupt(int irq, FAR void *context)
{
gpio_porthandler(AVR32_GPIO0_BASE, __IRQ_GPIO_PA0,
CONFIG_AVR32_GPIOIRQSETA, context);
return 0;
}
#endif
#if CONFIG_AVR32_GPIOIRQSETB != 0
static int gpio1_interrupt(int irq, FAR void *context)
{
gpio_porthandler(AVR32_GPIO1_BASE, __IRQ_GPIO_PB0,
CONFIG_AVR32_GPIOIRQSETB, context);
return 0;
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: gpio_irqinitialize
*
* Description:
* Initialize all vectors to the unexpected interrupt handler.
*
* Assumptions:
* Called during the early boot sequence before global interrupts have
* been enabled.
*
****************************************************************************/
void gpio_irqinitialize(void)
{
int i;
/* Point all interrupt vectors to the unexpected interrupt */
for (i = 0; i < NR_GPIO_IRQS; i++)
{
g_gpiohandler[i] = irq_unexpected_isr;
}
/* Then attach the GPIO interrupt handlers */
#if CONFIG_AVR32_GPIOIRQSETA != 0
irq_attach(AVR32_IRQ_GPIO0, gpio0_interrupt);
#endif
#if CONFIG_AVR32_GPIOIRQSETB != 0
irq_attach(AVR32_IRQ_GPIO1, gpio1_interrupt);
#endif
}
/****************************************************************************
* Name: gpio_irqattach
*
* Description:
* Attach in GPIO interrupt to the provide 'isr'
*
****************************************************************************/
int gpio_irqattach(int irq, xcpt_t newisr, xcpt_t *oldisr)
{
irqstate_t flags;
int ret = -EINVAL;
if ((unsigned)irq < NR_GPIO_IRQS)
{
/* If the new ISR is NULL, then the ISR is being detached. In this
* case, disable the ISR and direct any interrupts
* to the unexpected interrupt handler.
*/
flags = irqsave();
if (newisr == NULL)
{
gpio_irqdisable(irq);
newisr = irq_unexpected_isr;
}
/* Return the old ISR (in case the caller ever wants to restore it) */
if (oldisr)
{
*oldisr = g_gpiohandler[irq];
}
/* Then save the new ISR in the table. */
g_gpiohandler[irq] = newisr;
irqrestore(flags);
ret = OK;
}
return ret;
}
/****************************************************************************
* Name: gpio_irqenable
*
* Description:
* Enable the GPIO IRQ specified by 'irq'
*
****************************************************************************/
void gpio_irqenable(int irq)
{
uint32_t base;
int pin;
if ((unsigned)irq < NR_GPIO_IRQS)
{
/* Get the base address of the GPIO module associated with this IRQ */
base = gpio_baseaddress(irq);
/* Get the pin number associated with this IRQ. We made life difficult
* here by choosing a sparse representation of IRQs on GPIO pins.
*/
pin = gpio_pin(irq);
DEBUGASSERT(pin >= 0);
/* Enable the GPIO interrupt. */
putreg32((1 << pin), base + AVR32_GPIO_IERS_OFFSET);
}
}
/****************************************************************************
* Name: gpio_irqdisable
*
* Description:
* Disable the GPIO IRQ specified by 'irq'
*
****************************************************************************/
void gpio_irqdisable(int irq)
{
uint32_t base;
int pin;
if ((unsigned)irq < NR_GPIO_IRQS)
{
/* Get the base address of the GPIO module associated with this IRQ */
base = gpio_baseaddress(irq);
/* Get the pin number associated with this IRQ. We made life difficult
* here by choosing a sparse representation of IRQs on GPIO pins.
*/
pin = gpio_pin(irq);
DEBUGASSERT(pin >= 0);
/* Disable the GPIO interrupt. */
putreg32((1 << pin), base + AVR32_GPIO_IERC_OFFSET);
}
}
#endif /* CONFIG_AVR32_GPIOIRQ */
| bsd-3-clause |
astaxie/build-web-application-with-golang | th/05.0.md | 1206 | # 5 Database
For web developers, the database is at the core of web development. You can save almost anything into a database and query or update data inside it, like user information, products or news articles.
Go doesn't provide any database drivers, but it does have a driver interface defined in the `database/sql` package. People can develop database drivers based on that interface. In section 5.1, we are going to talk about database driver interface design in Go. In sections 5.2 to 5.4, I will introduce some SQL database drivers to you. In section 5.5, I will present the ORM that I have developed which is based on the `database/sql` interface standard. It is compatible with most drivers that have implemented the `database/sql` interface, and it makes it easy to access databases idiomatically in Go.
NoSQL has been a hot topic in recent years. More websites are deciding to use NoSQL databases as their main database instead of just for the purpose of caching. I will introduce you to two NoSQL databases, which are MongoDB and Redis, in section 5.6.
## Links
- [Directory](preface.md)
- Previous Chapter: [Chapter 4 Summary](04.6.md)
- Next section: [database/sql interface](05.1.md)
| bsd-3-clause |
chromium/chromium | content/test/data/accessibility/accname/name-checkbox-label-embedded-select.html | 285 | <!--
@BLINK-DENY:descri*
-->
<!doctype html>
<html>
<body>
<input type="checkbox" id="test" />
<label for="test">Flash the screen
<select size="1">
<option selected="selected">1</option>
<option>2</option>
<option>3</option>
</select>
times.
</label>
</body>
</html>
| bsd-3-clause |
juanchi008/playa_auto | web/phppgadmin/views.php | 27911 | <?php
/**
* Manage views in a database
*
* $Id: views.php,v 1.75 2007/12/15 22:57:43 ioguix Exp $
*/
// Include application functions
include_once('./libraries/lib.inc.php');
include_once('./classes/Gui.php');
$action = (isset($_REQUEST['action'])) ? $_REQUEST['action'] : '';
if (!isset($msg)) $msg = '';
/**
* Ask for select parameters and perform select
*/
function doSelectRows($confirm, $msg = '') {
global $data, $misc, $_no_output;
global $lang;
if ($confirm) {
$misc->printTrail('view');
$misc->printTitle($lang['strselect'], 'pg.sql.select');
$misc->printMsg($msg);
$attrs = $data->getTableAttributes($_REQUEST['view']);
echo "<form action=\"views.php\" method=\"post\" id=\"selectform\">\n";
if ($attrs->recordCount() > 0) {
// JavaScript for select all feature
echo "<script type=\"text/javascript\">\n";
echo "//<![CDATA[\n";
echo " function selectAll() {\n";
echo " for (var i=0; i<document.getElementById('selectform').elements.length; i++) {\n";
echo " var e = document.getElementById('selectform').elements[i];\n";
echo " if (e.name.indexOf('show') == 0) e.checked = document.getElementById('selectform').selectall.checked;\n";
echo " }\n";
echo " }\n";
echo "//]]>\n";
echo "</script>\n";
echo "<table>\n";
// Output table header
echo "<tr><th class=\"data\">{$lang['strshow']}</th><th class=\"data\">{$lang['strcolumn']}</th>";
echo "<th class=\"data\">{$lang['strtype']}</th><th class=\"data\">{$lang['stroperator']}</th>";
echo "<th class=\"data\">{$lang['strvalue']}</th></tr>";
$i = 0;
while (!$attrs->EOF) {
$attrs->fields['attnotnull'] = $data->phpBool($attrs->fields['attnotnull']);
// Set up default value if there isn't one already
if (!isset($_REQUEST['values'][$attrs->fields['attname']]))
$_REQUEST['values'][$attrs->fields['attname']] = null;
if (!isset($_REQUEST['ops'][$attrs->fields['attname']]))
$_REQUEST['ops'][$attrs->fields['attname']] = null;
// Continue drawing row
$id = (($i % 2) == 0 ? '1' : '2');
echo "<tr class=\"data{$id}\">\n";
echo "<td style=\"white-space:nowrap;\">";
echo "<input type=\"checkbox\" name=\"show[", htmlspecialchars($attrs->fields['attname']), "]\"",
isset($_REQUEST['show'][$attrs->fields['attname']]) ? ' checked="checked"' : '', " /></td>";
echo "<td style=\"white-space:nowrap;\">", $misc->printVal($attrs->fields['attname']), "</td>";
echo "<td style=\"white-space:nowrap;\">", $misc->printVal($data->formatType($attrs->fields['type'], $attrs->fields['atttypmod'])), "</td>";
echo "<td style=\"white-space:nowrap;\">";
echo "<select name=\"ops[{$attrs->fields['attname']}]\">\n";
foreach (array_keys($data->selectOps) as $v) {
echo "<option value=\"", htmlspecialchars($v), "\"", ($v == $_REQUEST['ops'][$attrs->fields['attname']]) ? ' selected="selected"' : '',
">", htmlspecialchars($v), "</option>\n";
}
echo "</select></td>\n";
echo "<td style=\"white-space:nowrap;\">", $data->printField("values[{$attrs->fields['attname']}]",
$_REQUEST['values'][$attrs->fields['attname']], $attrs->fields['type']), "</td>";
echo "</tr>\n";
$i++;
$attrs->moveNext();
}
// Select all checkbox
echo "<tr><td colspan=\"5\"><input type=\"checkbox\" id=\"selectall\" name=\"selectall\" onclick=\"javascript:selectAll()\" /><label for=\"selectall\">{$lang['strselectallfields']}</label></td></tr>";
echo "</table>\n";
}
else echo "<p>{$lang['strinvalidparam']}</p>\n";
echo "<p><input type=\"hidden\" name=\"action\" value=\"selectrows\" />\n";
echo "<input type=\"hidden\" name=\"view\" value=\"", htmlspecialchars($_REQUEST['view']), "\" />\n";
echo "<input type=\"hidden\" name=\"subject\" value=\"view\" />\n";
echo $misc->form;
echo "<input type=\"submit\" name=\"select\" value=\"{$lang['strselect']}\" />\n";
echo "<input type=\"submit\" name=\"cancel\" value=\"{$lang['strcancel']}\" /></p>\n";
echo "</form>\n";
}
else {
if (!isset($_POST['show'])) $_POST['show'] = array();
if (!isset($_POST['values'])) $_POST['values'] = array();
if (!isset($_POST['nulls'])) $_POST['nulls'] = array();
// Verify that they haven't supplied a value for unary operators
foreach ($_POST['ops'] as $k => $v) {
if ($data->selectOps[$v] == 'p' && $_POST['values'][$k] != '') {
doSelectRows(true, $lang['strselectunary']);
return;
}
}
if (sizeof($_POST['show']) == 0)
doSelectRows(true, $lang['strselectneedscol']);
else {
// Generate query SQL
$query = $data->getSelectSQL($_REQUEST['view'], array_keys($_POST['show']),
$_POST['values'], $_POST['ops']);
$_REQUEST['query'] = $query;
$_REQUEST['return'] = "schema";
$_no_output = true;
include('./display.php');
exit;
}
}
}
/**
* Show confirmation of drop and perform actual drop
*/
function doDrop($confirm) {
global $data, $misc;
global $lang, $_reload_browser;
if (empty($_REQUEST['view']) && empty($_REQUEST['ma'])) {
doDefault($lang['strspecifyviewtodrop']);
exit();
}
if ($confirm) {
$misc->printTrail('view');
$misc->printTitle($lang['strdrop'],'pg.view.drop');
echo "<form action=\"views.php\" method=\"post\">\n";
//If multi drop
if (isset($_REQUEST['ma'])) {
foreach($_REQUEST['ma'] as $v) {
$a = unserialize(htmlspecialchars_decode($v, ENT_QUOTES));
echo "<p>", sprintf($lang['strconfdropview'], $misc->printVal($a['view'])), "</p>\n";
echo '<input type="hidden" name="view[]" value="', htmlspecialchars($a['view']), "\" />\n";
}
}
else {
echo "<p>", sprintf($lang['strconfdropview'], $misc->printVal($_REQUEST['view'])), "</p>\n";
echo "<input type=\"hidden\" name=\"view\" value=\"", htmlspecialchars($_REQUEST['view']), "\" />\n";
}
echo "<input type=\"hidden\" name=\"action\" value=\"drop\" />\n";
echo $misc->form;
echo "<p><input type=\"checkbox\" id=\"cascade\" name=\"cascade\" /> <label for=\"cascade\">{$lang['strcascade']}</label></p>\n";
echo "<input type=\"submit\" name=\"drop\" value=\"{$lang['strdrop']}\" />\n";
echo "<input type=\"submit\" name=\"cancel\" value=\"{$lang['strcancel']}\" />\n";
echo "</form>\n";
}
else {
if (is_array($_POST['view'])) {
$msg='';
$status = $data->beginTransaction();
if ($status == 0) {
foreach($_POST['view'] as $s) {
$status = $data->dropView($s, isset($_POST['cascade']));
if ($status == 0)
$msg.= sprintf('%s: %s<br />', htmlentities($s, ENT_QUOTES, 'UTF-8'), $lang['strviewdropped']);
else {
$data->endTransaction();
doDefault(sprintf('%s%s: %s<br />', $msg, htmlentities($s, ENT_QUOTES, 'UTF-8'), $lang['strviewdroppedbad']));
return;
}
}
}
if($data->endTransaction() == 0) {
// Everything went fine, back to the Default page....
$_reload_browser = true;
doDefault($msg);
}
else doDefault($lang['strviewdroppedbad']);
}
else{
$status = $data->dropView($_POST['view'], isset($_POST['cascade']));
if ($status == 0) {
$_reload_browser = true;
doDefault($lang['strviewdropped']);
}
else
doDefault($lang['strviewdroppedbad']);
}
}
}
/**
* Sets up choices for table linkage, and which fields to select for the view we're creating
*/
function doSetParamsCreate($msg = '') {
global $data, $misc;
global $lang;
// Check that they've chosen tables for the view definition
if (!isset($_POST['formTables']) ) doWizardCreate($lang['strviewneedsdef']);
else {
// Initialise variables
if (!isset($_REQUEST['formView'])) $_REQUEST['formView'] = '';
if (!isset($_REQUEST['formComment'])) $_REQUEST['formComment'] = '';
$misc->printTrail('schema');
$misc->printTitle($lang['strcreateviewwiz'], 'pg.view.create');
$misc->printMsg($msg);
$tblCount = sizeof($_POST['formTables']);
//unserialize our schema/table information and store in arrSelTables
for ($i = 0; $i < $tblCount; $i++) {
$arrSelTables[] = unserialize($_POST['formTables'][$i]);
}
$linkCount = $tblCount;
//get linking keys
$rsLinkKeys = $data->getLinkingKeys($arrSelTables);
$linkCount = $rsLinkKeys->recordCount() > $tblCount ? $rsLinkKeys->recordCount() : $tblCount;
$arrFields = array(); //array that will hold all our table/field names
//if we have schemas we need to specify the correct schema for each table we're retrieiving
//with getTableAttributes
$curSchema = $data->_schema;
for ($i = 0; $i < $tblCount; $i++) {
if ($data->_schema != $arrSelTables[$i]['schemaname']) {
$data->setSchema($arrSelTables[$i]['schemaname']);
}
$attrs = $data->getTableAttributes($arrSelTables[$i]['tablename']);
while (!$attrs->EOF) {
$arrFields["{$arrSelTables[$i]['schemaname']}.{$arrSelTables[$i]['tablename']}.{$attrs->fields['attname']}"] = serialize(array(
'schemaname' => $arrSelTables[$i]['schemaname'],
'tablename' => $arrSelTables[$i]['tablename'],
'fieldname' => $attrs->fields['attname'])
);
$attrs->moveNext();
}
$data->setSchema($curSchema);
}
asort($arrFields);
echo "<form action=\"views.php\" method=\"post\">\n";
echo "<table>\n";
echo "<tr><th class=\"data\">{$lang['strviewname']}</th></tr>";
echo "<tr>\n<td class=\"data1\">\n";
// View name
echo "<input name=\"formView\" value=\"", htmlspecialchars($_REQUEST['formView']), "\" size=\"32\" maxlength=\"{$data->_maxNameLen}\" />\n";
echo "</td>\n</tr>\n";
echo "<tr><th class=\"data\">{$lang['strcomment']}</th></tr>";
echo "<tr>\n<td class=\"data1\">\n";
// View comments
echo "<textarea name=\"formComment\" rows=\"3\" cols=\"32\">",
htmlspecialchars($_REQUEST['formComment']), "</textarea>\n";
echo "</td>\n</tr>\n";
echo "</table>\n";
// Output selector for fields to be retrieved from view
echo "<table>\n";
echo "<tr><th class=\"data\">{$lang['strcolumns']}</th></tr>";
echo "<tr>\n<td class=\"data1\">\n";
echo GUI::printCombo($arrFields, 'formFields[]', false, '', true);
echo "</td>\n</tr>";
echo "<tr><td><input type=\"radio\" name=\"dblFldMeth\" id=\"dblFldMeth1\" value=\"rename\" /><label for=\"dblFldMeth1\">{$lang['strrenamedupfields']}</label>";
echo "<br /><input type=\"radio\" name=\"dblFldMeth\" id=\"dblFldMeth2\" value=\"drop\" /><label for=\"dblFldMeth2\">{$lang['strdropdupfields']}</label>";
echo "<br /><input type=\"radio\" name=\"dblFldMeth\" id=\"dblFldMeth3\" value=\"\" checked=\"checked\" /><label for=\"dblFldMeth3\">{$lang['strerrordupfields']}</label></td></tr></table><br />";
// Output the Linking keys combo boxes
echo "<table>\n";
echo "<tr><th class=\"data\">{$lang['strviewlink']}</th></tr>";
$rowClass = 'data1';
for ($i = 0; $i < $linkCount; $i++) {
// Initialise variables
if (!isset($formLink[$i]['operator'])) $formLink[$i]['operator'] = 'INNER JOIN';
echo "<tr>\n<td class=\"$rowClass\">\n";
if (!$rsLinkKeys->EOF) {
$curLeftLink = htmlspecialchars(serialize(array('schemaname' => $rsLinkKeys->fields['p_schema'], 'tablename' => $rsLinkKeys->fields['p_table'], 'fieldname' => $rsLinkKeys->fields['p_field']) ) );
$curRightLink = htmlspecialchars(serialize(array('schemaname' => $rsLinkKeys->fields['f_schema'], 'tablename' => $rsLinkKeys->fields['f_table'], 'fieldname' => $rsLinkKeys->fields['f_field']) ) );
$rsLinkKeys->moveNext();
}
else {
$curLeftLink = '';
$curRightLink = '';
}
echo GUI::printCombo($arrFields, "formLink[$i][leftlink]", true, $curLeftLink, false );
echo GUI::printCombo($data->joinOps, "formLink[$i][operator]", true, $formLink[$i]['operator']);
echo GUI::printCombo($arrFields, "formLink[$i][rightlink]", true, $curRightLink, false );
echo "</td>\n</tr>\n";
$rowClass = $rowClass == 'data1' ? 'data2' : 'data1';
}
echo "</table>\n<br />\n";
// Build list of available operators (infix only)
$arrOperators = array();
foreach ($data->selectOps as $k => $v) {
if ($v == 'i') $arrOperators[$k] = $k;
}
// Output additional conditions, note that this portion of the wizard treats the right hand side as literal values
//(not as database objects) so field names will be treated as strings, use the above linking keys section to perform joins
echo "<table>\n";
echo "<tr><th class=\"data\">{$lang['strviewconditions']}</th></tr>";
$rowClass = 'data1';
for ($i = 0; $i < $linkCount; $i++) {
echo "<tr>\n<td class=\"$rowClass\">\n";
echo GUI::printCombo($arrFields, "formCondition[$i][field]");
echo GUI::printCombo($arrOperators, "formCondition[$i][operator]", false, false);
echo "<input type=\"text\" name=\"formCondition[$i][txt]\" />\n";
echo "</td>\n</tr>\n";
$rowClass = $rowClass == 'data1' ? 'data2' : 'data1';
}
echo "</table>\n";
echo "<p><input type=\"hidden\" name=\"action\" value=\"save_create_wiz\" />\n";
foreach ($arrSelTables AS $curTable) {
echo "<input type=\"hidden\" name=\"formTables[]\" value=\"" . htmlspecialchars(serialize($curTable) ) . "\" />\n";
}
echo $misc->form;
echo "<input type=\"submit\" value=\"{$lang['strcreate']}\" />\n";
echo "<input type=\"submit\" name=\"cancel\" value=\"{$lang['strcancel']}\" /></p>\n";
echo "</form>\n";
}
}
/**
* Display a wizard where they can enter a new view
*/
function doWizardCreate($msg = '') {
global $data, $misc;
global $lang;
$tables = $data->getTables(true);
$misc->printTrail('schema');
$misc->printTitle($lang['strcreateviewwiz'], 'pg.view.create');
$misc->printMsg($msg);
echo "<form action=\"views.php\" method=\"post\">\n";
echo "<table>\n";
echo "<tr><th class=\"data\">{$lang['strtables']}</th></tr>";
echo "<tr>\n<td class=\"data1\">\n";
$arrTables = array();
while (!$tables->EOF) {
$arrTmp = array();
$arrTmp['schemaname'] = $tables->fields['nspname'];
$arrTmp['tablename'] = $tables->fields['relname'];
$arrTables[$tables->fields['nspname'] . '.' . $tables->fields['relname']] = serialize($arrTmp);
$tables->moveNext();
}
echo GUI::printCombo($arrTables, 'formTables[]', false, '', true);
echo "</td>\n</tr>\n";
echo "</table>\n";
echo "<p><input type=\"hidden\" name=\"action\" value=\"set_params_create\" />\n";
echo $misc->form;
echo "<input type=\"submit\" value=\"{$lang['strnext']}\" />\n";
echo "<input type=\"submit\" name=\"cancel\" value=\"{$lang['strcancel']}\" /></p>\n";
echo "</form>\n";
}
/**
* Displays a screen where they can enter a new view
*/
function doCreate($msg = '') {
global $data, $misc, $conf;
global $lang;
if (!isset($_REQUEST['formView'])) $_REQUEST['formView'] = '';
if (!isset($_REQUEST['formDefinition'])) $_REQUEST['formDefinition'] = 'SELECT ';
if (!isset($_REQUEST['formComment'])) $_REQUEST['formComment'] = '';
$misc->printTrail('schema');
$misc->printTitle($lang['strcreateview'], 'pg.view.create');
$misc->printMsg($msg);
echo "<form action=\"views.php\" method=\"post\">\n";
echo "<table style=\"width: 100%\">\n";
echo "\t<tr>\n\t\t<th class=\"data left required\">{$lang['strname']}</th>\n";
echo "\t<td class=\"data1\"><input name=\"formView\" size=\"32\" maxlength=\"{$data->_maxNameLen}\" value=\"",
htmlspecialchars($_REQUEST['formView']), "\" /></td>\n\t</tr>\n";
echo "\t<tr>\n\t\t<th class=\"data left required\">{$lang['strdefinition']}</th>\n";
echo "\t<td class=\"data1\"><textarea style=\"width:100%;\" rows=\"10\" cols=\"50\" name=\"formDefinition\">",
htmlspecialchars($_REQUEST['formDefinition']), "</textarea></td>\n\t</tr>\n";
echo "\t<tr>\n\t\t<th class=\"data left\">{$lang['strcomment']}</th>\n";
echo "\t\t<td class=\"data1\"><textarea name=\"formComment\" rows=\"3\" cols=\"32\">",
htmlspecialchars($_REQUEST['formComment']), "</textarea></td>\n\t</tr>\n";
echo "</table>\n";
echo "<p><input type=\"hidden\" name=\"action\" value=\"save_create\" />\n";
echo $misc->form;
echo "<input type=\"submit\" value=\"{$lang['strcreate']}\" />\n";
echo "<input type=\"submit\" name=\"cancel\" value=\"{$lang['strcancel']}\" /></p>\n";
echo "</form>\n";
}
/**
* Actually creates the new view in the database
*/
function doSaveCreate() {
global $data, $lang, $_reload_browser;
// Check that they've given a name and a definition
if ($_POST['formView'] == '') doCreate($lang['strviewneedsname']);
elseif ($_POST['formDefinition'] == '') doCreate($lang['strviewneedsdef']);
else {
$status = $data->createView($_POST['formView'], $_POST['formDefinition'], false, $_POST['formComment']);
if ($status == 0) {
$_reload_browser = true;
doDefault($lang['strviewcreated']);
}
else
doCreate($lang['strviewcreatedbad']);
}
}
/**
* Actually creates the new wizard view in the database
*/
function doSaveCreateWiz() {
global $data, $lang, $_reload_browser;
// Check that they've given a name and fields they want to select
if (!strlen($_POST['formView']) ) doSetParamsCreate($lang['strviewneedsname']);
else if (!isset($_POST['formFields']) || !count($_POST['formFields']) ) doSetParamsCreate($lang['strviewneedsfields']);
else {
$selFields = '';
if (! empty($_POST['dblFldMeth']) )
$tmpHsh = array();
foreach ($_POST['formFields'] AS $curField) {
$arrTmp = unserialize($curField);
$data->fieldArrayClean($arrTmp);
if (! empty($_POST['dblFldMeth']) ) { // doublon control
if (empty($tmpHsh[$arrTmp['fieldname']])) { // field does not exist
$selFields .= "\"{$arrTmp['schemaname']}\".\"{$arrTmp['tablename']}\".\"{$arrTmp['fieldname']}\", ";
$tmpHsh[$arrTmp['fieldname']] = 1;
} else if ($_POST['dblFldMeth'] == 'rename') { // field exist and must be renamed
$tmpHsh[$arrTmp['fieldname']]++;
$selFields .= "\"{$arrTmp['schemaname']}\".\"{$arrTmp['tablename']}\".\"{$arrTmp['fieldname']}\" AS \"{$arrTmp['schemaname']}_{$arrTmp['tablename']}_{$arrTmp['fieldname']}{$tmpHsh[$arrTmp['fieldname']]}\", ";
}
/* field already exist, just ignore this one */
} else { // no doublon control
$selFields .= "\"{$arrTmp['schemaname']}\".\"{$arrTmp['tablename']}\".\"{$arrTmp['fieldname']}\", ";
}
}
$selFields = substr($selFields, 0, -2);
unset($arrTmp, $tmpHsh);
$linkFields = '';
// If we have links, out put the JOIN ... ON statements
if (is_array($_POST['formLink']) ) {
// Filter out invalid/blank entries for our links
$arrLinks = array();
foreach ($_POST['formLink'] AS $curLink) {
if (strlen($curLink['leftlink']) && strlen($curLink['rightlink']) && strlen($curLink['operator'])) {
$arrLinks[] = $curLink;
}
}
// We must perform some magic to make sure that we have a valid join order
$count = sizeof($arrLinks);
$arrJoined = array();
$arrUsedTbls = array();
// If we have at least one join condition, output it
if ($count > 0) {
$j = 0;
while ($j < $count) {
foreach ($arrLinks AS $curLink) {
$arrLeftLink = unserialize($curLink['leftlink']);
$arrRightLink = unserialize($curLink['rightlink']);
$data->fieldArrayClean($arrLeftLink);
$data->fieldArrayClean($arrRightLink);
$tbl1 = "\"{$arrLeftLink['schemaname']}\".\"{$arrLeftLink['tablename']}\"";
$tbl2 = "\"{$arrRightLink['schemaname']}\".\"{$arrRightLink['tablename']}\"";
if ( (!in_array($curLink, $arrJoined) && in_array($tbl1, $arrUsedTbls)) || !count($arrJoined) ) {
// Make sure for multi-column foreign keys that we use a table alias tables joined to more than once
// This can (and should be) more optimized for multi-column foreign keys
$adj_tbl2 = in_array($tbl2, $arrUsedTbls) ? "$tbl2 AS alias_ppa_" . mktime() : $tbl2;
$linkFields .= strlen($linkFields) ? "{$curLink['operator']} $adj_tbl2 ON (\"{$arrLeftLink['schemaname']}\".\"{$arrLeftLink['tablename']}\".\"{$arrLeftLink['fieldname']}\" = \"{$arrRightLink['schemaname']}\".\"{$arrRightLink['tablename']}\".\"{$arrRightLink['fieldname']}\") "
: "$tbl1 {$curLink['operator']} $adj_tbl2 ON (\"{$arrLeftLink['schemaname']}\".\"{$arrLeftLink['tablename']}\".\"{$arrLeftLink['fieldname']}\" = \"{$arrRightLink['schemaname']}\".\"{$arrRightLink['tablename']}\".\"{$arrRightLink['fieldname']}\") ";
$arrJoined[] = $curLink;
if (!in_array($tbl1, $arrUsedTbls) ) $arrUsedTbls[] = $tbl1;
if (!in_array($tbl2, $arrUsedTbls) ) $arrUsedTbls[] = $tbl2;
}
}
$j++;
}
}
}
//if linkfields has no length then either _POST['formLink'] was not set, or there were no join conditions
//just select from all seleted tables - a cartesian join do a
if (!strlen($linkFields) ) {
foreach ($_POST['formTables'] AS $curTable) {
$arrTmp = unserialize($curTable);
$data->fieldArrayClean($arrTmp);
$linkFields .= strlen($linkFields) ? ", \"{$arrTmp['schemaname']}\".\"{$arrTmp['tablename']}\"" : "\"{$arrTmp['schemaname']}\".\"{$arrTmp['tablename']}\"";
}
}
$addConditions = '';
if (is_array($_POST['formCondition']) ) {
foreach ($_POST['formCondition'] AS $curCondition) {
if (strlen($curCondition['field']) && strlen($curCondition['txt']) ) {
$arrTmp = unserialize($curCondition['field']);
$data->fieldArrayClean($arrTmp);
$addConditions .= strlen($addConditions) ? " AND \"{$arrTmp['schemaname']}\".\"{$arrTmp['tablename']}\".\"{$arrTmp['fieldname']}\" {$curCondition['operator']} '{$curCondition['txt']}' "
: " \"{$arrTmp['schemaname']}\".\"{$arrTmp['tablename']}\".\"{$arrTmp['fieldname']}\" {$curCondition['operator']} '{$curCondition['txt']}' ";
}
}
}
$viewQuery = "SELECT $selFields FROM $linkFields ";
//add where from additional conditions
if (strlen($addConditions) ) $viewQuery .= ' WHERE ' . $addConditions;
$status = $data->createView($_POST['formView'], $viewQuery, false, $_POST['formComment']);
if ($status == 0) {
$_reload_browser = true;
doDefault($lang['strviewcreated']);
}
else
doSetParamsCreate($lang['strviewcreatedbad']);
}
}
/**
* Show default list of views in the database
*/
function doDefault($msg = '') {
global $data, $misc, $conf;
global $lang;
$misc->printTrail('schema');
$misc->printTabs('schema','views');
$misc->printMsg($msg);
$views = $data->getViews();
$columns = array(
'view' => array(
'title' => $lang['strview'],
'field' => field('relname'),
'url' => "redirect.php?subject=view&{$misc->href}&",
'vars' => array('view' => 'relname'),
),
'owner' => array(
'title' => $lang['strowner'],
'field' => field('relowner'),
),
'actions' => array(
'title' => $lang['stractions'],
),
'comment' => array(
'title' => $lang['strcomment'],
'field' => field('relcomment'),
),
);
$actions = array(
'multiactions' => array(
'keycols' => array('view' => 'relname'),
'url' => 'views.php',
),
'browse' => array(
'content' => $lang['strbrowse'],
'attr'=> array (
'href' => array (
'url' => 'display.php',
'urlvars' => array (
'action' => 'confselectrows',
'subject' => 'view',
'return' => 'schema',
'view' => field('relname')
)
)
)
),
'select' => array(
'content' => $lang['strselect'],
'attr'=> array (
'href' => array (
'url' => 'views.php',
'urlvars' => array (
'action' => 'confselectrows',
'view' => field('relname')
)
)
)
),
// Insert is possible if the relevant rule for the view has been created.
// 'insert' => array(
// 'title' => $lang['strinsert'],
// 'url' => "views.php?action=confinsertrow&{$misc->href}&",
// 'vars' => array('view' => 'relname'),
// ),
'alter' => array(
'content' => $lang['stralter'],
'attr'=> array (
'href' => array (
'url' => 'viewproperties.php',
'urlvars' => array (
'action' => 'confirm_alter',
'view' => field('relname')
)
)
)
),
'drop' => array(
'multiaction' => 'confirm_drop',
'content' => $lang['strdrop'],
'attr'=> array (
'href' => array (
'url' => 'views.php',
'urlvars' => array (
'action' => 'confirm_drop',
'view' => field('relname')
)
)
)
),
);
$misc->printTable($views, $columns, $actions, 'views-views', $lang['strnoviews']);
$navlinks = array (
'create' => array (
'attr'=> array (
'href' => array (
'url' => 'views.php',
'urlvars' => array (
'action' => 'create',
'server' => $_REQUEST['server'],
'database' => $_REQUEST['database'],
'schema' => $_REQUEST['schema']
)
)
),
'content' => $lang['strcreateview']
),
'createwiz' => array (
'attr'=> array (
'href' => array (
'url' => 'views.php',
'urlvars' => array (
'action' => 'wiz_create',
'server' => $_REQUEST['server'],
'database' => $_REQUEST['database'],
'schema' => $_REQUEST['schema']
)
)
),
'content' => $lang['strcreateviewwiz']
)
);
$misc->printNavLinks($navlinks, 'views-views', get_defined_vars());
}
/**
* Generate XML for the browser tree.
*/
function doTree() {
global $misc, $data;
$views = $data->getViews();
$reqvars = $misc->getRequestVars('view');
$attrs = array(
'text' => field('relname'),
'icon' => 'View',
'iconAction' => url('display.php', $reqvars, array('view' => field('relname'))),
'toolTip'=> field('relcomment'),
'action' => url('redirect.php', $reqvars, array('view' => field('relname'))),
'branch' => url('views.php', $reqvars,
array (
'action' => 'subtree',
'view' => field('relname')
)
)
);
$misc->printTree($views, $attrs, 'views');
exit;
}
function doSubTree() {
global $misc, $data;
$tabs = $misc->getNavTabs('view');
$items = $misc->adjustTabsForTree($tabs);
$reqvars = $misc->getRequestVars('view');
$attrs = array(
'text' => field('title'),
'icon' => field('icon'),
'action' => url(field('url'), $reqvars, field('urlvars'), array('view' => $_REQUEST['view'])),
'branch' => ifempty(
field('branch'), '', url(field('url'), field('urlvars'), $reqvars,
array(
'action' => 'tree',
'view' => $_REQUEST['view']
)
)
),
);
$misc->printTree($items, $attrs, 'view');
exit;
}
if ($action == 'tree') doTree();
if ($action == 'subtree') dosubTree();
$misc->printHeader($lang['strviews']);
$misc->printBody();
switch ($action) {
case 'selectrows':
if (!isset($_REQUEST['cancel'])) doSelectRows(false);
else doDefault();
break;
case 'confselectrows':
doSelectRows(true);
break;
case 'save_create_wiz':
if (isset($_REQUEST['cancel'])) doDefault();
else doSaveCreateWiz();
break;
case 'wiz_create':
doWizardCreate();
break;
case 'set_params_create':
if (isset($_POST['cancel'])) doDefault();
else doSetParamsCreate();
break;
case 'save_create':
if (isset($_REQUEST['cancel'])) doDefault();
else doSaveCreate();
break;
case 'create':
doCreate();
break;
case 'drop':
if (isset($_POST['drop'])) doDrop(false);
else doDefault();
break;
case 'confirm_drop':
doDrop(true);
break;
default:
doDefault();
break;
}
$misc->printFooter();
?>
| bsd-3-clause |
NifTK/MITK | CMakeExternals/Rasqal.cmake | 1663 | #-----------------------------------------------------------------------------
# rasqal
#-----------------------------------------------------------------------------
if(MITK_USE_Rasqal)
# Sanity checks
if(DEFINED Rasqal_DIR AND NOT EXISTS ${Rasqal_DIR})
message(FATAL_ERROR "Rasqal_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj Rasqal)
set(proj_DEPENDENCIES ${Raptor2_DEPENDS} ${PCRE_DEPENDS})
set(${proj}_DEPENDS ${proj})
if(NOT DEFINED Rasqal_DIR)
set(additional_cmake_args )
if(CTEST_USE_LAUNCHERS)
list(APPEND additional_cmake_args
"-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
)
endif()
ExternalProject_Add(${proj}
LIST_SEPARATOR ${sep}
URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/rasqal-0.9.32.tar.gz
URL_MD5 dc7c6107de00c47f85f6ab7db164a136
PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Rasqal-0.9.32.patch
LIST_SEPARATOR ^^
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
${additional_cmake_args}
"-DCMAKE_C_FLAGS:STRING=-DPCRE_STATIC ${CMAKE_C_FLAGS}"
-DRASQAL_REGEX:STRING=pcre
-DCMAKE_PREFIX_PATH:STRING=${PCRE_DIR}^^${REDLAND_INSTALL_DIR}
-DPCRE_INCLUDE_DIR:PATH=${PCRE_DIR}/include
CMAKE_CACHE_ARGS
${ep_common_cache_args}
CMAKE_CACHE_DEFAULT_ARGS
${ep_common_cache_default_args}
DEPENDS ${proj_DEPENDENCIES}
)
set(${proj}_DIR ${ep_prefix}/lib/rasqal/cmake)
mitkFunctionInstallExternalCMakeProject(${proj})
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
endif()
| bsd-3-clause |
youtube/cobalt | third_party/skia_next/third_party/skia/docs/examples/IRect_isEmpty64.cpp | 748 | // Copyright 2019 Google LLC.
// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
#include "tools/fiddle/examples.h"
// HASH=eb905faa1084ccab3ad0605df4c27ea4
REG_FIDDLE(IRect_isEmpty64, 256, 256, true, 0) {
void draw(SkCanvas* canvas) {
SkIRect tests[] = {{20, 40, 10, 50}, {20, 40, 20, 50}};
for (auto rect : tests) {
SkDebugf("rect: {%d, %d, %d, %d} is" "%s empty\n", rect.left(), rect.top(), rect.right(),
rect.bottom(), rect.isEmpty64() ? "" : " not");
rect.sort();
SkDebugf("sorted: {%d, %d, %d, %d} is" "%s empty\n", rect.left(), rect.top(), rect.right(),
rect.bottom(), rect.isEmpty64() ? "" : " not");
}
}
} // END FIDDLE
| bsd-3-clause |
chromium/chromium | third_party/tflite_support/src/tensorflow_lite_support/python/task/core/task_utils.py | 1839 | # Copyright 2021 The TensorFlow Authors. All Rights Reserved.
#
# 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.
"""Utils functions used in Task Python API."""
from tensorflow_lite_support.cc.task.core.proto import base_options_pb2
from tensorflow_lite_support.python.task.core import task_options
from tensorflow_lite_support.python.task.core.proto import configuration_pb2
_ProtoBaseOptions = base_options_pb2.BaseOptions
def ConvertToProtoBaseOptions(
options: task_options.BaseOptions) -> _ProtoBaseOptions:
"""Convert the Python BaseOptions to Proto BaseOptions.
Python BaseOptions is a subset of the Proto BaseOptions that strips off
configurations that are useless in Python development.
Args:
options: the Python BaseOptions object.
Returns:
The Proto BaseOptions object.
"""
proto_options = _ProtoBaseOptions()
if options.model_file.file_content:
proto_options.model_file.file_content = options.model_file.file_content
elif options.model_file.file_name:
proto_options.model_file.file_name = options.model_file.file_name
proto_options.compute_settings.tflite_settings.cpu_settings.num_threads = (
options.num_threads)
if options.use_coral:
proto_options.compute_settings.tflite_settings.delegate = (
configuration_pb2.Delegate.EDGETPU_CORAL)
return proto_options
| bsd-3-clause |
andreinabgomezg29/spree_out_stock | spec/dummy/db/migrate/20170904174291_update_adjustment_states.spree.rb | 500 | # This migration comes from spree (originally 20130417120035)
class UpdateAdjustmentStates < ActiveRecord::Migration[4.2]
def up
Spree::Order.complete.find_each do |order|
order.adjustments.update_all(state: 'closed')
end
Spree::Shipment.shipped.includes(:adjustment).find_each do |shipment|
shipment.adjustment.update_column(:state, 'finalized') if shipment.adjustment
end
Spree::Adjustment.where(state: nil).update_all(state: 'open')
end
def down
end
end
| bsd-3-clause |
zcbenz/cefode-chromium | chrome/browser/resources/net_internals/export_view.js | 6896 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/**
* This view displays options for exporting the captured data.
*/
var ExportView = (function() {
'use strict';
// We inherit from DivView.
var superClass = DivView;
/**
* @constructor
*/
function ExportView() {
assertFirstConstructorCall(ExportView);
// Call superclass's constructor.
superClass.call(this, ExportView.MAIN_BOX_ID);
var privacyStrippingCheckbox = $(ExportView.PRIVACY_STRIPPING_CHECKBOX_ID);
privacyStrippingCheckbox.onclick =
this.onSetPrivacyStripping_.bind(this, privacyStrippingCheckbox);
this.saveFileButton_ = $(ExportView.SAVE_FILE_BUTTON_ID);
this.saveFileButton_.onclick = this.onSaveFile_.bind(this);
this.saveStatusText_ = $(ExportView.SAVE_STATUS_TEXT_ID);
this.userCommentsTextArea_ = $(ExportView.USER_COMMENTS_TEXT_AREA_ID);
// Track blob for previous log dump so it can be revoked when a new dump is
// saved.
this.lastBlobURL_ = null;
// Cached copy of the last loaded log dump, for use when exporting.
this.loadedLogDump_ = null;
}
// ID for special HTML element in category_tabs.html
ExportView.TAB_HANDLE_ID = 'tab-handle-export';
// IDs for special HTML elements in export_view.html
ExportView.MAIN_BOX_ID = 'export-view-tab-content';
ExportView.DOWNLOAD_ANCHOR_ID = 'export-view-download-anchor';
ExportView.SAVE_FILE_BUTTON_ID = 'export-view-save-log-file';
ExportView.SAVE_STATUS_TEXT_ID = 'export-view-save-status-text';
ExportView.PRIVACY_STRIPPING_CHECKBOX_ID =
'export-view-privacy-stripping-checkbox';
ExportView.USER_COMMENTS_TEXT_AREA_ID = 'export-view-user-comments';
ExportView.PRIVACY_WARNING_ID = 'export-view-privacy-warning';
cr.addSingletonGetter(ExportView);
ExportView.prototype = {
// Inherit the superclass's methods.
__proto__: superClass.prototype,
/**
* Depending on the value of the checkbox, enables or disables stripping
* cookies and passwords from log dumps and displayed events.
*/
onSetPrivacyStripping_: function(privacyStrippingCheckbox) {
SourceTracker.getInstance().setPrivacyStripping(
privacyStrippingCheckbox.checked);
},
/**
* When loading a log dump, cache it for future export and continue showing
* the ExportView.
*/
onLoadLogFinish: function(polledData, tabData, logDump) {
this.loadedLogDump_ = logDump;
this.setUserComments_(logDump.userComments);
return true;
},
/**
* Sets the save to file status text, displayed below the save to file
* button, to |text|. Also enables or disables the save button based on the
* value of |isSaving|, which must be true if the save process is still
* ongoing, and false when the operation has stopped, regardless of success
* of failure.
*/
setSaveFileStatus: function(text, isSaving) {
this.enableSaveFileButton_(!isSaving);
this.saveStatusText_.textContent = text;
},
enableSaveFileButton_: function(enabled) {
this.saveFileButton_.disabled = !enabled;
},
showPrivacyWarning: function() {
setNodeDisplay($(ExportView.PRIVACY_WARNING_ID), true);
$(ExportView.PRIVACY_STRIPPING_CHECKBOX_ID).checked = false;
$(ExportView.PRIVACY_STRIPPING_CHECKBOX_ID).disabled = true;
// Updating the checkbox doesn't actually disable privacy stripping, since
// the onclick function will not be called.
this.onSetPrivacyStripping_($(ExportView.PRIVACY_STRIPPING_CHECKBOX_ID));
},
/**
* If not already busy saving a log dump, triggers asynchronous
* generation of log dump and starts waiting for it to complete.
*/
onSaveFile_: function() {
if (this.saveFileButton_.disabled)
return;
// Clean up previous blob, if any, to reduce resource usage.
if (this.lastBlobURL_) {
window.webkitURL.revokeObjectURL(this.lastBlobURL_);
this.lastBlobURL_ = null;
}
this.createLogDump_(this.onLogDumpCreated_.bind(this));
},
/**
* Creates a log dump, and either synchronously or asynchronously calls
* |callback| if it succeeds. Separate from onSaveFile_ for unit tests.
*/
createLogDump_: function(callback) {
// Get an explanation for the dump file (this is mandatory!)
var userComments = this.getNonEmptyUserComments_();
if (userComments == undefined) {
return;
}
this.setSaveFileStatus('Preparing data...', true);
var privacyStripping = SourceTracker.getInstance().getPrivacyStripping();
// If we have a cached log dump, update it synchronously.
if (this.loadedLogDump_) {
var dumpText = log_util.createUpdatedLogDump(userComments,
this.loadedLogDump_,
privacyStripping);
callback(dumpText);
return;
}
// Otherwise, poll information from the browser before creating one.
log_util.createLogDumpAsync(userComments,
callback,
privacyStripping);
},
/**
* Sets the user comments.
*/
setUserComments_: function(userComments) {
this.userCommentsTextArea_.value = userComments;
},
/**
* Fetches the user comments for this dump. If none were entered, warns the
* user and returns undefined. Otherwise returns the comments text.
*/
getNonEmptyUserComments_: function() {
var value = this.userCommentsTextArea_.value;
// Reset the class name in case we had hilighted it earlier.
this.userCommentsTextArea_.className = '';
// We don't accept empty explanations. We don't care what is entered, as
// long as there is something (a single whitespace would work).
if (value == '') {
// Put a big obnoxious red border around the text area.
this.userCommentsTextArea_.className =
'export-view-explanation-warning';
alert('Please fill in the text field!');
return undefined;
}
return value;
},
/**
* Creates a blob url and starts downloading it.
*/
onLogDumpCreated_: function(dumpText) {
var textBlob = new Blob([dumpText], {type: 'octet/stream'});
this.lastBlobURL_ = window.webkitURL.createObjectURL(textBlob);
// Update the anchor tag and simulate a click on it to start the
// download.
var downloadAnchor = $(ExportView.DOWNLOAD_ANCHOR_ID);
downloadAnchor.href = this.lastBlobURL_;
downloadAnchor.click();
this.setSaveFileStatus('Dump successful', false);
}
};
return ExportView;
})();
| bsd-3-clause |
pervino/solidus | backend/app/controllers/spree/admin/properties_controller.rb | 601 | # frozen_string_literal: true
module Spree
module Admin
class PropertiesController < ResourceController
def index
respond_with(@collection)
end
private
def collection
return @collection if @collection
# params[:q] can be blank upon pagination
params[:q] = {} if params[:q].blank?
@collection = super
@search = @collection.ransack(params[:q])
@collection = @search.result.
page(params[:page]).
per(Spree::Config[:properties_per_page])
@collection
end
end
end
end
| bsd-3-clause |
nwjs/chromium.src | content/test/data/accessibility/aria/aria-owns-list.html | 344 | <!--
@MAC-ALLOW:AXSize={w: 400, h: *}
@BLINK-ALLOW:pageSize=(400*
-->
<html>
<body>
<style>
[role="listitem"] {
width: 400px;
height: 200px;
}
</style>
<div role="list" aria-owns="one two"></div>
<div id="one" role="listitem">One</div>
<div id="two" role="listitem">Two</div>
</body>
</html>
| bsd-3-clause |
0mok/fresco | drawee/src/test/java/com/facebook/drawee/drawable/RoundedBitmapDrawableTest.java | 4630 | /*
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
package com.facebook.drawee.drawable;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Paint;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.util.DisplayMetrics;
import org.robolectric.RobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
@RunWith(RobolectricTestRunner.class)
public class RoundedBitmapDrawableTest {
private Resources mResources;
private Bitmap mBitmap;
private DisplayMetrics mDisplayMetrics;
RoundedBitmapDrawable mRoundedBitmapDrawable;
private final Drawable.Callback mCallback = mock(Drawable.Callback.class);
@Before
public void setUp() {
mResources = mock(Resources.class);
mBitmap = mock(Bitmap.class);
mDisplayMetrics = mock(DisplayMetrics.class);
when(mResources.getDisplayMetrics()).thenReturn(mDisplayMetrics);
mRoundedBitmapDrawable = new RoundedBitmapDrawable(mResources, mBitmap);
mRoundedBitmapDrawable.setCallback(mCallback);
}
@Test
public void testSetCircle() {
mRoundedBitmapDrawable.setCircle(true);
verify(mCallback).invalidateDrawable(mRoundedBitmapDrawable);
assertTrue(mRoundedBitmapDrawable.isCircle());
}
@Test
public void testSetRadii() {
mRoundedBitmapDrawable.setRadii(new float[]{1, 2, 3, 4, 5, 6, 7, 8});
verify(mCallback).invalidateDrawable(mRoundedBitmapDrawable);
assertArrayEquals(new float[]{1, 2, 3, 4, 5, 6, 7, 8}, mRoundedBitmapDrawable.getRadii(), 0);
}
@Test
public void testSetRadius() {
mRoundedBitmapDrawable.setRadius(9);
verify(mCallback).invalidateDrawable(mRoundedBitmapDrawable);
assertArrayEquals(new float[]{9, 9, 9, 9, 9, 9, 9, 9}, mRoundedBitmapDrawable.getRadii(), 0);
}
@Test
public void testSetBorder() {
int color = 0x12345678;
float width = 5;
mRoundedBitmapDrawable.setBorder(color, width);
verify(mCallback).invalidateDrawable(mRoundedBitmapDrawable);
assertEquals(color, mRoundedBitmapDrawable.getBorderColor());
assertEquals(width, mRoundedBitmapDrawable.getBorderWidth(), 0);
}
@Test
public void testSetPadding() {
float padding = 10;
mRoundedBitmapDrawable.setPadding(padding);
verify(mCallback).invalidateDrawable(mRoundedBitmapDrawable);
assertEquals(padding, mRoundedBitmapDrawable.getPadding(), 0);
}
@Test
public void testShouldRoundDefault() {
assertFalse(mRoundedBitmapDrawable.shouldRound());
}
@Test
public void testShouldRoundRadius() {
mRoundedBitmapDrawable.setRadius(5);
assertTrue(mRoundedBitmapDrawable.shouldRound());
mRoundedBitmapDrawable.setRadius(0);
assertFalse(mRoundedBitmapDrawable.shouldRound());
}
@Test
public void testShouldRoundRadii() {
mRoundedBitmapDrawable.setRadii(new float[]{0, 0, 0, 0, 0, 0, 0, 1});
assertTrue(mRoundedBitmapDrawable.shouldRound());
mRoundedBitmapDrawable.setRadii(new float[]{0, 0, 0, 0, 0, 0, 0, 0});
assertFalse(mRoundedBitmapDrawable.shouldRound());
}
@Test
public void testShouldRoundCircle() {
mRoundedBitmapDrawable.setCircle(true);
assertTrue(mRoundedBitmapDrawable.shouldRound());
mRoundedBitmapDrawable.setCircle(false);
assertFalse(mRoundedBitmapDrawable.shouldRound());
}
@Test
public void testShouldRoundBorder() {
mRoundedBitmapDrawable.setBorder(0xFFFFFFFF, 1);
assertTrue(mRoundedBitmapDrawable.shouldRound());
mRoundedBitmapDrawable.setBorder(0x00000000, 0);
assertFalse(mRoundedBitmapDrawable.shouldRound());
}
@Test
public void testPreservePaintOnDrawableCopy() {
ColorFilter colorFilter = mock(ColorFilter.class);
Paint originalPaint = mock(Paint.class);
BitmapDrawable originalVersion = mock(BitmapDrawable.class);
originalPaint.setColorFilter(colorFilter);
when(originalVersion.getPaint()).thenReturn(originalPaint);
RoundedBitmapDrawable roundedVersion = RoundedBitmapDrawable.fromBitmapDrawable(
mResources,
originalVersion);
assertEquals(
originalVersion.getPaint().getColorFilter(),
roundedVersion.getPaint().getColorFilter());
}
}
| bsd-3-clause |
TeamEOS/external_chromium_org | content/browser/indexed_db/indexed_db_backing_store.h | 21096 | // Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_
#define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/basictypes.h"
#include "base/files/file_path.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "content/browser/indexed_db/indexed_db.h"
#include "content/browser/indexed_db/indexed_db_active_blob_registry.h"
#include "content/browser/indexed_db/indexed_db_blob_info.h"
#include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
#include "content/browser/indexed_db/indexed_db_metadata.h"
#include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
#include "content/browser/indexed_db/leveldb/leveldb_transaction.h"
#include "content/common/content_export.h"
#include "content/common/indexed_db/indexed_db_key.h"
#include "content/common/indexed_db/indexed_db_key_path.h"
#include "content/common/indexed_db/indexed_db_key_range.h"
#include "third_party/leveldatabase/src/include/leveldb/status.h"
#include "url/gurl.h"
#include "webkit/browser/blob/blob_data_handle.h"
namespace base {
class TaskRunner;
}
namespace fileapi {
class FileWriterDelegate;
}
namespace net {
class URLRequestContext;
}
namespace content {
class IndexedDBFactory;
class LevelDBComparator;
class LevelDBDatabase;
struct IndexedDBValue;
class LevelDBFactory {
public:
virtual ~LevelDBFactory() {}
virtual leveldb::Status OpenLevelDB(const base::FilePath& file_name,
const LevelDBComparator* comparator,
scoped_ptr<LevelDBDatabase>* db,
bool* is_disk_full) = 0;
virtual leveldb::Status DestroyLevelDB(const base::FilePath& file_name) = 0;
};
class CONTENT_EXPORT IndexedDBBackingStore
: public base::RefCounted<IndexedDBBackingStore> {
public:
class CONTENT_EXPORT Transaction;
class CONTENT_EXPORT Comparator : public LevelDBComparator {
public:
virtual int Compare(const base::StringPiece& a,
const base::StringPiece& b) const OVERRIDE;
virtual const char* Name() const OVERRIDE;
};
const GURL& origin_url() const { return origin_url_; }
IndexedDBFactory* factory() const { return indexed_db_factory_; }
base::TaskRunner* task_runner() const { return task_runner_; }
base::OneShotTimer<IndexedDBBackingStore>* close_timer() {
return &close_timer_;
}
IndexedDBActiveBlobRegistry* active_blob_registry() {
return &active_blob_registry_;
}
static scoped_refptr<IndexedDBBackingStore> Open(
IndexedDBFactory* indexed_db_factory,
const GURL& origin_url,
const base::FilePath& path_base,
net::URLRequestContext* request_context,
blink::WebIDBDataLoss* data_loss,
std::string* data_loss_message,
bool* disk_full,
base::TaskRunner* task_runner,
bool clean_journal);
static scoped_refptr<IndexedDBBackingStore> Open(
IndexedDBFactory* indexed_db_factory,
const GURL& origin_url,
const base::FilePath& path_base,
net::URLRequestContext* request_context,
blink::WebIDBDataLoss* data_loss,
std::string* data_loss_message,
bool* disk_full,
LevelDBFactory* leveldb_factory,
base::TaskRunner* task_runner,
bool clean_journal);
static scoped_refptr<IndexedDBBackingStore> OpenInMemory(
const GURL& origin_url,
base::TaskRunner* task_runner);
static scoped_refptr<IndexedDBBackingStore> OpenInMemory(
const GURL& origin_url,
LevelDBFactory* leveldb_factory,
base::TaskRunner* task_runner);
void GrantChildProcessPermissions(int child_process_id);
// Compact is public for testing.
virtual void Compact();
virtual std::vector<base::string16> GetDatabaseNames(leveldb::Status*);
virtual leveldb::Status GetIDBDatabaseMetaData(
const base::string16& name,
IndexedDBDatabaseMetadata* metadata,
bool* success) WARN_UNUSED_RESULT;
virtual leveldb::Status CreateIDBDatabaseMetaData(
const base::string16& name,
const base::string16& version,
int64 int_version,
int64* row_id);
virtual bool UpdateIDBDatabaseIntVersion(
IndexedDBBackingStore::Transaction* transaction,
int64 row_id,
int64 int_version);
virtual leveldb::Status DeleteDatabase(const base::string16& name);
// Assumes caller has already closed the backing store.
static leveldb::Status DestroyBackingStore(const base::FilePath& path_base,
const GURL& origin_url);
static bool RecordCorruptionInfo(const base::FilePath& path_base,
const GURL& origin_url,
const std::string& message);
leveldb::Status GetObjectStores(
int64 database_id,
IndexedDBDatabaseMetadata::ObjectStoreMap* map) WARN_UNUSED_RESULT;
virtual leveldb::Status CreateObjectStore(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
const base::string16& name,
const IndexedDBKeyPath& key_path,
bool auto_increment);
virtual leveldb::Status DeleteObjectStore(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id) WARN_UNUSED_RESULT;
class CONTENT_EXPORT RecordIdentifier {
public:
RecordIdentifier(const std::string& primary_key, int64 version);
RecordIdentifier();
~RecordIdentifier();
const std::string& primary_key() const { return primary_key_; }
int64 version() const { return version_; }
void Reset(const std::string& primary_key, int64 version) {
primary_key_ = primary_key;
version_ = version;
}
private:
// TODO(jsbell): Make it more clear that this is the *encoded* version of
// the key.
std::string primary_key_;
int64 version_;
DISALLOW_COPY_AND_ASSIGN(RecordIdentifier);
};
class BlobWriteCallback : public base::RefCounted<BlobWriteCallback> {
public:
virtual void Run(bool succeeded) = 0;
protected:
virtual ~BlobWriteCallback() {}
friend class base::RefCounted<BlobWriteCallback>;
};
virtual leveldb::Status GetRecord(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
const IndexedDBKey& key,
IndexedDBValue* record) WARN_UNUSED_RESULT;
virtual leveldb::Status PutRecord(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
const IndexedDBKey& key,
IndexedDBValue& value,
ScopedVector<webkit_blob::BlobDataHandle>* handles,
RecordIdentifier* record) WARN_UNUSED_RESULT;
virtual leveldb::Status ClearObjectStore(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id) WARN_UNUSED_RESULT;
virtual leveldb::Status DeleteRecord(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
const RecordIdentifier& record) WARN_UNUSED_RESULT;
virtual leveldb::Status DeleteRange(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
const IndexedDBKeyRange&) WARN_UNUSED_RESULT;
virtual leveldb::Status GetKeyGeneratorCurrentNumber(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64* current_number) WARN_UNUSED_RESULT;
virtual leveldb::Status MaybeUpdateKeyGeneratorCurrentNumber(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 new_state,
bool check_current) WARN_UNUSED_RESULT;
virtual leveldb::Status KeyExistsInObjectStore(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
const IndexedDBKey& key,
RecordIdentifier* found_record_identifier,
bool* found) WARN_UNUSED_RESULT;
virtual leveldb::Status CreateIndex(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 index_id,
const base::string16& name,
const IndexedDBKeyPath& key_path,
bool is_unique,
bool is_multi_entry) WARN_UNUSED_RESULT;
virtual leveldb::Status DeleteIndex(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 index_id) WARN_UNUSED_RESULT;
virtual leveldb::Status PutIndexDataForRecord(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKey& key,
const RecordIdentifier& record) WARN_UNUSED_RESULT;
virtual leveldb::Status GetPrimaryKeyViaIndex(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKey& key,
scoped_ptr<IndexedDBKey>* primary_key) WARN_UNUSED_RESULT;
virtual leveldb::Status KeyExistsInIndex(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKey& key,
scoped_ptr<IndexedDBKey>* found_primary_key,
bool* exists) WARN_UNUSED_RESULT;
// Public for IndexedDBActiveBlobRegistry::ReleaseBlobRef.
virtual void ReportBlobUnused(int64 database_id, int64 blob_key);
base::FilePath GetBlobFileName(int64 database_id, int64 key);
class Cursor {
public:
virtual ~Cursor();
enum IteratorState {
READY = 0,
SEEK
};
struct CursorOptions {
CursorOptions();
~CursorOptions();
int64 database_id;
int64 object_store_id;
int64 index_id;
std::string low_key;
bool low_open;
std::string high_key;
bool high_open;
bool forward;
bool unique;
};
const IndexedDBKey& key() const { return *current_key_; }
bool Continue(leveldb::Status* s) { return Continue(NULL, NULL, SEEK, s); }
bool Continue(const IndexedDBKey* key,
IteratorState state,
leveldb::Status* s) {
return Continue(key, NULL, state, s);
}
bool Continue(const IndexedDBKey* key,
const IndexedDBKey* primary_key,
IteratorState state,
leveldb::Status*);
bool Advance(uint32 count, leveldb::Status*);
bool FirstSeek(leveldb::Status*);
virtual Cursor* Clone() = 0;
virtual const IndexedDBKey& primary_key() const;
virtual IndexedDBValue* value() = 0;
virtual const RecordIdentifier& record_identifier() const;
virtual bool LoadCurrentRow() = 0;
protected:
Cursor(scoped_refptr<IndexedDBBackingStore> backing_store,
Transaction* transaction,
int64 database_id,
const CursorOptions& cursor_options);
explicit Cursor(const IndexedDBBackingStore::Cursor* other);
virtual std::string EncodeKey(const IndexedDBKey& key) = 0;
virtual std::string EncodeKey(const IndexedDBKey& key,
const IndexedDBKey& primary_key) = 0;
bool IsPastBounds() const;
bool HaveEnteredRange() const;
IndexedDBBackingStore* backing_store_;
Transaction* transaction_;
int64 database_id_;
const CursorOptions cursor_options_;
scoped_ptr<LevelDBIterator> iterator_;
scoped_ptr<IndexedDBKey> current_key_;
IndexedDBBackingStore::RecordIdentifier record_identifier_;
private:
DISALLOW_COPY_AND_ASSIGN(Cursor);
};
virtual scoped_ptr<Cursor> OpenObjectStoreKeyCursor(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
const IndexedDBKeyRange& key_range,
indexed_db::CursorDirection,
leveldb::Status*);
virtual scoped_ptr<Cursor> OpenObjectStoreCursor(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
const IndexedDBKeyRange& key_range,
indexed_db::CursorDirection,
leveldb::Status*);
virtual scoped_ptr<Cursor> OpenIndexKeyCursor(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKeyRange& key_range,
indexed_db::CursorDirection,
leveldb::Status*);
virtual scoped_ptr<Cursor> OpenIndexCursor(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKeyRange& key_range,
indexed_db::CursorDirection,
leveldb::Status*);
class BlobChangeRecord {
public:
BlobChangeRecord(const std::string& key, int64 object_store_id);
~BlobChangeRecord();
const std::string& key() const { return key_; }
int64 object_store_id() const { return object_store_id_; }
void SetBlobInfo(std::vector<IndexedDBBlobInfo>* blob_info);
std::vector<IndexedDBBlobInfo>& mutable_blob_info() { return blob_info_; }
const std::vector<IndexedDBBlobInfo>& blob_info() const {
return blob_info_;
}
void SetHandles(ScopedVector<webkit_blob::BlobDataHandle>* handles);
scoped_ptr<BlobChangeRecord> Clone() const;
private:
std::string key_;
int64 object_store_id_;
std::vector<IndexedDBBlobInfo> blob_info_;
ScopedVector<webkit_blob::BlobDataHandle> handles_;
DISALLOW_COPY_AND_ASSIGN(BlobChangeRecord);
};
typedef std::map<std::string, BlobChangeRecord*> BlobChangeMap;
class Transaction {
public:
explicit Transaction(IndexedDBBackingStore* backing_store);
virtual ~Transaction();
virtual void Begin();
// The callback will be called eventually on success or failure, or
// immediately if phase one is complete due to lack of any blobs to write.
virtual leveldb::Status CommitPhaseOne(scoped_refptr<BlobWriteCallback>);
virtual leveldb::Status CommitPhaseTwo();
virtual void Rollback();
void Reset() {
backing_store_ = NULL;
transaction_ = NULL;
}
leveldb::Status PutBlobInfoIfNeeded(
int64 database_id,
int64 object_store_id,
const std::string& object_store_data_key,
std::vector<IndexedDBBlobInfo>*,
ScopedVector<webkit_blob::BlobDataHandle>* handles);
void PutBlobInfo(int64 database_id,
int64 object_store_id,
const std::string& object_store_data_key,
std::vector<IndexedDBBlobInfo>*,
ScopedVector<webkit_blob::BlobDataHandle>* handles);
LevelDBTransaction* transaction() { return transaction_; }
leveldb::Status GetBlobInfoForRecord(
int64 database_id,
const std::string& object_store_data_key,
IndexedDBValue* value);
// This holds a BlobEntryKey and the encoded IndexedDBBlobInfo vector stored
// under that key.
typedef std::vector<std::pair<BlobEntryKey, std::string> >
BlobEntryKeyValuePairVec;
class WriteDescriptor {
public:
WriteDescriptor(const GURL& url, int64_t key, int64_t size);
WriteDescriptor(const base::FilePath& path,
int64_t key,
int64_t size,
base::Time last_modified);
bool is_file() const { return is_file_; }
const GURL& url() const {
DCHECK(!is_file_);
return url_;
}
const base::FilePath& file_path() const {
DCHECK(is_file_);
return file_path_;
}
int64_t key() const { return key_; }
int64_t size() const { return size_; }
base::Time last_modified() const { return last_modified_; }
private:
bool is_file_;
GURL url_;
base::FilePath file_path_;
int64_t key_;
int64_t size_;
base::Time last_modified_;
};
class ChainedBlobWriter : public base::RefCounted<ChainedBlobWriter> {
public:
virtual void set_delegate(
scoped_ptr<fileapi::FileWriterDelegate> delegate) = 0;
// TODO(ericu): Add a reason in the event of failure.
virtual void ReportWriteCompletion(bool succeeded,
int64 bytes_written) = 0;
virtual void Abort() = 0;
protected:
virtual ~ChainedBlobWriter() {}
friend class base::RefCounted<ChainedBlobWriter>;
};
class ChainedBlobWriterImpl;
typedef std::vector<WriteDescriptor> WriteDescriptorVec;
private:
class BlobWriteCallbackWrapper;
leveldb::Status HandleBlobPreTransaction(
BlobEntryKeyValuePairVec* new_blob_entries,
WriteDescriptorVec* new_files_to_write);
// Returns true on success, false on failure.
bool CollectBlobFilesToRemove();
// The callback will be called eventually on success or failure.
void WriteNewBlobs(BlobEntryKeyValuePairVec& new_blob_entries,
WriteDescriptorVec& new_files_to_write,
scoped_refptr<BlobWriteCallback> callback);
leveldb::Status SortBlobsToRemove();
IndexedDBBackingStore* backing_store_;
scoped_refptr<LevelDBTransaction> transaction_;
BlobChangeMap blob_change_map_;
BlobChangeMap incognito_blob_map_;
int64 database_id_;
BlobJournalType blobs_to_remove_;
scoped_refptr<ChainedBlobWriter> chained_blob_writer_;
};
protected:
IndexedDBBackingStore(IndexedDBFactory* indexed_db_factory,
const GURL& origin_url,
const base::FilePath& blob_path,
net::URLRequestContext* request_context,
scoped_ptr<LevelDBDatabase> db,
scoped_ptr<LevelDBComparator> comparator,
base::TaskRunner* task_runner);
virtual ~IndexedDBBackingStore();
friend class base::RefCounted<IndexedDBBackingStore>;
bool is_incognito() const { return !indexed_db_factory_; }
bool SetUpMetadata();
virtual bool WriteBlobFile(
int64 database_id,
const Transaction::WriteDescriptor& descriptor,
Transaction::ChainedBlobWriter* chained_blob_writer);
virtual bool RemoveBlobFile(int64 database_id, int64 key);
virtual void StartJournalCleaningTimer();
void CleanPrimaryJournalIgnoreReturn();
private:
static scoped_refptr<IndexedDBBackingStore> Create(
IndexedDBFactory* indexed_db_factory,
const GURL& origin_url,
const base::FilePath& blob_path,
net::URLRequestContext* request_context,
scoped_ptr<LevelDBDatabase> db,
scoped_ptr<LevelDBComparator> comparator,
base::TaskRunner* task_runner);
static bool ReadCorruptionInfo(const base::FilePath& path_base,
const GURL& origin_url,
std::string& message);
leveldb::Status FindKeyInIndex(
IndexedDBBackingStore::Transaction* transaction,
int64 database_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKey& key,
std::string* found_encoded_primary_key,
bool* found);
leveldb::Status GetIndexes(int64 database_id,
int64 object_store_id,
IndexedDBObjectStoreMetadata::IndexMap* map)
WARN_UNUSED_RESULT;
bool RemoveBlobDirectory(int64 database_id);
leveldb::Status CleanUpBlobJournal(const std::string& level_db_key);
IndexedDBFactory* indexed_db_factory_;
const GURL origin_url_;
base::FilePath blob_path_;
// The origin identifier is a key prefix unique to the origin used in the
// leveldb backing store to partition data by origin. It is a normalized
// version of the origin URL with a versioning suffix appended, e.g.
// "http_localhost_81@1" Since only one origin is stored per backing store
// this is redundant but necessary for backwards compatibility; the suffix
// provides for future flexibility.
const std::string origin_identifier_;
net::URLRequestContext* request_context_;
base::TaskRunner* task_runner_;
std::set<int> child_process_ids_granted_;
BlobChangeMap incognito_blob_map_;
base::OneShotTimer<IndexedDBBackingStore> journal_cleaning_timer_;
scoped_ptr<LevelDBDatabase> db_;
scoped_ptr<LevelDBComparator> comparator_;
// Whenever blobs are registered in active_blob_registry_, indexed_db_factory_
// will hold a reference to this backing store.
IndexedDBActiveBlobRegistry active_blob_registry_;
base::OneShotTimer<IndexedDBBackingStore> close_timer_;
DISALLOW_COPY_AND_ASSIGN(IndexedDBBackingStore);
};
} // namespace content
#endif // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_
| bsd-3-clause |
gavinp/chromium | chrome/browser/ui/views/frame/opaque_browser_frame_view.h | 7146 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_UI_VIEWS_FRAME_OPAQUE_BROWSER_FRAME_VIEW_H_
#define CHROME_BROWSER_UI_VIEWS_FRAME_OPAQUE_BROWSER_FRAME_VIEW_H_
#pragma once
#include "base/memory/scoped_ptr.h"
#include "chrome/browser/ui/views/frame/browser_frame.h"
#include "chrome/browser/ui/views/frame/browser_non_client_frame_view.h"
#include "chrome/browser/ui/views/tab_icon_view.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/window/non_client_view.h"
class BrowserView;
namespace views {
class ImageButton;
class FrameBackground;
}
class OpaqueBrowserFrameView : public BrowserNonClientFrameView,
public content::NotificationObserver,
public views::ButtonListener,
public TabIconView::TabIconViewModel {
public:
// Constructs a non-client view for an BrowserFrame.
OpaqueBrowserFrameView(BrowserFrame* frame, BrowserView* browser_view);
virtual ~OpaqueBrowserFrameView();
// Overridden from BrowserNonClientFrameView:
virtual gfx::Rect GetBoundsForTabStrip(views::View* tabstrip) const OVERRIDE;
virtual int GetHorizontalTabStripVerticalOffset(bool restored) const OVERRIDE;
virtual void UpdateThrobber(bool running) OVERRIDE;
virtual gfx::Size GetMinimumSize() OVERRIDE;
protected:
views::ImageButton* minimize_button() const { return minimize_button_; }
views::ImageButton* maximize_button() const { return maximize_button_; }
views::ImageButton* restore_button() const { return restore_button_; }
views::ImageButton* close_button() const { return close_button_; }
// Used to allow subclasses to reserve height for other components they
// will add. The space is reserved below the ClientView.
virtual int GetReservedHeight() const;
virtual gfx::Rect GetBoundsForReservedArea() const;
// Returns the height of the entire nonclient top border, including the window
// frame, any title area, and any connected client edge. If |restored| is
// true, acts as if the window is restored regardless of the real mode.
int NonClientTopBorderHeight(bool restored) const;
// Overridden from views::NonClientFrameView:
virtual gfx::Rect GetBoundsForClientView() const OVERRIDE;
virtual gfx::Rect GetWindowBoundsForClientBounds(
const gfx::Rect& client_bounds) const OVERRIDE;
virtual int NonClientHitTest(const gfx::Point& point) OVERRIDE;
virtual void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask)
OVERRIDE;
virtual void ResetWindowControls() OVERRIDE;
virtual void UpdateWindowIcon() OVERRIDE;
// Overridden from views::View:
virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
virtual void Layout() OVERRIDE;
virtual bool HitTest(const gfx::Point& l) const OVERRIDE;
virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE;
// Overridden from views::ButtonListener:
virtual void ButtonPressed(views::Button* sender, const views::Event& event)
OVERRIDE;
// Overridden from TabIconView::TabIconViewModel:
virtual bool ShouldTabIconViewAnimate() const OVERRIDE;
virtual SkBitmap GetFaviconForTabIconView() OVERRIDE;
// content::NotificationObserver implementation:
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE;
private:
// Creates, adds and returns a new image button with |this| as its listener.
// Memory is owned by the caller.
views::ImageButton* InitWindowCaptionButton(int normal_bitmap_id,
int hot_bitmap_id,
int pushed_bitmap_id,
int mask_bitmap_id,
int accessibility_string_id);
// Returns the thickness of the border that makes up the window frame edges.
// This does not include any client edge. If |restored| is true, acts as if
// the window is restored regardless of the real mode.
int FrameBorderThickness(bool restored) const;
// Returns the height of the top resize area. This is smaller than the frame
// border height in order to increase the window draggable area.
int TopResizeHeight() const;
// Returns the thickness of the entire nonclient left, right, and bottom
// borders, including both the window frame and any client edge.
int NonClientBorderThickness() const;
// Returns the y-coordinate of the caption buttons. If |restored| is true,
// acts as if the window is restored regardless of the real mode.
int CaptionButtonY(bool restored) const;
// Returns the thickness of the 3D edge along the bottom of the titlebar. If
// |restored| is true, acts as if the window is restored regardless of the
// real mode.
int TitlebarBottomThickness(bool restored) const;
// Returns the size of the titlebar icon. This is used even when the icon is
// not shown, e.g. to set the titlebar height.
int IconSize() const;
// Returns the bounds of the titlebar icon (or where the icon would be if
// there was one).
gfx::Rect IconBounds() const;
// Paint various sub-components of this view. The *FrameBorder() functions
// also paint the background of the titlebar area, since the top frame border
// and titlebar background are a contiguous component.
void PaintRestoredFrameBorder(gfx::Canvas* canvas);
void PaintMaximizedFrameBorder(gfx::Canvas* canvas);
void PaintTitleBar(gfx::Canvas* canvas);
void PaintToolbarBackground(gfx::Canvas* canvas);
void PaintRestoredClientEdge(gfx::Canvas* canvas);
// Compute aspects of the frame needed to paint the frame background.
SkColor GetFrameColor() const;
SkBitmap* GetFrameBitmap() const;
SkBitmap* GetFrameOverlayBitmap() const;
int GetTopAreaHeight() const;
// Layout various sub-components of this view.
void LayoutWindowControls();
void LayoutTitleBar();
void LayoutAvatar();
// Returns the bounds of the client area for the specified view size.
gfx::Rect CalculateClientAreaBounds(int width, int height) const;
// The layout rect of the title, if visible.
gfx::Rect title_bounds_;
// The layout rect of the avatar icon, if visible.
gfx::Rect avatar_bounds_;
// Window controls.
views::ImageButton* minimize_button_;
views::ImageButton* maximize_button_;
views::ImageButton* restore_button_;
views::ImageButton* close_button_;
// The Window icon.
TabIconView* window_icon_;
// The bounds of the ClientView.
gfx::Rect client_view_bounds_;
content::NotificationRegistrar registrar_;
// Background painter for the window frame.
scoped_ptr<views::FrameBackground> frame_background_;
DISALLOW_COPY_AND_ASSIGN(OpaqueBrowserFrameView);
};
#endif // CHROME_BROWSER_UI_VIEWS_FRAME_OPAQUE_BROWSER_FRAME_VIEW_H_
| bsd-3-clause |
santoshn/softboundcets-34 | softboundcets-llvm-clang34/tools/clang/test/Sema/warn-main-return-type.c | 1543 | // RUN: %clang_cc1 -fsyntax-only -verify %s
// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -x c++ %s 2>&1 | FileCheck %s
// expected-note@+1 5{{previous definition is here}}
int main() {
return 0;
}
// expected-error@+3 {{conflicting types for 'main}}
// expected-warning@+2 {{return type of 'main' is not 'int'}}
// expected-note@+1 {{change return type to 'int'}}
void main() {
// CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:1-[[@LINE-1]]:5}:"int"
}
// expected-error@+3 {{conflicting types for 'main}}
// expected-warning@+2 {{return type of 'main' is not 'int'}}
// expected-note@+1 {{change return type to 'int'}}
double main() {
// CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:1-[[@LINE-1]]:7}:"int"
return 0.0;
}
// Currently we suggest to replace only 'float' here because we don't store
// enough source locations.
//
// expected-error@+3 {{conflicting types for 'main}}
// expected-warning@+2 {{return type of 'main' is not 'int'}}
// expected-note@+1 {{change return type to 'int'}}
const float main() {
// CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:7-[[@LINE-1]]:12}:"int"
return 0.0f;
}
typedef void *(*fptr)(int a);
// expected-error@+2 {{conflicting types for 'main}}
// expected-warning@+1 {{return type of 'main' is not 'int'}}
fptr main() {
return (fptr) 0;
}
// expected-error@+2 {{conflicting types for 'main}}
// expected-warning@+1 {{return type of 'main' is not 'int'}}
void *(*main())(int a) {
return (fptr) 0;
}
| bsd-3-clause |
ChromeDevTools/devtools-frontend | node_modules/@typescript-eslint/experimental-utils/dist/ts-eslint-scope/Variable.js | 419 | "use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Variable = void 0;
const variable_1 = __importDefault(require("eslint-scope/lib/variable"));
const Variable = variable_1.default;
exports.Variable = Variable;
//# sourceMappingURL=Variable.js.map | bsd-3-clause |
chromium/chromium | services/device/hid/hid_preparsed_data.cc | 10536 | // Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "services/device/hid/hid_preparsed_data.h"
#include <cstddef>
#include <cstdint>
#include "base/debug/dump_without_crashing.h"
#include "base/memory/ptr_util.h"
#include "base/notreached.h"
#include "components/device_event_log/device_event_log.h"
namespace device {
namespace {
// Windows parses HID report descriptors into opaque _HIDP_PREPARSED_DATA
// objects. The internal structure of _HIDP_PREPARSED_DATA is reserved for
// internal system use. The structs below are inferred and may be wrong or
// incomplete.
// https://docs.microsoft.com/en-us/windows-hardware/drivers/hid/preparsed-data
//
// _HIDP_PREPARSED_DATA begins with a fixed-sized header containing information
// about a single top-level HID collection. The header is followed by a
// variable-sized array describing the fields that make up each report.
//
// Input report items appear first in the array, followed by output report items
// and feature report items. The number of items of each type is given by
// |input_item_count|, |output_item_count| and |feature_item_count|. The sum of
// these counts should equal |item_count|. The total size in bytes of all report
// items is |size_bytes|.
#pragma pack(push, 1)
struct PreparsedDataHeader {
// Unknown constant value. _HIDP_PREPARSED_DATA identifier?
uint64_t magic;
// Top-level collection usage information.
uint16_t usage;
uint16_t usage_page;
uint16_t unknown[3];
// Number of report items for input reports. Includes unused items.
uint16_t input_item_count;
uint16_t unknown2;
// Maximum input report size, in bytes. Includes the report ID byte. Zero if
// there are no input reports.
uint16_t input_report_byte_length;
uint16_t unknown3;
// Number of report items for output reports. Includes unused items.
uint16_t output_item_count;
uint16_t unknown4;
// Maximum output report size, in bytes. Includes the report ID byte. Zero if
// there are no output reports.
uint16_t output_report_byte_length;
uint16_t unknown5;
// Number of report items for feature reports. Includes unused items.
uint16_t feature_item_count;
// Total number of report items (input, output, and feature). Unused items are
// excluded.
uint16_t item_count;
// Maximum feature report size, in bytes. Includes the report ID byte. Zero if
// there are no feature reports.
uint16_t feature_report_byte_length;
// Total size of all report items, in bytes.
uint16_t size_bytes;
uint16_t unknown6;
};
#pragma pack(pop)
static_assert(sizeof(PreparsedDataHeader) == 44,
"PreparsedDataHeader has incorrect size");
#pragma pack(push, 1)
struct PreparsedDataItem {
// Usage page for |usage_minimum| and |usage_maximum|.
uint16_t usage_page;
// Report ID for the report containing this item.
uint8_t report_id;
// Bit offset from |byte_index|.
uint8_t bit_index;
// Bit width of a single field defined by this item.
uint16_t bit_size;
// The number of fields defined by this item.
uint16_t report_count;
// Byte offset from the start of the report containing this item, including
// the report ID byte.
uint16_t byte_index;
// The total number of bits for all fields defined by this item.
uint16_t bit_count;
// The bit field for the corresponding main item in the HID report. This bit
// field is defined in the Device Class Definition for HID v1.11 section
// 6.2.2.5.
// https://www.usb.org/document-library/device-class-definition-hid-111
uint32_t bit_field;
uint32_t unknown;
// Usage information for the collection containing this item.
uint16_t link_usage_page;
uint16_t link_usage;
uint32_t unknown2[9];
// The usage range for this item.
uint16_t usage_minimum;
uint16_t usage_maximum;
// The string descriptor index range associated with this item. If the item
// has no string descriptors, |string_minimum| and |string_maximum| are set to
// zero.
uint16_t string_minimum;
uint16_t string_maximum;
// The designator index range associated with this item. If the item has no
// designators, |designator_minimum| and |designator_maximum| are set to zero.
uint16_t designator_minimum;
uint16_t designator_maximum;
// The data index range associated with this item.
uint16_t data_index_minimum;
uint16_t data_index_maximum;
uint32_t unknown3;
// The range of fields defined by this item in logical units.
int32_t logical_minimum;
int32_t logical_maximum;
// The range of fields defined by this item in units defined by |unit| and
// |unit_exponent|. If this item does not use physical units,
// |physical_minimum| and |physical_maximum| are set to zero.
int32_t physical_minimum;
int32_t physical_maximum;
// The unit definition for this item. The format for this definition is
// described in the Device Class Definition for HID v1.11 section 6.2.2.7.
// https://www.usb.org/document-library/device-class-definition-hid-111
uint32_t unit;
uint32_t unit_exponent;
};
#pragma pack(pop)
static_assert(sizeof(PreparsedDataItem) == 104,
"PreparsedDataItem has incorrect size");
bool ValidatePreparsedDataHeader(const PreparsedDataHeader& header) {
static bool has_dumped_without_crashing = false;
// _HIDP_PREPARSED_DATA objects are expected to start with a known constant
// value.
constexpr uint64_t kHidPreparsedDataMagic = 0x52444B2050646948;
// Require a matching magic value. The details of _HIDP_PREPARSED_DATA are
// proprietary and the magic constant may change. If DCHECKS are on, trigger
// a CHECK failure and crash. Otherwise, generate a non-crash dump.
DCHECK_EQ(header.magic, kHidPreparsedDataMagic);
if (header.magic != kHidPreparsedDataMagic) {
HID_LOG(ERROR) << "Unexpected magic value.";
if (has_dumped_without_crashing) {
base::debug::DumpWithoutCrashing();
has_dumped_without_crashing = true;
}
return false;
}
if (header.input_report_byte_length == 0 && header.input_item_count > 0)
return false;
if (header.output_report_byte_length == 0 && header.output_item_count > 0)
return false;
if (header.feature_report_byte_length == 0 && header.feature_item_count > 0)
return false;
// Calculate the expected total size of report items in the
// _HIDP_PREPARSED_DATA object. Use the individual item counts for each report
// type instead of the total |item_count|. In some cases additional items are
// allocated but are not used for any reports. Unused items are excluded from
// |item_count| but are included in the item counts for each report type and
// contribute to the total size of the object. See crbug.com/1199890 for more
// information.
uint16_t total_item_size =
(header.input_item_count + header.output_item_count +
header.feature_item_count) *
sizeof(PreparsedDataItem);
if (total_item_size != header.size_bytes)
return false;
return true;
}
bool ValidatePreparsedDataItem(const PreparsedDataItem& item) {
// Check that the item does not overlap with the report ID byte.
if (item.byte_index == 0)
return false;
// Check that the bit index does not exceed the maximum bit index in one byte.
if (item.bit_index >= CHAR_BIT)
return false;
// Check that the item occupies at least one bit in the report.
if (item.report_count == 0 || item.bit_size == 0 || item.bit_count == 0)
return false;
return true;
}
HidServiceWin::PreparsedData::ReportItem MakeReportItemFromPreparsedData(
const PreparsedDataItem& item) {
size_t bit_index = (item.byte_index - 1) * CHAR_BIT + item.bit_index;
return {item.report_id, item.bit_field,
item.bit_size, item.report_count,
item.usage_page, item.usage_minimum,
item.usage_maximum, item.designator_minimum,
item.designator_maximum, item.string_minimum,
item.string_maximum, item.logical_minimum,
item.logical_maximum, item.physical_minimum,
item.physical_maximum, item.unit,
item.unit_exponent, bit_index};
}
} // namespace
// static
std::unique_ptr<HidPreparsedData> HidPreparsedData::Create(
HANDLE device_handle) {
PHIDP_PREPARSED_DATA preparsed_data;
if (!HidD_GetPreparsedData(device_handle, &preparsed_data) ||
!preparsed_data) {
HID_PLOG(EVENT) << "Failed to get device data";
return nullptr;
}
HIDP_CAPS capabilities;
if (HidP_GetCaps(preparsed_data, &capabilities) != HIDP_STATUS_SUCCESS) {
HID_PLOG(EVENT) << "Failed to get device capabilities";
HidD_FreePreparsedData(preparsed_data);
return nullptr;
}
return base::WrapUnique(new HidPreparsedData(preparsed_data, capabilities));
}
HidPreparsedData::HidPreparsedData(PHIDP_PREPARSED_DATA preparsed_data,
HIDP_CAPS capabilities)
: preparsed_data_(preparsed_data), capabilities_(capabilities) {
DCHECK(preparsed_data_);
}
HidPreparsedData::~HidPreparsedData() {
HidD_FreePreparsedData(preparsed_data_);
}
const HIDP_CAPS& HidPreparsedData::GetCaps() const {
return capabilities_;
}
std::vector<HidServiceWin::PreparsedData::ReportItem>
HidPreparsedData::GetReportItems(HIDP_REPORT_TYPE report_type) const {
const auto& header =
*reinterpret_cast<const PreparsedDataHeader*>(preparsed_data_);
if (!ValidatePreparsedDataHeader(header))
return {};
size_t min_index;
size_t item_count;
switch (report_type) {
case HidP_Input:
min_index = 0;
item_count = header.input_item_count;
break;
case HidP_Output:
min_index = header.input_item_count;
item_count = header.output_item_count;
break;
case HidP_Feature:
min_index = header.input_item_count + header.output_item_count;
item_count = header.feature_item_count;
break;
default:
return {};
}
if (item_count == 0)
return {};
const auto* data = reinterpret_cast<const uint8_t*>(preparsed_data_);
const auto* items = reinterpret_cast<const PreparsedDataItem*>(
data + sizeof(PreparsedDataHeader));
std::vector<ReportItem> report_items;
for (size_t i = min_index; i < min_index + item_count; ++i) {
if (ValidatePreparsedDataItem(items[i]))
report_items.push_back(MakeReportItemFromPreparsedData(items[i]));
}
return report_items;
}
} // namespace device
| bsd-3-clause |
firstsee/ServiceStack | tests/ServiceStack.Common.Tests/Models/ModelWithIndexFields.cs | 300 | using ServiceStack.DataAnnotations;
namespace ServiceStack.Common.Tests.Models
{
public class ModelWithIndexFields
{
public string Id { get; set; }
[Index]
public string Name { get; set; }
public string AlbumId { get; set; }
[Index(true)]
public string UniqueName { get; set; }
}
} | bsd-3-clause |
ric2b/Vivaldi-browser | chromium/ash/perftests/ash_background_filter_blur_perftest.cc | 5648 | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include "ash/shell.h"
#include "ash/test/ash_test_base.h"
#include "base/timer/lap_timer.h"
#include "testing/perf/perf_test.h"
#include "ui/aura/window.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/test/draw_waiter_for_test.h"
namespace ash {
namespace {
// TODO(wutao): On chromeos_linux builds, the tests only run with
// use_ozone = false.
class AshBackgroundFilterBlurPerfTest : public AshTestBase {
public:
AshBackgroundFilterBlurPerfTest() : timer_(0, base::TimeDelta(), 1) {}
AshBackgroundFilterBlurPerfTest(const AshBackgroundFilterBlurPerfTest&) =
delete;
AshBackgroundFilterBlurPerfTest& operator=(
const AshBackgroundFilterBlurPerfTest&) = delete;
~AshBackgroundFilterBlurPerfTest() override = default;
// AshTestBase:
void SetUp() override;
protected:
std::unique_ptr<ui::Layer> CreateSolidColorLayer(SkColor color);
void WithBoundsChange(ui::Layer* layer,
int num_iteration,
const std::string& test_name);
void WithOpacityChange(ui::Layer* layer,
int num_iteration,
const std::string& test_name);
std::unique_ptr<ui::Layer> background_layer_;
std::unique_ptr<ui::Layer> blur_layer_;
private:
ui::Layer* root_layer_ = nullptr;
ui::Compositor* compositor_ = nullptr;
base::LapTimer timer_;
};
void AshBackgroundFilterBlurPerfTest::SetUp() {
AshTestBase::SetUp();
// This is for consistency even if the default display size changed.
UpdateDisplay("800x600");
root_layer_ = Shell::GetAllRootWindows()[0]->layer();
compositor_ = root_layer_->GetCompositor();
background_layer_ = CreateSolidColorLayer(SK_ColorGREEN);
blur_layer_ = CreateSolidColorLayer(SK_ColorBLACK);
}
std::unique_ptr<ui::Layer>
AshBackgroundFilterBlurPerfTest::CreateSolidColorLayer(SkColor color) {
std::unique_ptr<ui::Layer> layer =
std::make_unique<ui::Layer>(ui::LAYER_SOLID_COLOR);
layer->SetBounds(root_layer_->bounds());
layer->SetColor(color);
root_layer_->Add(layer.get());
root_layer_->StackAtTop(layer.get());
return layer;
}
void AshBackgroundFilterBlurPerfTest::WithBoundsChange(
ui::Layer* layer,
int num_iteration,
const std::string& test_name) {
const gfx::Rect init_bounds = layer->GetTargetBounds();
// Wait for a DidCommit before starts the loop, and do not measure the last
// iteration of the loop.
ui::DrawWaiterForTest::WaitForCommit(compositor_);
timer_.Reset();
for (int i = 1; i <= num_iteration + 1; ++i) {
float fraction = (static_cast<float>(i) / num_iteration);
const gfx::Rect bounds =
gfx::Rect(0, 0, static_cast<int>(init_bounds.width() * fraction),
static_cast<int>(init_bounds.height() * fraction));
layer->SetBounds(bounds);
ui::DrawWaiterForTest::WaitForCommit(compositor_);
if (i <= num_iteration)
timer_.NextLap();
}
perf_test::PrintResult("AshBackgroundFilterBlurPerfTest", std::string(),
test_name, timer_.LapsPerSecond(), "runs/s", true);
}
void AshBackgroundFilterBlurPerfTest::WithOpacityChange(
ui::Layer* layer,
int num_iteration,
const std::string& test_name) {
float init_opacity = layer->GetTargetOpacity();
// Wait for a DidCommit before starts the loop, and do not measure the last
// iteration of the loop.
ui::DrawWaiterForTest::WaitForCommit(compositor_);
timer_.Reset();
for (int i = 1; i <= num_iteration + 1; ++i) {
float fraction = (static_cast<float>(i) / num_iteration);
float opacity = std::min(1.0f, init_opacity * fraction);
layer->SetOpacity(opacity);
ui::DrawWaiterForTest::WaitForCommit(compositor_);
if (i <= num_iteration)
timer_.NextLap();
}
perf_test::PrintResult("AshBackgroundFilterBlurPerfTest", std::string(),
test_name, timer_.LapsPerSecond(), "runs/s", true);
}
TEST_F(AshBackgroundFilterBlurPerfTest, NoBlurBackgroundLayerBoundsChange) {
WithBoundsChange(background_layer_.get(), 100,
"no_blur_background_layer_bounds_change");
}
TEST_F(AshBackgroundFilterBlurPerfTest, NoBlurBlurLayerBoundsChange) {
WithBoundsChange(blur_layer_.get(), 100, "no_blur_blur_layer_bounds_change");
}
TEST_F(AshBackgroundFilterBlurPerfTest, BackgroundLayerBoundsChange) {
blur_layer_->SetBackgroundBlur(10.f);
WithBoundsChange(background_layer_.get(), 100,
"background_layer_bounds_change");
}
TEST_F(AshBackgroundFilterBlurPerfTest, BlurLayerBoundsChange) {
blur_layer_->SetBackgroundBlur(10.f);
WithBoundsChange(blur_layer_.get(), 100, "blur_layer_bounds_change");
}
TEST_F(AshBackgroundFilterBlurPerfTest, NoBlurBackgroundLayerOpacityChange) {
WithOpacityChange(background_layer_.get(), 100,
"no_blur_background_layer_opacity_change");
}
TEST_F(AshBackgroundFilterBlurPerfTest, NoBlurBlurLayerOpacityChange) {
WithOpacityChange(blur_layer_.get(), 100,
"no_blur_blur_layer_opacity_change");
}
TEST_F(AshBackgroundFilterBlurPerfTest, BackgroundLayerOpacityChange) {
blur_layer_->SetBackgroundBlur(10.f);
WithOpacityChange(background_layer_.get(), 100,
"background_layer_opacity_change");
}
TEST_F(AshBackgroundFilterBlurPerfTest, BlurLayerOpacityChange) {
blur_layer_->SetBackgroundBlur(10.f);
WithOpacityChange(blur_layer_.get(), 100, "blur_layer_opacity_change");
}
} // namespace
} // namespace ash
| bsd-3-clause |
endlessm/chromium-browser | third_party/webgl/src/sdk/tests/conformance/glsl/bugs/modulo-arithmetic-accuracy.html | 1848 | <!--
Copyright (c) 2019 The Khronos Group Inc.
Use of this source code is governed by an MIT-style license that can be
found in the LICENSE.txt file.
-->
<!-- author: Bill Baxter (wbaxter at google.com) -->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Modulo Arithmetic Accuracy Bug</title>
<link rel="stylesheet" href="../../../resources/js-test-style.css"/>
<script src="../../../js/js-test-pre.js"></script>
<script src="../../../js/webgl-test-utils.js"></script>
<script src="../../../js/glsl-conformance-test.js"></script>
</head>
<body>
<div id="description"></div>
<div id="console"></div>
<script id="shader-vs" type="x-shader/x-vertex">
attribute vec4 vPosition;
uniform float divisor;
varying vec4 vColor;
void main(void) {
gl_Position = vPosition;
float index = 9.0;
// mod(x, y) is computed as x-y*floor(x/y). There are no guarantees on
// the precision of floating point operations in WebGL shaders, but division
// should be accurate to at least 1 part in 10^5.
float value = mod(index * 1.00001, divisor);
vColor = (value < 1.) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
}
</script>
<script id="shader-fs" type="x-shader/x-fragment">
precision mediump float;
varying vec4 vColor;
void main(void) {
gl_FragColor = vColor;
}
</script>
<script>
"use strict";
description();
debug("");
// Reproduces bug seen on Mac OS X with AMD Radeon HD 6490 GPU
debug("If things are working correctly, then the square will be green.");
debug("If your card thinks mod(9,3) is not 0, then the square will be red.");
GLSLConformanceTester.runRenderTests([
{
vShaderId: 'shader-vs',
vShaderSuccess: true,
fShaderId: 'shader-fs',
fShaderSuccess: true,
linkSuccess: true,
passMsg: 'Test that mod(9/3) is 0',
uniforms: [{name: "divisor", functionName: "uniform1f", value: 3}]
}
]);
</script>
</body>
</html>
| bsd-3-clause |
guorendong/iridium-browser-ubuntu | sync/test/engine/mock_connection_manager.cc | 25782 | // Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Mock ServerConnectionManager class for use in client regression tests.
#include "sync/test/engine/mock_connection_manager.h"
#include <map>
#include "base/location.h"
#include "base/strings/stringprintf.h"
#include "sync/engine/syncer_proto_util.h"
#include "sync/protocol/bookmark_specifics.pb.h"
#include "sync/syncable/directory.h"
#include "sync/syncable/syncable_write_transaction.h"
#include "sync/test/engine/test_id_factory.h"
#include "testing/gtest/include/gtest/gtest.h"
using std::find;
using std::map;
using std::string;
using sync_pb::ClientToServerMessage;
using sync_pb::CommitMessage;
using sync_pb::CommitResponse;
using sync_pb::GetUpdatesMessage;
using sync_pb::SyncEnums;
namespace syncer {
using syncable::WriteTransaction;
static char kValidAuthToken[] = "AuthToken";
static char kCacheGuid[] = "kqyg7097kro6GSUod+GSg==";
MockConnectionManager::MockConnectionManager(syncable::Directory* directory,
CancelationSignal* signal)
: ServerConnectionManager("unused", 0, false, signal),
server_reachable_(true),
conflict_all_commits_(false),
conflict_n_commits_(0),
next_new_id_(10000),
store_birthday_("Store BDay!"),
store_birthday_sent_(false),
client_stuck_(false),
countdown_to_postbuffer_fail_(0),
directory_(directory),
mid_commit_observer_(NULL),
throttling_(false),
partialThrottling_(false),
fail_with_auth_invalid_(false),
fail_non_periodic_get_updates_(false),
next_position_in_parent_(2),
use_legacy_bookmarks_protocol_(false),
num_get_updates_requests_(0) {
SetNewTimestamp(0);
SetAuthToken(kValidAuthToken);
}
MockConnectionManager::~MockConnectionManager() {
EXPECT_TRUE(update_queue_.empty()) << "Unfetched updates.";
}
void MockConnectionManager::SetCommitTimeRename(string prepend) {
commit_time_rename_prepended_string_ = prepend;
}
void MockConnectionManager::SetMidCommitCallback(
const base::Closure& callback) {
mid_commit_callback_ = callback;
}
void MockConnectionManager::SetMidCommitObserver(
MockConnectionManager::MidCommitObserver* observer) {
mid_commit_observer_ = observer;
}
bool MockConnectionManager::PostBufferToPath(PostBufferParams* params,
const string& path,
const string& auth_token,
ScopedServerStatusWatcher* watcher) {
ClientToServerMessage post;
CHECK(post.ParseFromString(params->buffer_in));
CHECK(post.has_protocol_version());
CHECK(post.has_api_key());
CHECK(post.has_bag_of_chips());
requests_.push_back(post);
client_stuck_ = post.sync_problem_detected();
sync_pb::ClientToServerResponse response;
response.Clear();
if (directory_) {
// If the Directory's locked when we do this, it's a problem as in normal
// use this function could take a while to return because it accesses the
// network. As we can't test this we do the next best thing and hang here
// when there's an issue.
CHECK(directory_->good());
WriteTransaction wt(FROM_HERE, syncable::UNITTEST, directory_);
}
if (auth_token.empty()) {
params->response.server_status = HttpResponse::SYNC_AUTH_ERROR;
return false;
}
if (auth_token != kValidAuthToken) {
// Simulate server-side auth failure.
params->response.server_status = HttpResponse::SYNC_AUTH_ERROR;
InvalidateAndClearAuthToken();
}
if (--countdown_to_postbuffer_fail_ == 0) {
// Fail as countdown hits zero.
params->response.server_status = HttpResponse::SYNC_SERVER_ERROR;
return false;
}
if (!server_reachable_) {
params->response.server_status = HttpResponse::CONNECTION_UNAVAILABLE;
return false;
}
// Default to an ok connection.
params->response.server_status = HttpResponse::SERVER_CONNECTION_OK;
response.set_error_code(SyncEnums::SUCCESS);
const string current_store_birthday = store_birthday();
response.set_store_birthday(current_store_birthday);
if (post.has_store_birthday() && post.store_birthday() !=
current_store_birthday) {
response.set_error_code(SyncEnums::NOT_MY_BIRTHDAY);
response.set_error_message("Merry Unbirthday!");
response.SerializeToString(¶ms->buffer_out);
store_birthday_sent_ = true;
return true;
}
bool result = true;
EXPECT_TRUE(!store_birthday_sent_ || post.has_store_birthday() ||
post.message_contents() == ClientToServerMessage::AUTHENTICATE);
store_birthday_sent_ = true;
if (post.message_contents() == ClientToServerMessage::COMMIT) {
ProcessCommit(&post, &response);
} else if (post.message_contents() == ClientToServerMessage::GET_UPDATES) {
ProcessGetUpdates(&post, &response);
} else {
EXPECT_TRUE(false) << "Unknown/unsupported ClientToServerMessage";
return false;
}
{
base::AutoLock lock(response_code_override_lock_);
if (throttling_) {
response.set_error_code(SyncEnums::THROTTLED);
throttling_ = false;
}
if (partialThrottling_) {
sync_pb::ClientToServerResponse_Error* response_error =
response.mutable_error();
response_error->set_error_type(SyncEnums::PARTIAL_FAILURE);
for (ModelTypeSet::Iterator it = throttled_type_.First(); it.Good();
it.Inc()) {
response_error->add_error_data_type_ids(
GetSpecificsFieldNumberFromModelType(it.Get()));
}
partialThrottling_ = false;
}
if (fail_with_auth_invalid_)
response.set_error_code(SyncEnums::AUTH_INVALID);
}
response.SerializeToString(¶ms->buffer_out);
if (post.message_contents() == ClientToServerMessage::COMMIT &&
!mid_commit_callback_.is_null()) {
mid_commit_callback_.Run();
mid_commit_callback_.Reset();
}
if (mid_commit_observer_) {
mid_commit_observer_->Observe();
}
return result;
}
sync_pb::GetUpdatesResponse* MockConnectionManager::GetUpdateResponse() {
if (update_queue_.empty()) {
NextUpdateBatch();
}
return &update_queue_.back();
}
void MockConnectionManager::AddDefaultBookmarkData(sync_pb::SyncEntity* entity,
bool is_folder) {
if (use_legacy_bookmarks_protocol_) {
sync_pb::SyncEntity_BookmarkData* data = entity->mutable_bookmarkdata();
data->set_bookmark_folder(is_folder);
if (!is_folder) {
data->set_bookmark_url("http://google.com");
}
} else {
entity->set_folder(is_folder);
entity->mutable_specifics()->mutable_bookmark();
if (!is_folder) {
entity->mutable_specifics()->mutable_bookmark()->
set_url("http://google.com");
}
}
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
int id,
int parent_id,
string name,
int64 version,
int64 sync_ts,
std::string originator_cache_guid,
std::string originator_client_item_id) {
return AddUpdateDirectory(TestIdFactory::FromNumber(id),
TestIdFactory::FromNumber(parent_id),
name,
version,
sync_ts,
originator_cache_guid,
originator_client_item_id);
}
void MockConnectionManager::SetGUClientCommand(
sync_pb::ClientCommand* command) {
gu_client_command_.reset(command);
}
void MockConnectionManager::SetCommitClientCommand(
sync_pb::ClientCommand* command) {
commit_client_command_.reset(command);
}
void MockConnectionManager::SetTransientErrorId(syncable::Id id) {
transient_error_ids_.push_back(id);
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
int id, int parent_id,
string name, int64 version,
int64 sync_ts,
string originator_client_item_id,
string originator_cache_guid) {
return AddUpdateBookmark(TestIdFactory::FromNumber(id),
TestIdFactory::FromNumber(parent_id),
name,
version,
sync_ts,
originator_client_item_id,
originator_cache_guid);
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
int id,
int parent_id,
string name,
int64 version,
int64 sync_ts,
bool is_dir,
int64 position,
const sync_pb::EntitySpecifics& specifics) {
sync_pb::SyncEntity* ent = AddUpdateMeta(
TestIdFactory::FromNumber(id).GetServerId(),
TestIdFactory::FromNumber(parent_id).GetServerId(),
name, version, sync_ts);
ent->set_position_in_parent(position);
ent->mutable_specifics()->CopyFrom(specifics);
ent->set_folder(is_dir);
return ent;
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
int id,
int parent_id,
string name,
int64 version,
int64 sync_ts,
bool is_dir,
int64 position,
const sync_pb::EntitySpecifics& specifics,
string originator_cache_guid,
string originator_client_item_id) {
sync_pb::SyncEntity* ent = AddUpdateSpecifics(
id, parent_id, name, version, sync_ts, is_dir, position, specifics);
ent->set_originator_cache_guid(originator_cache_guid);
ent->set_originator_client_item_id(originator_client_item_id);
return ent;
}
sync_pb::SyncEntity* MockConnectionManager::SetNigori(
int id,
int64 version,
int64 sync_ts,
const sync_pb::EntitySpecifics& specifics) {
sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
ent->set_id_string(TestIdFactory::FromNumber(id).GetServerId());
ent->set_parent_id_string(TestIdFactory::FromNumber(0).GetServerId());
ent->set_server_defined_unique_tag(ModelTypeToRootTag(NIGORI));
ent->set_name("Nigori");
ent->set_non_unique_name("Nigori");
ent->set_version(version);
ent->set_sync_timestamp(sync_ts);
ent->set_mtime(sync_ts);
ent->set_ctime(1);
ent->set_position_in_parent(0);
ent->set_folder(false);
ent->mutable_specifics()->CopyFrom(specifics);
return ent;
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdatePref(string id,
string parent_id,
string client_tag,
int64 version,
int64 sync_ts) {
sync_pb::SyncEntity* ent =
AddUpdateMeta(id, parent_id, " ", version, sync_ts);
ent->set_client_defined_unique_tag(client_tag);
sync_pb::EntitySpecifics specifics;
AddDefaultFieldValue(PREFERENCES, &specifics);
ent->mutable_specifics()->CopyFrom(specifics);
return ent;
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateFull(
string id, string parent_id,
string name, int64 version,
int64 sync_ts, bool is_dir) {
sync_pb::SyncEntity* ent =
AddUpdateMeta(id, parent_id, name, version, sync_ts);
AddDefaultBookmarkData(ent, is_dir);
return ent;
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateMeta(
string id, string parent_id,
string name, int64 version,
int64 sync_ts) {
sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
ent->set_id_string(id);
ent->set_parent_id_string(parent_id);
ent->set_non_unique_name(name);
ent->set_name(name);
ent->set_version(version);
ent->set_sync_timestamp(sync_ts);
ent->set_mtime(sync_ts);
ent->set_ctime(1);
ent->set_position_in_parent(GeneratePositionInParent());
// This isn't perfect, but it works well enough. This is an update, which
// means the ID is a server ID, which means it never changes. By making
// kCacheGuid also never change, we guarantee that the same item always has
// the same originator_cache_guid and originator_client_item_id.
//
// Unfortunately, neither this class nor the tests that use it explicitly
// track sync entitites, so supporting proper cache guids and client item IDs
// would require major refactoring. The ID used here ought to be the "c-"
// style ID that was sent up on the commit.
ent->set_originator_cache_guid(kCacheGuid);
ent->set_originator_client_item_id(id);
return ent;
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
string id,
string parent_id,
string name,
int64 version,
int64 sync_ts,
std::string originator_cache_guid,
std::string originator_client_item_id) {
sync_pb::SyncEntity* ret =
AddUpdateFull(id, parent_id, name, version, sync_ts, true);
ret->set_originator_cache_guid(originator_cache_guid);
ret->set_originator_client_item_id(originator_client_item_id);
return ret;
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
string id,
string parent_id,
string name, int64 version,
int64 sync_ts,
string originator_cache_guid,
string originator_client_item_id) {
sync_pb::SyncEntity* ret =
AddUpdateFull(id, parent_id, name, version, sync_ts, false);
ret->set_originator_cache_guid(originator_cache_guid);
ret->set_originator_client_item_id(originator_client_item_id);
return ret;
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
EXPECT_EQ(1, last_sent_commit().entries_size());
EXPECT_EQ(1, last_commit_response().entryresponse_size());
EXPECT_EQ(CommitResponse::SUCCESS,
last_commit_response().entryresponse(0).response_type());
if (last_sent_commit().entries(0).deleted()) {
ModelType type = GetModelType(last_sent_commit().entries(0));
AddUpdateTombstone(syncable::Id::CreateFromServerId(
last_sent_commit().entries(0).id_string()), type);
} else {
sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
ent->CopyFrom(last_sent_commit().entries(0));
ent->clear_insert_after_item_id();
ent->clear_old_parent_id();
ent->set_position_in_parent(
last_commit_response().entryresponse(0).position_in_parent());
ent->set_version(
last_commit_response().entryresponse(0).version());
ent->set_id_string(
last_commit_response().entryresponse(0).id_string());
// This is the same hack as in AddUpdateMeta. See the comment in that
// function for more information.
ent->set_originator_cache_guid(kCacheGuid);
ent->set_originator_client_item_id(
last_commit_response().entryresponse(0).id_string());
if (last_sent_commit().entries(0).has_unique_position()) {
ent->mutable_unique_position()->CopyFrom(
last_sent_commit().entries(0).unique_position());
}
// Tests don't currently care about the following:
// parent_id_string, name, non_unique_name.
}
return GetMutableLastUpdate();
}
void MockConnectionManager::AddUpdateTombstone(
const syncable::Id& id,
ModelType type) {
// Tombstones have only the ID set and dummy values for the required fields.
sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
ent->set_id_string(id.GetServerId());
ent->set_version(0);
ent->set_name("");
ent->set_deleted(true);
// Make sure we can still extract the ModelType from this tombstone.
AddDefaultFieldValue(type, ent->mutable_specifics());
}
void MockConnectionManager::SetLastUpdateDeleted() {
// Tombstones have only the ID set. Wipe anything else.
string id_string = GetMutableLastUpdate()->id_string();
ModelType type = GetModelType(*GetMutableLastUpdate());
GetUpdateResponse()->mutable_entries()->RemoveLast();
AddUpdateTombstone(syncable::Id::CreateFromServerId(id_string), type);
}
void MockConnectionManager::SetLastUpdateOriginatorFields(
const string& client_id,
const string& entry_id) {
GetMutableLastUpdate()->set_originator_cache_guid(client_id);
GetMutableLastUpdate()->set_originator_client_item_id(entry_id);
}
void MockConnectionManager::SetLastUpdateServerTag(const string& tag) {
GetMutableLastUpdate()->set_server_defined_unique_tag(tag);
}
void MockConnectionManager::SetLastUpdateClientTag(const string& tag) {
GetMutableLastUpdate()->set_client_defined_unique_tag(tag);
}
void MockConnectionManager::SetLastUpdatePosition(int64 server_position) {
GetMutableLastUpdate()->set_position_in_parent(server_position);
}
void MockConnectionManager::SetNewTimestamp(int ts) {
next_token_ = base::StringPrintf("mock connection ts = %d", ts);
ApplyToken();
}
void MockConnectionManager::ApplyToken() {
if (!update_queue_.empty()) {
GetUpdateResponse()->clear_new_progress_marker();
sync_pb::DataTypeProgressMarker* new_marker =
GetUpdateResponse()->add_new_progress_marker();
new_marker->set_data_type_id(-1); // Invalid -- clients shouldn't see.
new_marker->set_token(next_token_);
}
}
void MockConnectionManager::SetChangesRemaining(int64 timestamp) {
GetUpdateResponse()->set_changes_remaining(timestamp);
}
void MockConnectionManager::ProcessGetUpdates(
sync_pb::ClientToServerMessage* csm,
sync_pb::ClientToServerResponse* response) {
CHECK(csm->has_get_updates());
ASSERT_EQ(csm->message_contents(), ClientToServerMessage::GET_UPDATES);
const GetUpdatesMessage& gu = csm->get_updates();
num_get_updates_requests_++;
EXPECT_FALSE(gu.has_from_timestamp());
EXPECT_FALSE(gu.has_requested_types());
if (fail_non_periodic_get_updates_) {
EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::PERIODIC,
gu.caller_info().source());
}
// Verify that the items we're about to send back to the client are of
// the types requested by the client. If this fails, it probably indicates
// a test bug.
EXPECT_TRUE(gu.fetch_folders());
EXPECT_FALSE(gu.has_requested_types());
if (update_queue_.empty()) {
GetUpdateResponse();
}
sync_pb::GetUpdatesResponse* updates = &update_queue_.front();
for (int i = 0; i < updates->entries_size(); ++i) {
if (!updates->entries(i).deleted()) {
ModelType entry_type = GetModelType(updates->entries(i));
EXPECT_TRUE(
IsModelTypePresentInSpecifics(gu.from_progress_marker(), entry_type))
<< "Syncer did not request updates being provided by the test.";
}
}
response->mutable_get_updates()->CopyFrom(*updates);
// Set appropriate progress markers, overriding the value squirreled
// away by ApplyToken().
std::string token = response->get_updates().new_progress_marker(0).token();
response->mutable_get_updates()->clear_new_progress_marker();
for (int i = 0; i < gu.from_progress_marker_size(); ++i) {
sync_pb::DataTypeProgressMarker* new_marker =
response->mutable_get_updates()->add_new_progress_marker();
new_marker->set_data_type_id(gu.from_progress_marker(i).data_type_id());
new_marker->set_token(token);
}
// Fill the keystore key if requested.
if (gu.need_encryption_key())
response->mutable_get_updates()->add_encryption_keys(keystore_key_);
update_queue_.pop_front();
if (gu_client_command_) {
response->mutable_client_command()->CopyFrom(*gu_client_command_.get());
}
}
void MockConnectionManager::SetKeystoreKey(const std::string& key) {
// Note: this is not a thread-safe set, ok for now. NOT ok if tests
// run the syncer on the background thread while this method is called.
keystore_key_ = key;
}
bool MockConnectionManager::ShouldConflictThisCommit() {
bool conflict = false;
if (conflict_all_commits_) {
conflict = true;
} else if (conflict_n_commits_ > 0) {
conflict = true;
--conflict_n_commits_;
}
return conflict;
}
bool MockConnectionManager::ShouldTransientErrorThisId(syncable::Id id) {
return find(transient_error_ids_.begin(), transient_error_ids_.end(), id)
!= transient_error_ids_.end();
}
void MockConnectionManager::ProcessCommit(
sync_pb::ClientToServerMessage* csm,
sync_pb::ClientToServerResponse* response_buffer) {
CHECK(csm->has_commit());
ASSERT_EQ(csm->message_contents(), ClientToServerMessage::COMMIT);
map <string, string> changed_ids;
const CommitMessage& commit_message = csm->commit();
CommitResponse* commit_response = response_buffer->mutable_commit();
commit_messages_.push_back(new CommitMessage);
commit_messages_.back()->CopyFrom(commit_message);
map<string, sync_pb::CommitResponse_EntryResponse*> response_map;
for (int i = 0; i < commit_message.entries_size() ; i++) {
const sync_pb::SyncEntity& entry = commit_message.entries(i);
CHECK(entry.has_id_string());
string id_string = entry.id_string();
ASSERT_LT(entry.name().length(), 256ul) << " name probably too long. True "
"server name checking not implemented";
syncable::Id id;
if (entry.version() == 0) {
// Relies on our new item string id format. (string representation of a
// negative number).
id = syncable::Id::CreateFromClientString(id_string);
} else {
id = syncable::Id::CreateFromServerId(id_string);
}
committed_ids_.push_back(id);
if (response_map.end() == response_map.find(id_string))
response_map[id_string] = commit_response->add_entryresponse();
sync_pb::CommitResponse_EntryResponse* er = response_map[id_string];
if (ShouldConflictThisCommit()) {
er->set_response_type(CommitResponse::CONFLICT);
continue;
}
if (ShouldTransientErrorThisId(id)) {
er->set_response_type(CommitResponse::TRANSIENT_ERROR);
continue;
}
er->set_response_type(CommitResponse::SUCCESS);
er->set_version(entry.version() + 1);
if (!commit_time_rename_prepended_string_.empty()) {
// Commit time rename sent down from the server.
er->set_name(commit_time_rename_prepended_string_ + entry.name());
}
string parent_id_string = entry.parent_id_string();
// Remap id's we've already assigned.
if (changed_ids.end() != changed_ids.find(parent_id_string)) {
parent_id_string = changed_ids[parent_id_string];
er->set_parent_id_string(parent_id_string);
}
if (entry.has_version() && 0 != entry.version()) {
er->set_id_string(id_string); // Allows verification.
} else {
string new_id = base::StringPrintf("mock_server:%d", next_new_id_++);
changed_ids[id_string] = new_id;
er->set_id_string(new_id);
}
}
commit_responses_.push_back(new CommitResponse(*commit_response));
if (commit_client_command_) {
response_buffer->mutable_client_command()->CopyFrom(
*commit_client_command_.get());
}
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
syncable::Id id,
syncable::Id parent_id,
string name,
int64 version,
int64 sync_ts,
string originator_cache_guid,
string originator_client_item_id) {
return AddUpdateDirectory(id.GetServerId(), parent_id.GetServerId(),
name, version, sync_ts, originator_cache_guid,
originator_client_item_id);
}
sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
syncable::Id id,
syncable::Id parent_id,
string name,
int64 version,
int64 sync_ts,
string originator_cache_guid,
string originator_client_item_id) {
return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(),
name, version, sync_ts, originator_cache_guid,
originator_client_item_id);
}
sync_pb::SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
sync_pb::GetUpdatesResponse* updates = GetUpdateResponse();
EXPECT_GT(updates->entries_size(), 0);
return updates->mutable_entries()->Mutable(updates->entries_size() - 1);
}
void MockConnectionManager::NextUpdateBatch() {
update_queue_.push_back(sync_pb::GetUpdatesResponse::default_instance());
SetChangesRemaining(0);
ApplyToken();
}
const CommitMessage& MockConnectionManager::last_sent_commit() const {
EXPECT_TRUE(!commit_messages_.empty());
return *commit_messages_.back();
}
const CommitResponse& MockConnectionManager::last_commit_response() const {
EXPECT_TRUE(!commit_responses_.empty());
return *commit_responses_.back();
}
const sync_pb::ClientToServerMessage&
MockConnectionManager::last_request() const {
EXPECT_TRUE(!requests_.empty());
return requests_.back();
}
const std::vector<sync_pb::ClientToServerMessage>&
MockConnectionManager::requests() const {
return requests_;
}
bool MockConnectionManager::IsModelTypePresentInSpecifics(
const google::protobuf::RepeatedPtrField<
sync_pb::DataTypeProgressMarker>& filter,
ModelType value) {
int data_type_id = GetSpecificsFieldNumberFromModelType(value);
for (int i = 0; i < filter.size(); ++i) {
if (filter.Get(i).data_type_id() == data_type_id) {
return true;
}
}
return false;
}
sync_pb::DataTypeProgressMarker const*
MockConnectionManager::GetProgressMarkerForType(
const google::protobuf::RepeatedPtrField<
sync_pb::DataTypeProgressMarker>& filter,
ModelType value) {
int data_type_id = GetSpecificsFieldNumberFromModelType(value);
for (int i = 0; i < filter.size(); ++i) {
if (filter.Get(i).data_type_id() == data_type_id) {
return &(filter.Get(i));
}
}
return NULL;
}
void MockConnectionManager::SetServerReachable() {
server_reachable_ = true;
}
void MockConnectionManager::SetServerNotReachable() {
server_reachable_ = false;
}
void MockConnectionManager::UpdateConnectionStatus() {
if (!server_reachable_) {
server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
} else {
server_status_ = HttpResponse::SERVER_CONNECTION_OK;
}
}
void MockConnectionManager::SetServerStatus(
HttpResponse::ServerConnectionCode server_status) {
server_status_ = server_status;
}
} // namespace syncer
| bsd-3-clause |
tianzhihen/phantomjs | src/modules/cookiejar.js | 2651 | /*jslint sloppy: true, nomen: true */
/*global exports:true */
/*
This file is part of the PhantomJS project from Ofi Labs.
Copyright (C) 2013 Joseph Rollinson, [email protected]
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the <organization> nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* Takes in a QtCookieJar and decorates it with useful functions. */
function decorateCookieJar(jar) {
/* Allows one to add a cookie to the cookie jar from inside JavaScript */
jar.addCookie = function(cookie) {
jar.addCookieFromMap(cookie);
};
/* Getting and Setting jar.cookies gets and sets all the cookies in the
* cookie jar.
*/
jar.__defineGetter__('cookies', function() {
return this.cookiesToMap();
});
jar.__defineSetter__('cookies', function(cookies) {
this.addCookiesFromMap(cookies);
});
return jar;
}
/* Creates and decorates a new cookie jar.
* path is the file path where Phantomjs will store the cookie jar persistently.
* path is not mandatory.
*/
exports.create = function (path) {
if (arguments.length < 1) {
path = "";
}
return decorateCookieJar(phantom.createCookieJar(path));
};
/* Exports the decorateCookieJar function */
exports.decorate = decorateCookieJar;
| bsd-3-clause |
endlessm/chromium-browser | third_party/webgl/src/sdk/tests/conformance2/textures/canvas/tex-3d-rgba8-rgba-unsigned_byte.html | 943 | <!--
Copyright (c) 2019 The Khronos Group Inc.
Use of this source code is governed by an MIT-style license that can be
found in the LICENSE.txt file.
-->
<!--
This file is auto-generated from py/tex_image_test_generator.py
DO NOT EDIT!
-->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<link rel="stylesheet" href="../../../resources/js-test-style.css"/>
<script src="../../../js/js-test-pre.js"></script>
<script src="../../../js/webgl-test-utils.js"></script>
<script src="../../../js/tests/tex-image-and-sub-image-utils.js"></script>
<script src="../../../js/tests/tex-image-and-sub-image-3d-with-canvas.js"></script>
</head>
<body>
<canvas id="example" width="32" height="32"></canvas>
<div id="description"></div>
<div id="console"></div>
<script>
"use strict";
function testPrologue(gl) {
return true;
}
generateTest("RGBA8", "RGBA", "UNSIGNED_BYTE", testPrologue, "../../../resources/", 2)();
</script>
</body>
</html>
| bsd-3-clause |
ric2b/Vivaldi-browser | chromium/chrome/browser/ui/passwords/bubble_controllers/move_to_account_store_bubble_controller.cc | 4892 | // Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/passwords/bubble_controllers/move_to_account_store_bubble_controller.h"
#include "chrome/browser/favicon/favicon_service_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_avatar_icon_util.h"
#include "chrome/browser/signin/identity_manager_factory.h"
#include "chrome/browser/sync/sync_service_factory.h"
#include "chrome/browser/ui/passwords/passwords_model_delegate.h"
#include "chrome/grit/generated_resources.h"
#include "components/favicon/core/favicon_util.h"
#include "components/password_manager/core/browser/password_feature_manager.h"
#include "components/password_manager/core/browser/password_manager_features_util.h"
#include "components/password_manager/core/common/password_manager_ui.h"
#include "components/signin/public/base/consent_level.h"
#include "components/signin/public/identity_manager/identity_manager.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/web_contents.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/resource/resource_bundle.h"
namespace metrics_util = password_manager::metrics_util;
MoveToAccountStoreBubbleController::MoveToAccountStoreBubbleController(
base::WeakPtr<PasswordsModelDelegate> delegate)
: PasswordBubbleControllerBase(
std::move(delegate),
password_manager::metrics_util::AUTOMATIC_MOVE_TO_ACCOUNT_STORE) {}
MoveToAccountStoreBubbleController::~MoveToAccountStoreBubbleController() {
// Make sure the interactions are reported even if Views didn't notify the
// controller about the bubble being closed.
if (!interaction_reported_)
OnBubbleClosing();
}
void MoveToAccountStoreBubbleController::RequestFavicon(
base::OnceCallback<void(const gfx::Image&)> favicon_ready_callback) {
favicon::FaviconService* favicon_service =
FaviconServiceFactory::GetForProfile(GetProfile(),
ServiceAccessType::EXPLICIT_ACCESS);
favicon::GetFaviconImageForPageURL(
favicon_service, delegate_->GetPendingPassword().url,
favicon_base::IconType::kFavicon,
base::BindOnce(&MoveToAccountStoreBubbleController::OnFaviconReady,
base::Unretained(this), std::move(favicon_ready_callback)),
&favicon_tracker_);
}
void MoveToAccountStoreBubbleController::OnFaviconReady(
base::OnceCallback<void(const gfx::Image&)> favicon_ready_callback,
const favicon_base::FaviconImageResult& result) {
std::move(favicon_ready_callback).Run(result.image);
}
std::u16string MoveToAccountStoreBubbleController::GetTitle() const {
return l10n_util::GetStringUTF16(IDS_PASSWORD_MANAGER_MOVE_TITLE);
}
void MoveToAccountStoreBubbleController::AcceptMove() {
dismissal_reason_ = metrics_util::CLICKED_ACCEPT;
if (delegate_->GetPasswordFeatureManager()->IsOptedInForAccountStorage()) {
// User has already opted in to the account store. Move without reauth.
return delegate_->MovePasswordToAccountStore();
}
// Otherwise, we should invoke the reauth flow before saving.
return delegate_->AuthenticateUserForAccountStoreOptInAndMovePassword();
}
void MoveToAccountStoreBubbleController::RejectMove() {
dismissal_reason_ = metrics_util::CLICKED_NEVER;
return delegate_->BlockMovingPasswordToAccountStore();
}
gfx::Image MoveToAccountStoreBubbleController::GetProfileIcon(int size) {
if (!GetProfile())
return gfx::Image();
signin::IdentityManager* identity_manager =
IdentityManagerFactory::GetForProfile(GetProfile());
if (!identity_manager)
return gfx::Image();
AccountInfo primary_account_info = identity_manager->FindExtendedAccountInfo(
identity_manager->GetPrimaryAccountInfo(signin::ConsentLevel::kSignin));
DCHECK(!primary_account_info.IsEmpty());
gfx::Image account_icon = primary_account_info.account_image;
if (account_icon.IsEmpty()) {
account_icon = ui::ResourceBundle::GetSharedInstance().GetImageNamed(
profiles::GetPlaceholderAvatarIconResourceID());
}
return profiles::GetSizedAvatarIcon(account_icon,
/*is_rectangle=*/true, /*width=*/size,
/*height=*/size, profiles::SHAPE_CIRCLE);
}
void MoveToAccountStoreBubbleController::ReportInteractions() {
Profile* profile = GetProfile();
if (!profile)
return;
metrics_util::LogMoveUIDismissalReason(
dismissal_reason_,
password_manager::features_util::ComputePasswordAccountStorageUserState(
profile->GetPrefs(), SyncServiceFactory::GetForProfile(profile)));
// TODO(crbug.com/1063852): Consider recording UKM here, via:
// metrics_recorder_->RecordUIDismissalReason(dismissal_reason_)
}
| bsd-3-clause |
ric2b/Vivaldi-browser | chromium/chrome/test/chromedriver/commands.h | 2494 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_TEST_CHROMEDRIVER_COMMANDS_H_
#define CHROME_TEST_CHROMEDRIVER_COMMANDS_H_
#include <memory>
#include <string>
#include "base/callback_forward.h"
#include "base/memory/ref_counted.h"
#include "chrome/test/chromedriver/command.h"
#include "chrome/test/chromedriver/session_thread_map.h"
namespace base {
class DictionaryValue;
class Value;
}
struct Session;
class Status;
// Gets status/info about ChromeDriver.
void ExecuteGetStatus(
const base::DictionaryValue& params,
const std::string& session_id,
const CommandCallback& callback);
// Creates a new session.
void ExecuteCreateSession(SessionThreadMap* session_thread_map,
const Command& init_session_cmd,
const base::DictionaryValue& params,
const std::string& host,
const CommandCallback& callback);
// Gets all sessions
void ExecuteGetSessions(
const Command& session_capabilities_command,
SessionThreadMap* session_thread_map,
const base::DictionaryValue& params,
const std::string& session_id,
const CommandCallback& callback);
// Quits all sessions.
void ExecuteQuitAll(
const Command& quit_command,
SessionThreadMap* session_thread_map,
const base::DictionaryValue& params,
const std::string& session_id,
const CommandCallback& callback);
typedef base::RepeatingCallback<Status(Session* session,
const base::DictionaryValue&,
std::unique_ptr<base::Value>*)>
SessionCommand;
// Executes a given session command, after acquiring access to the appropriate
// session.
void ExecuteSessionCommand(SessionThreadMap* session_thread_map,
const char* command_name,
const SessionCommand& command,
bool w3c_standard_command,
bool return_ok_without_session,
const base::DictionaryValue& params,
const std::string& session_id,
const CommandCallback& callback);
namespace internal {
void CreateSessionOnSessionThreadForTesting(const std::string& id);
} // namespace internal
#endif // CHROME_TEST_CHROMEDRIVER_COMMANDS_H_
| bsd-3-clause |
ric2b/Vivaldi-browser | chromium/chrome/test/mini_installer/variable_expander.py | 17079 | # Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import base64
import hashlib
import os
import string
import win32api
import win32file
import win32com.client
from win32com.shell import shell, shellcon
import win32security
def _GetFileVersion(file_path):
"""Returns the file version of the given file."""
return win32com.client.Dispatch(
'Scripting.FileSystemObject').GetFileVersion(file_path)
def _GetFileBitness(file_path):
"""Returns the bitness of the given file."""
if win32file.GetBinaryType(file_path) == win32file.SCS_32BIT_BINARY:
return '32'
return '64'
def _GetProductName(file_path):
"""Returns the product name of the given file.
Args:
file_path: The absolute or relative path to the file.
Returns:
A string representing the product name of the file, or None if the
product name was not found.
"""
language_and_codepage_pairs = win32api.GetFileVersionInfo(
file_path, '\\VarFileInfo\\Translation')
if not language_and_codepage_pairs:
return None
product_name_entry = ('\\StringFileInfo\\%04x%04x\\ProductName' %
language_and_codepage_pairs[0])
return win32api.GetFileVersionInfo(file_path, product_name_entry)
def _GetUserSpecificRegistrySuffix():
"""Returns '.' + the unpadded Base32 encoding of the MD5 of the user's SID.
The result must match the output from the method
UserSpecificRegistrySuffix::GetSuffix() in
chrome/installer/util/shell_util.cc. It will always be 27 characters long.
"""
token_handle = win32security.OpenProcessToken(win32api.GetCurrentProcess(),
win32security.TOKEN_QUERY)
user_sid, _ = win32security.GetTokenInformation(token_handle,
win32security.TokenUser)
user_sid_string = win32security.ConvertSidToStringSid(user_sid)
md5_digest = hashlib.md5(user_sid_string).digest()
return '.' + base64.b32encode(md5_digest).rstrip('=')
class VariableExpander:
"""Expands variables in strings."""
def __init__(self, mini_installer_path,
previous_version_mini_installer_path, chromedriver_path,
quiet, output_dir):
"""Constructor.
The constructor initializes a variable dictionary that maps variables to
their values. These are the only acceptable variables:
* $BRAND: the browser brand (e.g., "Google Chrome" or "Chromium").
* $CHROME_DIR: the directory of Chrome (or Chromium) from the base
installation directory.
* $CHROME_HTML_PROG_ID: 'ChromeHTML' (or 'ChromiumHTM').
* $CHROME_LONG_NAME: 'Google Chrome' (or 'Chromium').
* $CHROME_LONG_NAME_BETA: 'Google Chrome Beta' if $BRAND is 'Google
* Chrome'.
* $CHROME_LONG_NAME_DEV: 'Google Chrome Dev' if $BRAND is 'Google
* Chrome'.
* $CHROME_LONG_NAME_SXS: 'Google Chrome SxS' if $BRAND is 'Google
* Chrome'.
* $CHROME_SHORT_NAME: 'Chrome' (or 'Chromium').
* $CHROME_SHORT_NAME_BETA: 'ChromeBeta' if $BRAND is 'Google Chrome'.
* $CHROME_SHORT_NAME_DEV: 'ChromeDev' if $BRAND is 'Google Chrome'.
* $CHROME_SHORT_NAME_SXS: 'ChromeCanary' if $BRAND is 'Google Chrome'.
* $CHROME_UPDATE_REGISTRY_SUBKEY: the registry key, excluding the root
key, of Chrome for Google Update.
* $CHROME_UPDATE_REGISTRY_SUBKEY_DEV: the registry key, excluding the
root key, of Chrome Dev for Google Update.
* $CHROME_UPDATE_REGISTRY_SUBKEY_BETA: the registry key, excluding the
root key, of Chrome Beta for Google Update.
* $CHROME_UPDATE_REGISTRY_SUBKEY_SXS: the registry key, excluding the
root key, of Chrome SxS for Google Update.
* $CHROMEDRIVER_PATH: Path to chromedriver.
* $QUIET: Supress output.
* $OUTPUT_DIR: "--output-dir=DIR" or an empty string.
* $LAUNCHER_UPDATE_REGISTRY_SUBKEY: the registry key, excluding the root
key, of the app launcher for Google Update if $BRAND is 'Google
* Chrome'.
* $LOCAL_APPDATA: the unquoted path to the Local Application Data
folder.
* $LOG_FILE: "--log-file=FILE" or an empty string.
* $MINI_INSTALLER: the unquoted path to the mini_installer.
* $MINI_INSTALLER_BITNESS: the bitness of the mini_installer.
* $MINI_INSTALLER_FILE_VERSION: the file version of $MINI_INSTALLER.
* $PREVIOUS_VERSION_MINI_INSTALLER: the unquoted path to a
mini_installer whose version is lower than $MINI_INSTALLER.
* $PREVIOUS_VERSION_MINI_INSTALLER_FILE_VERSION: the file version of
$PREVIOUS_VERSION_MINI_INSTALLER.
* $PROGRAM_FILES: the unquoted path to the Program Files folder.
* $USER_SPECIFIC_REGISTRY_SUFFIX: the output from the function
_GetUserSpecificRegistrySuffix().
* $VERSION_[XP/SERVER_2003/VISTA/WIN7/WIN8/WIN8_1/WIN10]: a 2-tuple
representing the version of the corresponding OS.
* $WINDOWS_VERSION: a 2-tuple representing the current Windows version.
* $CHROME_TOAST_ACTIVATOR_CLSID: NotificationActivator's CLSID for
Chrome.
* $CHROME_TOAST_ACTIVATOR_CLSID_BETA: NotificationActivator's CLSID for
Chrome Beta.
* $CHROME_TOAST_ACTIVATOR_CLSID_DEV: NotificationActivator's CLSID for
Chrome Dev.
* $CHROME_TOAST_ACTIVATOR_CLSID_SXS: NotificationActivator's CLSID for
Chrome SxS.
* $CHROME_ELEVATOR_CLSID: Elevator Service CLSID for Chrome.
* $CHROME_ELEVATOR_CLSID_BETA: Elevator Service CLSID for Chrome Beta.
* $CHROME_ELEVATOR_CLSID_DEV: Elevator Service CLSID for Chrome Dev.
* $CHROME_ELEVATOR_CLSID_SXS: Elevator Service CLSID for Chrome SxS.
* $CHROME_ELEVATOR_IID: IElevator IID for Chrome.
* $CHROME_ELEVATOR_IID_BETA: IElevator IID for Chrome Beta.
* $CHROME_ELEVATOR_IID_DEV: IElevator IID for Chrome Dev.
* $CHROME_ELEVATOR_IID_SXS: IElevator IID for Chrome SxS.
* $CHROME_ELEVATION_SERVICE_NAME: Elevation Service Name for Chrome.
* $CHROME_ELEVATION_SERVICE_NAME_BETA: Elevation Service Name for Chrome
Beta.
* $CHROME_ELEVATION_SERVICE_NAME_DEV: Elevation Service Name for Chrome
Dev.
* $CHROME_ELEVATION_SERVICE_NAME_SXS: Elevation Service Name for Chrome
SxS.
* $CHROME_ELEVATION_SERVICE_DISPLAY_NAME: Elevation Service Display Name
for Chrome.
* $CHROME_ELEVATION_SERVICE_DISPLAY_NAME_BETA: Elevation Service Display
Name for Chrome Beta.
* $CHROME_ELEVATION_SERVICE_DISPLAY_NAME_DEV: Elevation Service Display
Name for Chrome Dev.
* $CHROME_ELEVATION_SERVICE_DISPLAY_NAME_SXS: Elevation Service Display
Name for Chrome SxS.
* $LAST_INSTALLER_BREAKING_VERSION: The last installer version that had
breaking changes.
Args:
mini_installer_path: The path to a mini_installer.
previous_version_mini_installer_path: The path to a mini_installer
whose version is lower than |mini_installer_path|.
"""
mini_installer_abspath = os.path.abspath(mini_installer_path)
previous_version_mini_installer_abspath = os.path.abspath(
previous_version_mini_installer_path)
windows_major_ver, windows_minor_ver, _, _, _ = win32api.GetVersionEx()
self._variable_mapping = {
'CHROMEDRIVER_PATH':
chromedriver_path,
'QUIET':
'-q' if quiet else '',
'OUTPUT_DIR':
'"--output-dir=%s"' % output_dir if output_dir else '',
'LAST_INSTALLER_BREAKING_VERSION':
'85.0.4169.0',
'LOCAL_APPDATA':
shell.SHGetFolderPath(0, shellcon.CSIDL_LOCAL_APPDATA, None, 0),
'LOG_FILE':
'',
'MINI_INSTALLER':
mini_installer_abspath,
'MINI_INSTALLER_FILE_VERSION':
_GetFileVersion(mini_installer_abspath),
'MINI_INSTALLER_BITNESS':
_GetFileBitness(mini_installer_abspath),
'PREVIOUS_VERSION_MINI_INSTALLER':
previous_version_mini_installer_abspath,
'PREVIOUS_VERSION_MINI_INSTALLER_FILE_VERSION':
_GetFileVersion(previous_version_mini_installer_abspath),
'PROGRAM_FILES':
shell.SHGetFolderPath(
0, shellcon.CSIDL_PROGRAM_FILES
if _GetFileBitness(mini_installer_abspath) == '64' else
shellcon.CSIDL_PROGRAM_FILESX86, None, 0),
'USER_SPECIFIC_REGISTRY_SUFFIX':
_GetUserSpecificRegistrySuffix(),
'VERSION_SERVER_2003':
'(5, 2)',
'VERSION_VISTA':
'(6, 0)',
'VERSION_WIN10':
'(10, 0)',
'VERSION_WIN7':
'(6, 1)',
'VERSION_WIN8':
'(6, 2)',
'VERSION_WIN8_1':
'(6, 3)',
'VERSION_XP':
'(5, 1)',
'WINDOWS_VERSION':
'(%s, %s)' % (windows_major_ver, windows_minor_ver)
}
mini_installer_product_name = _GetProductName(mini_installer_abspath)
if mini_installer_product_name == 'Google Chrome Installer':
self._variable_mapping.update({
'BRAND':
'Google Chrome',
'BINARIES_UPDATE_REGISTRY_SUBKEY':
('Software\\Google\\Update\\Clients\\'
'{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}'),
'CHROME_DIR':
'Google\\Chrome',
'CHROME_HTML_PROG_ID':
'ChromeHTML',
'CHROME_HTML_PROG_ID_BETA':
'ChromeBHTML',
'CHROME_HTML_PROG_ID_DEV':
'ChromeDHTML',
'CHROME_HTML_PROG_ID_SXS':
'ChromeSSHTM',
'CHROME_LONG_NAME':
'Google Chrome',
'CHROME_SHORT_NAME':
'Chrome',
'CHROME_UPDATE_REGISTRY_SUBKEY':
('Software\\Google\\Update\\Clients\\'
'{8A69D345-D564-463c-AFF1-A69D9E530F96}'),
'CHROME_CLIENT_STATE_KEY_BETA':
('Software\\Google\\Update\\ClientState\\'
'{8237E44A-0054-442C-B6B6-EA0509993955}'),
'CHROME_CLIENT_STATE_KEY_DEV':
('Software\\Google\\Update\\ClientState\\'
'{401C381F-E0DE-4B85-8BD8-3F3F14FBDA57}'),
'CHROME_CLIENT_STATE_KEY_SXS':
('Software\\Google\\Update\\ClientState\\'
'{4ea16ac7-fd5a-47c3-875b-dbf4a2008c20}'),
'CHROME_CLIENT_STATE_KEY':
('Software\\Google\\Update\\ClientState\\'
'{8A69D345-D564-463c-AFF1-A69D9E530F96}'),
'CHROME_TOAST_ACTIVATOR_CLSID':
('{A2C6CB58-C076-425C-ACB7-6D19D64428CD}'),
'CHROME_DIR_BETA':
'Google\\Chrome Beta',
'CHROME_DIR_DEV':
'Google\\Chrome Dev',
'CHROME_DIR_SXS':
'Google\\Chrome SxS',
'CHROME_LONG_NAME_BETA':
'Google Chrome Beta',
'CHROME_LONG_NAME_DEV':
'Google Chrome Dev',
'CHROME_LONG_NAME_SXS':
'Google Chrome SxS',
'CHROME_SHORT_NAME_BETA':
'ChromeBeta',
'CHROME_SHORT_NAME_DEV':
'ChromeDev',
'CHROME_SHORT_NAME_SXS':
'ChromeCanary',
'CHROME_UPDATE_REGISTRY_SUBKEY_BETA':
('Software\\Google\\Update\\Clients\\'
'{8237E44A-0054-442C-B6B6-EA0509993955}'),
'CHROME_UPDATE_REGISTRY_SUBKEY_DEV':
('Software\\Google\\Update\\Clients\\'
'{401C381F-E0DE-4B85-8BD8-3F3F14FBDA57}'),
'CHROME_UPDATE_REGISTRY_SUBKEY_SXS':
('Software\\Google\\Update\\Clients\\'
'{4ea16ac7-fd5a-47c3-875b-dbf4a2008c20}'),
'LAUNCHER_UPDATE_REGISTRY_SUBKEY':
('Software\\Google\\Update\\Clients\\'
'{FDA71E6F-AC4C-4a00-8B70-9958A68906BF}'),
'CHROME_TOAST_ACTIVATOR_CLSID_BETA':
('{B89B137F-96AA-4AE2-98C4-6373EAA1EA4D}'),
'CHROME_TOAST_ACTIVATOR_CLSID_DEV':
('{F01C03EB-D431-4C83-8D7A-902771E732FA}'),
'CHROME_TOAST_ACTIVATOR_CLSID_SXS':
('{FA372A6E-149F-4E95-832D-8F698D40AD7F}'),
'CHROME_ELEVATOR_CLSID':
('{708860E0-F641-4611-8895-7D867DD3675B}'),
'CHROME_ELEVATOR_CLSID_BETA':
('{DD2646BA-3707-4BF8-B9A7-038691A68FC2}'),
'CHROME_ELEVATOR_CLSID_DEV':
('{DA7FDCA5-2CAA-4637-AA17-0740584DE7DA}'),
'CHROME_ELEVATOR_CLSID_SXS':
('{704C2872-2049-435E-A469-0A534313C42B}'),
'CHROME_ELEVATOR_IID':
('{463ABECF-410D-407F-8AF5-0DF35A005CC8}'),
'CHROME_ELEVATOR_IID_BETA':
('{A2721D66-376E-4D2F-9F0F-9070E9A42B5F}'),
'CHROME_ELEVATOR_IID_DEV':
('{BB2AA26B-343A-4072-8B6F-80557B8CE571}'),
'CHROME_ELEVATOR_IID_SXS':
('{4F7CE041-28E9-484F-9DD0-61A8CACEFEE4}'),
'CHROME_ELEVATION_SERVICE_NAME':
('GoogleChromeElevationService'),
'CHROME_ELEVATION_SERVICE_NAME_BETA':
('GoogleChromeBetaElevationService'),
'CHROME_ELEVATION_SERVICE_NAME_DEV':
('GoogleChromeDevElevationService'),
'CHROME_ELEVATION_SERVICE_NAME_SXS':
('GoogleChromeCanaryElevationService'),
'CHROME_ELEVATION_SERVICE_DISPLAY_NAME':
('Google Chrome Elevation Service ' +
'(GoogleChromeElevationService)'),
'CHROME_ELEVATION_SERVICE_DISPLAY_NAME_BETA':
('Google Chrome Beta Elevation Service'
' (GoogleChromeBetaElevationService)'),
'CHROME_ELEVATION_SERVICE_DISPLAY_NAME_DEV':
('Google Chrome Dev Elevation Service'
' (GoogleChromeDevElevationService)'),
'CHROME_ELEVATION_SERVICE_DISPLAY_NAME_SXS':
('Google Chrome Canary Elevation Service'),
})
elif mini_installer_product_name == 'Chromium Installer':
self._variable_mapping.update({
'BRAND':
'Chromium',
'BINARIES_UPDATE_REGISTRY_SUBKEY':
'Software\\Chromium Binaries',
'CHROME_DIR':
'Chromium',
'CHROME_HTML_PROG_ID':
'ChromiumHTM',
'CHROME_LONG_NAME':
'Chromium',
'CHROME_SHORT_NAME':
'Chromium',
'CHROME_UPDATE_REGISTRY_SUBKEY':
'Software\\Chromium',
'CHROME_CLIENT_STATE_KEY':
'Software\\Chromium',
'CHROME_TOAST_ACTIVATOR_CLSID':
('{635EFA6F-08D6-4EC9-BD14-8A0FDE975159}'),
'CHROME_ELEVATOR_CLSID':
('{D133B120-6DB4-4D6B-8BFE-83BF8CA1B1B0}'),
'CHROME_ELEVATOR_IID':
('{B88C45B9-8825-4629-B83E-77CC67D9CEED}'),
'CHROME_ELEVATION_SERVICE_NAME':
'ChromiumElevationService',
'CHROME_ELEVATION_SERVICE_DISPLAY_NAME':
('Chromium Elevation Service (ChromiumElevationService)'),
})
else:
raise KeyError("Unknown mini_installer product name '%s'" %
mini_installer_product_name)
def SetLogFile(self, log_file):
"""Updates the value for the LOG_FILE variable"""
self._variable_mapping['LOG_FILE'] = ('"--log-file=%s"' %
log_file if log_file else '')
def Expand(self, a_string):
"""Expands variables in the given string.
This method resolves only variables defined in the constructor. It does
not resolve environment variables. Any dollar signs that are not part of
variables must be escaped with $$, otherwise a KeyError or a ValueError
will be raised.
Args:
a_string: A string.
Returns:
A new string created by replacing variables with their values.
"""
return string.Template(a_string).substitute(self._variable_mapping)
| bsd-3-clause |
windtrader/drupalvm-d8 | web/core/lib/Drupal/Core/Render/Element/Button.php | 3071 | <?php
namespace Drupal\Core\Render\Element;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Render\Element;
/**
* Provides an action button form element.
*
* When the button is pressed, the form will be submitted to Drupal, where it is
* validated and rebuilt. The submit handler is not invoked.
*
* Properties:
* - #limit_validation_errors: An array of form element keys that will block
* form submission when validation for these elements or any child elements
* fails. Specify an empty array to suppress all form validation errors.
* - #value: The text to be shown on the button.
*
*
* Usage Example:
* @code
* $form['actions']['preview'] = array(
* '#type' => 'button',
* '#value' => $this->t('Preview'),
* );
* @endcode
*
* @see \Drupal\Core\Render\Element\Submit
*
* @FormElement("button")
*/
class Button extends FormElement {
/**
* {@inheritdoc}
*/
public function getInfo() {
$class = get_class($this);
return array(
'#input' => TRUE,
'#name' => 'op',
'#is_button' => TRUE,
'#executes_submit_callback' => FALSE,
'#limit_validation_errors' => FALSE,
'#process' => array(
array($class, 'processButton'),
array($class, 'processAjaxForm'),
),
'#pre_render' => array(
array($class, 'preRenderButton'),
),
'#theme_wrappers' => array('input__submit'),
);
}
/**
* Processes a form button element.
*/
public static function processButton(&$element, FormStateInterface $form_state, &$complete_form) {
// If this is a button intentionally allowing incomplete form submission
// (e.g., a "Previous" or "Add another item" button), then also skip
// client-side validation.
if (isset($element['#limit_validation_errors']) && $element['#limit_validation_errors'] !== FALSE) {
$element['#attributes']['formnovalidate'] = 'formnovalidate';
}
return $element;
}
/**
* Prepares a #type 'button' render element for input.html.twig.
*
* @param array $element
* An associative array containing the properties of the element.
* Properties used: #attributes, #button_type, #name, #value. The
* #button_type property accepts any value, though core themes have CSS that
* styles the following button_types appropriately: 'primary', 'danger'.
*
* @return array
* The $element with prepared variables ready for input.html.twig.
*/
public static function preRenderButton($element) {
$element['#attributes']['type'] = 'submit';
Element::setAttributes($element, array('id', 'name', 'value'));
$element['#attributes']['class'][] = 'button';
if (!empty($element['#button_type'])) {
$element['#attributes']['class'][] = 'button--' . $element['#button_type'];
}
$element['#attributes']['class'][] = 'js-form-submit';
$element['#attributes']['class'][] = 'form-submit';
if (!empty($element['#attributes']['disabled'])) {
$element['#attributes']['class'][] = 'is-disabled';
}
return $element;
}
}
| gpl-2.0 |
ibc/MediaSoup | worker/deps/openssl/openssl/doc/man3/i2d_CMS_bio_stream.pod | 1218 | =pod
=head1 NAME
i2d_CMS_bio_stream - output CMS_ContentInfo structure in BER format
=head1 SYNOPSIS
#include <openssl/cms.h>
int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *data, int flags);
=head1 DESCRIPTION
i2d_CMS_bio_stream() outputs a CMS_ContentInfo structure in BER format.
It is otherwise identical to the function SMIME_write_CMS().
=head1 NOTES
This function is effectively a version of the i2d_CMS_bio() supporting
streaming.
=head1 BUGS
The prefix "i2d" is arguably wrong because the function outputs BER format.
=head1 RETURN VALUES
i2d_CMS_bio_stream() returns 1 for success or 0 for failure.
=head1 SEE ALSO
L<ERR_get_error(3)>, L<CMS_sign(3)>,
L<CMS_verify(3)>, L<CMS_encrypt(3)>
L<CMS_decrypt(3)>,
L<SMIME_write_CMS(3)>,
L<PEM_write_bio_CMS_stream(3)>
=head1 HISTORY
The i2d_CMS_bio_stream() function was added in OpenSSL 1.0.0.
=head1 COPYRIGHT
Copyright 2008-2016 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the OpenSSL license (the "License"). You may not use
this file except in compliance with the License. You can obtain a copy
in the file LICENSE in the source distribution or at
L<https://www.openssl.org/source/license.html>.
=cut
| isc |
Oussemalaamiri/guidemeAngular | src/node_modules/angular2-google-maps/esm/core/directives/google-map-kml-layer.js | 4685 | import { Directive, EventEmitter } from '@angular/core';
import { KmlLayerManager } from './../services/managers/kml-layer-manager';
var layerId = 0;
export var SebmGoogleMapKmlLayer = (function () {
function SebmGoogleMapKmlLayer(_manager) {
this._manager = _manager;
this._addedToManager = false;
this._id = (layerId++).toString();
this._subscriptions = [];
/**
* If true, the layer receives mouse events. Default value is true.
*/
this.clickable = true;
/**
* By default, the input map is centered and zoomed to the bounding box of the contents of the
* layer.
* If this option is set to true, the viewport is left unchanged, unless the map's center and zoom
* were never set.
*/
this.preserveViewport = false;
/**
* Whether to render the screen overlays. Default true.
*/
this.screenOverlays = true;
/**
* Suppress the rendering of info windows when layer features are clicked.
*/
this.suppressInfoWindows = false;
/**
* The URL of the KML document to display.
*/
this.url = null;
/**
* The z-index of the layer.
*/
this.zIndex = null;
/**
* This event is fired when a feature in the layer is clicked.
*/
this.layerClick = new EventEmitter();
/**
* This event is fired when the KML layers default viewport has changed.
*/
this.defaultViewportChange = new EventEmitter();
/**
* This event is fired when the KML layer has finished loading.
* At this point it is safe to read the status property to determine if the layer loaded
* successfully.
*/
this.statusChange = new EventEmitter();
}
SebmGoogleMapKmlLayer.prototype.ngOnInit = function () {
if (this._addedToManager) {
return;
}
this._manager.addKmlLayer(this);
this._addedToManager = true;
this._addEventListeners();
};
SebmGoogleMapKmlLayer.prototype.ngOnChanges = function (changes) {
if (!this._addedToManager) {
return;
}
this._updatePolygonOptions(changes);
};
SebmGoogleMapKmlLayer.prototype._updatePolygonOptions = function (changes) {
var options = Object.keys(changes)
.filter(function (k) { return SebmGoogleMapKmlLayer._kmlLayerOptions.indexOf(k) !== -1; })
.reduce(function (obj, k) {
obj[k] = changes[k].currentValue;
return obj;
}, {});
if (Object.keys(options).length > 0) {
this._manager.setOptions(this, options);
}
};
SebmGoogleMapKmlLayer.prototype._addEventListeners = function () {
var _this = this;
var listeners = [
{ name: 'click', handler: function (ev) { return _this.layerClick.emit(ev); } },
{ name: 'defaultviewport_changed', handler: function () { return _this.defaultViewportChange.emit(); } },
{ name: 'status_changed', handler: function () { return _this.statusChange.emit(); } },
];
listeners.forEach(function (obj) {
var os = _this._manager.createEventObservable(obj.name, _this).subscribe(obj.handler);
_this._subscriptions.push(os);
});
};
/** @internal */
SebmGoogleMapKmlLayer.prototype.id = function () { return this._id; };
/** @internal */
SebmGoogleMapKmlLayer.prototype.toString = function () { return "SebmGoogleMapKmlLayer-" + this._id.toString(); };
/** @internal */
SebmGoogleMapKmlLayer.prototype.ngOnDestroy = function () {
this._manager.deleteKmlLayer(this);
// unsubscribe all registered observable subscriptions
this._subscriptions.forEach(function (s) { return s.unsubscribe(); });
};
SebmGoogleMapKmlLayer._kmlLayerOptions = ['clickable', 'preserveViewport', 'screenOverlays', 'suppressInfoWindows', 'url', 'zIndex'];
SebmGoogleMapKmlLayer.decorators = [
{ type: Directive, args: [{
selector: 'sebm-google-map-kml-layer',
inputs: ['clickable', 'preserveViewport', 'screenOverlays', 'suppressInfoWindows', 'url', 'zIndex'],
outputs: ['layerClick', 'defaultViewportChange', 'statusChange']
},] },
];
/** @nocollapse */
SebmGoogleMapKmlLayer.ctorParameters = function () { return [
{ type: KmlLayerManager, },
]; };
return SebmGoogleMapKmlLayer;
}());
//# sourceMappingURL=google-map-kml-layer.js.map | mit |
metaminded/cruddler | test/dummy/app/helpers/cats_helper.rb | 22 | module CatsHelper
end
| mit |
derrabus/symfony | src/Symfony/Component/Intl/Resources/data/scripts/pt_PT.php | 493 | <?php
return [
'Names' => [
'Aran' => 'nasta’liq',
'Armn' => 'arménio',
'Beng' => 'bengalês',
'Egyd' => 'egípcio demótico',
'Egyh' => 'egípcio hierático',
'Ethi' => 'etíope',
'Hanb' => 'han com bopomofo',
'Inds' => 'indus',
'Orya' => 'odia',
'Sylo' => 'siloti nagri',
'Tale' => 'tai le',
'Telu' => 'telugu',
'Zsym' => 'símbolos',
'Zxxx' => 'não escrito',
],
];
| mit |
toddeye/home-assistant | tests/components/automation/test_zone.py | 5342 | """
tests.components.automation.test_location
±±±~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tests location automation.
"""
import unittest
from homeassistant.components import automation, zone
from tests.common import get_test_home_assistant
class TestAutomationZone(unittest.TestCase):
""" Test the event automation. """
def setUp(self): # pylint: disable=invalid-name
self.hass = get_test_home_assistant()
zone.setup(self.hass, {
'zone': {
'name': 'test',
'latitude': 32.880837,
'longitude': -117.237561,
'radius': 250,
}
})
self.calls = []
def record_call(service):
self.calls.append(service)
self.hass.services.register('test', 'automation', record_call)
def tearDown(self): # pylint: disable=invalid-name
""" Stop down stuff we started. """
self.hass.stop()
def test_if_fires_on_zone_enter(self):
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.881011,
'longitude': -117.234758
})
self.hass.pool.block_till_done()
self.assertTrue(automation.setup(self.hass, {
automation.DOMAIN: {
'trigger': {
'platform': 'zone',
'entity_id': 'test.entity',
'zone': 'zone.test',
'event': 'enter',
},
'action': {
'service': 'test.automation',
}
}
}))
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.880586,
'longitude': -117.237564
})
self.hass.pool.block_till_done()
self.assertEqual(1, len(self.calls))
def test_if_not_fires_for_enter_on_zone_leave(self):
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.880586,
'longitude': -117.237564
})
self.hass.pool.block_till_done()
self.assertTrue(automation.setup(self.hass, {
automation.DOMAIN: {
'trigger': {
'platform': 'zone',
'entity_id': 'test.entity',
'zone': 'zone.test',
'event': 'enter',
},
'action': {
'service': 'test.automation',
}
}
}))
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.881011,
'longitude': -117.234758
})
self.hass.pool.block_till_done()
self.assertEqual(0, len(self.calls))
def test_if_fires_on_zone_leave(self):
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.880586,
'longitude': -117.237564
})
self.hass.pool.block_till_done()
self.assertTrue(automation.setup(self.hass, {
automation.DOMAIN: {
'trigger': {
'platform': 'zone',
'entity_id': 'test.entity',
'zone': 'zone.test',
'event': 'leave',
},
'action': {
'service': 'test.automation',
}
}
}))
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.881011,
'longitude': -117.234758
})
self.hass.pool.block_till_done()
self.assertEqual(1, len(self.calls))
def test_if_not_fires_for_leave_on_zone_enter(self):
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.881011,
'longitude': -117.234758
})
self.hass.pool.block_till_done()
self.assertTrue(automation.setup(self.hass, {
automation.DOMAIN: {
'trigger': {
'platform': 'zone',
'entity_id': 'test.entity',
'zone': 'zone.test',
'event': 'leave',
},
'action': {
'service': 'test.automation',
}
}
}))
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.880586,
'longitude': -117.237564
})
self.hass.pool.block_till_done()
self.assertEqual(0, len(self.calls))
def test_zone_condition(self):
self.hass.states.set('test.entity', 'hello', {
'latitude': 32.880586,
'longitude': -117.237564
})
self.hass.pool.block_till_done()
self.assertTrue(automation.setup(self.hass, {
automation.DOMAIN: {
'trigger': {
'platform': 'event',
'event_type': 'test_event'
},
'condition': {
'platform': 'zone',
'entity_id': 'test.entity',
'zone': 'zone.test',
},
'action': {
'service': 'test.automation',
}
}
}))
self.hass.bus.fire('test_event')
self.hass.pool.block_till_done()
self.assertEqual(1, len(self.calls))
| mit |
owen-kellie-smith/mediawiki | wiki/extensions/SemanticMediaWiki/includes/queryprinters/EmbeddedResultPrinter.php | 3564 | <?php
namespace SMW;
use SMWQueryResult;
use Title;
/**
* Printer for embedded data.
*
* Embeds in the page output the contents of the pages in the query result set.
* Printouts are ignored: it only matters which pages were returned by the query.
* The optional "titlestyle" formatting parameter can be used to apply a format to
* the headings for the page titles. If "titlestyle" is not specified, a <h1> tag is
* used.
*
* @license GNU GPL v2+
* @since 1.7
*
* @author Fernando Correia
* @author Markus Krötzsch
*/
class EmbeddedResultPrinter extends ResultPrinter {
protected $m_showhead;
protected $m_embedformat;
/**
* @see SMWResultPrinter::handleParameters
*
* @since 1.7
*
* @param array $params
* @param $outputmode
*/
protected function handleParameters( array $params, $outputmode ) {
parent::handleParameters( $params, $outputmode );
$this->m_showhead = !$params['embedonly'];
$this->m_embedformat = $params['embedformat'];
}
public function getName() {
return wfMessage( 'smw_printername_embedded' )->text();
}
protected function getResultText( SMWQueryResult $res, $outputMode ) {
global $wgParser;
// No page should embed itself, find out who we are:
if ( $wgParser->getTitle() instanceof Title ) {
$title = $wgParser->getTitle()->getPrefixedText();
} else { // this is likely to be in vain -- this case is typical if we run on special pages
global $wgTitle;
$title = $wgTitle->getPrefixedText();
}
// print header
$result = '';
$footer = '';
$embstart = '';
$embend = '';
$headstart = '';
$headend = '';
$this->hasTemplates = true;
switch ( $this->m_embedformat ) {
case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
$headstart = '<' . $this->m_embedformat . '>';
$headend = '</' . $this->m_embedformat . ">\n";
break;
case 'ul': case 'ol':
$result .= '<' . $this->m_embedformat . '>';
$footer = '</' . $this->m_embedformat . '>';
$embstart = '<li>';
$headend = "<br />\n";
$embend = "</li>\n";
break;
}
// Print all result rows:
foreach ( $res->getResults() as $diWikiPage ) {
if ( $diWikiPage instanceof DIWikiPage ) { // ensure that we deal with title-likes
$dvWikiPage = DataValueFactory::getInstance()->newDataItemValue( $diWikiPage, null );
$result .= $embstart;
if ( $this->m_showhead ) {
$result .= $headstart . $dvWikiPage->getLongWikiText( $this->mLinker ) . $headend;
}
if ( $dvWikiPage->getLongWikiText() != $title ) {
if ( $diWikiPage->getNamespace() == NS_MAIN ) {
$result .= '{{:' . $diWikiPage->getDBkey() . '}}';
} else {
$result .= '{{' . $dvWikiPage->getLongWikiText() . '}}';
}
} else { // block recursion
$result .= '<b>' . $dvWikiPage->getLongWikiText() . '</b>';
}
$result .= $embend;
}
}
// show link to more results
if ( $this->linkFurtherResults( $res ) ) {
$result .= $embstart
. $this->getFurtherResultsLink( $res, $outputMode )->getText( SMW_OUTPUT_WIKI, $this->mLinker )
. $embend;
}
$result .= $footer;
return $result;
}
public function getParameters() {
$params = parent::getParameters();
$params[] = array(
'name' => 'embedformat',
'message' => 'smw-paramdesc-embedformat',
'default' => 'h1',
'values' => array( 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'ol', 'ul' ),
);
$params[] = array(
'name' => 'embedonly',
'type' => 'boolean',
'message' => 'smw-paramdesc-embedonly',
'default' => false,
);
return $params;
}
}
| mit |
JasonGross/graphviz-packaging | reference-graphviz-2.39.20141222.0545/plugin/xlib/gvdevice_xlib.c | 17220 | /* $Id$ $Revision$ */
/* vim:set shiftwidth=4 ts=8: */
/*************************************************************************
* Copyright (c) 2011 AT&T Intellectual Property
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors: See CVS logs. Details at http://www.graphviz.org/
*************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#ifdef HAVE_SYS_INOTIFY_H
#include <sys/inotify.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#if 0
#include <poll.h>
#endif
#include "gvplugin_device.h"
#include <cairo.h>
#ifdef CAIRO_HAS_XLIB_SURFACE
#include <cairo-xlib.h>
#include <X11/Xutil.h>
#include <X11/extensions/Xrender.h>
typedef struct window_xlib_s {
Window win;
unsigned long event_mask;
Pixmap pix;
GC gc;
Visual *visual;
Colormap cmap;
int depth;
Atom wm_delete_window_atom;
} window_t;
static void handle_configure_notify(GVJ_t * job, XConfigureEvent * cev)
{
/*FIXME - should allow for margins */
/* - similar zoom_to_fit code exists in: */
/* plugin/gtk/callbacks.c */
/* plugin/xlib/gvdevice_xlib.c */
/* lib/gvc/gvevent.c */
job->zoom *= 1 + MIN(
((double) cev->width - (double) job->width) / (double) job->width,
((double) cev->height - (double) job->height) / (double) job->height);
if (cev->width > job->width || cev->height > job->height)
job->has_grown = 1;
job->width = cev->width;
job->height = cev->height;
job->needs_refresh = 1;
}
static void handle_expose(GVJ_t * job, XExposeEvent * eev)
{
window_t *window;
window = (window_t *)job->window;
XCopyArea(eev->display, window->pix, eev->window, window->gc,
eev->x, eev->y, eev->width, eev->height, eev->x, eev->y);
}
static void handle_client_message(GVJ_t * job, XClientMessageEvent * cmev)
{
window_t *window;
window = (window_t *)job->window;
if (cmev->format == 32
&& (Atom) cmev->data.l[0] == window->wm_delete_window_atom)
exit(0);
}
static boolean handle_keypress(GVJ_t *job, XKeyEvent *kev)
{
int i;
KeyCode *keycodes;
keycodes = (KeyCode *)job->keycodes;
for (i=0; i < job->numkeys; i++) {
if (kev->keycode == keycodes[i])
return (job->keybindings[i].callback)(job);
}
return FALSE;
}
static Visual *find_argb_visual(Display * dpy, int scr)
{
XVisualInfo *xvi;
XVisualInfo template;
int nvi;
int i;
XRenderPictFormat *format;
Visual *visual;
template.screen = scr;
template.depth = 32;
template.class = TrueColor;
xvi = XGetVisualInfo(dpy,
VisualScreenMask |
VisualDepthMask |
VisualClassMask, &template, &nvi);
if (!xvi)
return 0;
visual = 0;
for (i = 0; i < nvi; i++) {
format = XRenderFindVisualFormat(dpy, xvi[i].visual);
if (format->type == PictTypeDirect && format->direct.alphaMask) {
visual = xvi[i].visual;
break;
}
}
XFree(xvi);
return visual;
}
static void browser_show(GVJ_t *job)
{
#if defined HAVE_SYS_TYPES_H && defined HAVE_UNISTD_H && defined HAVE_ERRNO_H
char *exec_argv[3] = {BROWSER, NULL, NULL};
pid_t pid;
int err;
exec_argv[1] = job->selected_href;
pid = fork();
if (pid == -1) {
fprintf(stderr,"fork failed: %s\n", strerror(errno));
}
else if (pid == 0) {
err = execvp(exec_argv[0], exec_argv);
fprintf(stderr,"error starting %s: %s\n", exec_argv[0], strerror(errno));
}
#else
fprintf(stdout,"browser_show: %s\n", job->selected_href);
#endif
}
static int handle_xlib_events (GVJ_t *firstjob, Display *dpy)
{
GVJ_t *job;
window_t *window;
XEvent xev;
pointf pointer;
int rc = 0;
while (XPending(dpy)) {
XNextEvent(dpy, &xev);
for (job = firstjob; job; job = job->next_active) {
window = (window_t *)job->window;
if (xev.xany.window == window->win) {
switch (xev.xany.type) {
case ButtonPress:
pointer.x = (double)xev.xbutton.x;
pointer.y = (double)xev.xbutton.y;
(job->callbacks->button_press)(job, xev.xbutton.button, pointer);
rc++;
break;
case MotionNotify:
if (job->button) { /* only interested while a button is pressed */
pointer.x = (double)xev.xbutton.x;
pointer.y = (double)xev.xbutton.y;
(job->callbacks->motion)(job, pointer);
rc++;
}
break;
case ButtonRelease:
pointer.x = (double)xev.xbutton.x;
pointer.y = (double)xev.xbutton.y;
(job->callbacks->button_release)(job, xev.xbutton.button, pointer);
if (job->selected_href && job->selected_href[0] && xev.xbutton.button == 1)
browser_show(job);
rc++;
break;
case KeyPress:
if (handle_keypress(job, &xev.xkey))
return -1; /* exit code */
rc++;
break;
case ConfigureNotify:
handle_configure_notify(job, &xev.xconfigure);
rc++;
break;
case Expose:
handle_expose(job, &xev.xexpose);
rc++;
break;
case ClientMessage:
handle_client_message(job, &xev.xclient);
rc++;
break;
}
break;
}
}
}
return rc;
}
static void update_display(GVJ_t *job, Display *dpy)
{
window_t *window;
cairo_surface_t *surface;
window = (window_t *)job->window;
if (job->has_grown) {
XFreePixmap(dpy, window->pix);
window->pix = XCreatePixmap(dpy, window->win,
job->width, job->height, window->depth);
job->has_grown = 0;
job->needs_refresh = 1;
}
if (job->needs_refresh) {
XFillRectangle(dpy, window->pix, window->gc, 0, 0,
job->width, job->height);
surface = cairo_xlib_surface_create(dpy,
window->pix, window->visual,
job->width, job->height);
job->context = (void *)cairo_create(surface);
job->external_context = TRUE;
(job->callbacks->refresh)(job);
cairo_surface_destroy(surface);
XCopyArea(dpy, window->pix, window->win, window->gc,
0, 0, job->width, job->height, 0, 0);
job->needs_refresh = 0;
}
}
static void init_window(GVJ_t *job, Display *dpy, int scr)
{
int argb = 0;
const char *base = "";
XGCValues gcv;
XSetWindowAttributes attributes;
XWMHints *wmhints;
XSizeHints *normalhints;
XClassHint *classhint;
unsigned long attributemask = 0;
char *name;
window_t *window;
int w, h;
double zoom_to_fit;
window = (window_t *)malloc(sizeof(window_t));
if (window == NULL) {
fprintf(stderr, "Failed to malloc window_t\n");
return;
}
w = 480; /* FIXME - w,h should be set by a --geometry commandline option */
h = 325;
zoom_to_fit = MIN((double) w / (double) job->width,
(double) h / (double) job->height);
if (zoom_to_fit < 1.0) /* don't make bigger */
job->zoom *= zoom_to_fit;
job->width = w; /* use window geometry */
job->height = h;
job->window = (void *)window;
job->fit_mode = 0;
job->needs_refresh = 1;
if (argb && (window->visual = find_argb_visual(dpy, scr))) {
window->cmap = XCreateColormap(dpy, RootWindow(dpy, scr),
window->visual, AllocNone);
attributes.override_redirect = False;
attributes.background_pixel = 0;
attributes.border_pixel = 0;
attributes.colormap = window->cmap;
attributemask = ( CWBackPixel
| CWBorderPixel
| CWOverrideRedirect
| CWColormap );
window->depth = 32;
} else {
window->cmap = DefaultColormap(dpy, scr);
window->visual = DefaultVisual(dpy, scr);
attributes.background_pixel = WhitePixel(dpy, scr);
attributes.border_pixel = BlackPixel(dpy, scr);
attributemask = (CWBackPixel | CWBorderPixel);
window->depth = DefaultDepth(dpy, scr);
}
window->win = XCreateWindow(dpy, RootWindow(dpy, scr),
0, 0, job->width, job->height, 0, window->depth,
InputOutput, window->visual,
attributemask, &attributes);
name = malloc(strlen("graphviz: ") + strlen(base) + 1);
strcpy(name, "graphviz: ");
strcat(name, base);
normalhints = XAllocSizeHints();
normalhints->flags = 0;
normalhints->x = 0;
normalhints->y = 0;
normalhints->width = job->width;
normalhints->height = job->height;
classhint = XAllocClassHint();
classhint->res_name = "graphviz";
classhint->res_class = "Graphviz";
wmhints = XAllocWMHints();
wmhints->flags = InputHint;
wmhints->input = True;
Xutf8SetWMProperties(dpy, window->win, name, base, 0, 0,
normalhints, wmhints, classhint);
XFree(wmhints);
XFree(classhint);
XFree(normalhints);
free(name);
window->pix = XCreatePixmap(dpy, window->win, job->width, job->height,
window->depth);
if (argb)
gcv.foreground = 0;
else
gcv.foreground = WhitePixel(dpy, scr);
window->gc = XCreateGC(dpy, window->pix, GCForeground, &gcv);
update_display(job, dpy);
window->event_mask = (
ButtonPressMask
| ButtonReleaseMask
| PointerMotionMask
| KeyPressMask
| StructureNotifyMask
| ExposureMask);
XSelectInput(dpy, window->win, window->event_mask);
window->wm_delete_window_atom =
XInternAtom(dpy, "WM_DELETE_WINDOW", False);
XSetWMProtocols(dpy, window->win, &window->wm_delete_window_atom, 1);
XMapWindow(dpy, window->win);
}
static int handle_stdin_events(GVJ_t *job, int stdin_fd)
{
int rc=0;
if (feof(stdin))
return -1;
(job->callbacks->read)(job, job->input_filename, job->layout_type);
rc++;
return rc;
}
#ifdef HAVE_SYS_INOTIFY_H
static int handle_file_events(GVJ_t *job, int inotify_fd)
{
int avail, ret, len, ln, rc = 0;
static char *buf;
char *bf, *p;
struct inotify_event *event;
ret = ioctl(inotify_fd, FIONREAD, &avail);
if (ret < 0) {
fprintf(stderr,"ioctl() failed\n");
return -1;;
}
if (avail) {
buf = realloc(buf, avail);
if (!buf) {
fprintf(stderr,"problem with realloc(%d)\n", avail);
return -1;
}
len = read(inotify_fd, buf, avail);
if (len != avail) {
fprintf(stderr,"avail = %u, len = %u\n", avail, len);
return -1;
}
bf = buf;
while (len > 0) {
event = (struct inotify_event *)bf;
switch (event->mask) {
case IN_MODIFY:
p = strrchr(job->input_filename, '/');
if (p)
p++;
else
p = job->input_filename;
if (strcmp((char*)(&(event->name)), p) == 0) {
(job->callbacks->read)(job, job->input_filename, job->layout_type);
rc++;
}
break;
case IN_ACCESS:
case IN_ATTRIB:
case IN_CLOSE_WRITE:
case IN_CLOSE_NOWRITE:
case IN_OPEN:
case IN_MOVED_FROM:
case IN_MOVED_TO:
case IN_CREATE:
case IN_DELETE:
case IN_DELETE_SELF:
case IN_MOVE_SELF:
case IN_UNMOUNT:
case IN_Q_OVERFLOW:
case IN_IGNORED:
case IN_ISDIR:
case IN_ONESHOT:
break;
}
ln = event->len + sizeof(struct inotify_event);
bf += ln;
len -= ln;
}
if (len != 0) {
fprintf(stderr,"length miscalculation, len = %d\n", len);
return -1;
}
}
return rc;
}
#endif
static void xlib_initialize(GVJ_t *firstjob)
{
Display *dpy;
KeySym keysym;
KeyCode *keycodes;
const char *display_name = NULL;
int i, scr;
dpy = XOpenDisplay(display_name);
if (dpy == NULL) {
fprintf(stderr, "Failed to open XLIB display: %s\n",
XDisplayName(NULL));
return;
}
scr = DefaultScreen(dpy);
firstjob->display = (void*)dpy;
firstjob->screen = scr;
keycodes = (KeyCode *)malloc(firstjob->numkeys * sizeof(KeyCode));
if (keycodes == NULL) {
fprintf(stderr, "Failed to malloc %d*KeyCode\n", firstjob->numkeys);
return;
}
for (i = 0; i < firstjob->numkeys; i++) {
keysym = XStringToKeysym(firstjob->keybindings[i].keystring);
if (keysym == NoSymbol)
fprintf(stderr, "ERROR: No keysym for \"%s\"\n",
firstjob->keybindings[i].keystring);
else
keycodes[i] = XKeysymToKeycode(dpy, keysym);
}
firstjob->keycodes = (void*)keycodes;
firstjob->device_dpi.x = DisplayWidth(dpy, scr) * 25.4 / DisplayWidthMM(dpy, scr);
firstjob->device_dpi.y = DisplayHeight(dpy, scr) * 25.4 / DisplayHeightMM(dpy, scr);
firstjob->device_sets_dpi = TRUE;
}
static void xlib_finalize(GVJ_t *firstjob)
{
GVJ_t *job;
Display *dpy = (Display *)(firstjob->display);
int scr = firstjob->screen;
KeyCode *keycodes= firstjob->keycodes;
int numfds, stdin_fd=0, xlib_fd, ret, events;
fd_set rfds;
boolean watching_stdin_p = FALSE;
#ifdef HAVE_SYS_INOTIFY_H
int wd=0;
int inotify_fd=0;
boolean watching_file_p = FALSE;
static char *dir;
char *p, *cwd = NULL;
inotify_fd = inotify_init();
if (inotify_fd < 0) {
fprintf(stderr,"inotify_init() failed\n");
return;
}
#endif
numfds = xlib_fd = XConnectionNumber(dpy);
if (firstjob->input_filename) {
if (firstjob->graph_index == 0) {
#ifdef HAVE_SYS_INOTIFY_H
watching_file_p = TRUE;
if (firstjob->input_filename[0] != '/') {
cwd = getcwd(NULL, 0);
dir = realloc(dir, strlen(cwd) + 1 + strlen(firstjob->input_filename) + 1);
strcpy(dir, cwd);
strcat(dir, "/");
strcat(dir, firstjob->input_filename);
free(cwd);
}
else {
dir = realloc(dir, strlen(firstjob->input_filename) + 1);
strcpy(dir, firstjob->input_filename);
}
p = strrchr(dir,'/');
*p = '\0';
wd = inotify_add_watch(inotify_fd, dir, IN_MODIFY );
numfds = MAX(inotify_fd, numfds);
#endif
}
}
else {
watching_stdin_p = TRUE;
stdin_fd = fcntl(STDIN_FILENO, F_DUPFD, 0);
numfds = MAX(stdin_fd, numfds);
}
for (job = firstjob; job; job = job->next_active)
init_window(job, dpy, scr);
/* This is the event loop */
FD_ZERO(&rfds);
while (1) {
events = 0;
#ifdef HAVE_SYS_INOTIFY_H
if (watching_file_p) {
if (FD_ISSET(inotify_fd, &rfds)) {
ret = handle_file_events(firstjob, inotify_fd);
if (ret < 0)
break;
events += ret;
}
FD_SET(inotify_fd, &rfds);
}
#endif
if (watching_stdin_p) {
if (FD_ISSET(stdin_fd, &rfds)) {
ret = handle_stdin_events(firstjob, stdin_fd);
if (ret < 0)
watching_stdin_p = FALSE;
events += ret;
}
if (watching_stdin_p)
FD_SET(stdin_fd, &rfds);
}
ret = handle_xlib_events(firstjob, dpy);
if (ret < 0)
break;
events += ret;
FD_SET(xlib_fd, &rfds);
if (events) {
for (job = firstjob; job; job = job->next_active)
update_display(job, dpy);
XFlush(dpy);
}
ret = select(numfds+1, &rfds, NULL, NULL, NULL);
if (ret < 0) {
fprintf(stderr,"select() failed\n");
break;
}
}
#ifdef HAVE_SYS_INOTIFY_H
if (watching_file_p)
ret = inotify_rm_watch(inotify_fd, wd);
#endif
XCloseDisplay(dpy);
free(keycodes);
firstjob->keycodes = NULL;
}
static gvdevice_features_t device_features_xlib = {
GVDEVICE_DOES_TRUECOLOR
| GVDEVICE_EVENTS, /* flags */
{0.,0.}, /* default margin - points */
{0.,0.}, /* default page width, height - points */
{96.,96.}, /* dpi */
};
static gvdevice_engine_t device_engine_xlib = {
xlib_initialize,
NULL, /* xlib_format */
xlib_finalize,
};
#endif
gvplugin_installed_t gvdevice_types_xlib[] = {
#ifdef CAIRO_HAS_XLIB_SURFACE
{0, "xlib:cairo", 0, &device_engine_xlib, &device_features_xlib},
{0, "x11:cairo", 0, &device_engine_xlib, &device_features_xlib},
#endif
{0, NULL, 0, NULL, NULL}
};
| mit |
timfel/mspec | spec/guards/conflict_spec.rb | 1789 | require File.dirname(__FILE__) + '/../spec_helper'
require 'mspec/guards/conflict'
describe Object, "#conflicts_with" do
before :each do
ScratchPad.clear
end
it "does not yield if Object.constants includes any of the arguments" do
Object.stub!(:constants).and_return(["SomeClass", "OtherClass"])
conflicts_with(:SomeClass, :AClass, :BClass) { ScratchPad.record :yield }
ScratchPad.recorded.should_not == :yield
end
it "does not yield if Object.constants (as Symbols) includes any of the arguments" do
Object.stub!(:constants).and_return([:SomeClass, :OtherClass])
conflicts_with(:SomeClass, :AClass, :BClass) { ScratchPad.record :yield }
ScratchPad.recorded.should_not == :yield
end
it "yields if Object.constants does not include any of the arguments" do
Object.stub!(:constants).and_return(["SomeClass", "OtherClass"])
conflicts_with(:AClass, :BClass) { ScratchPad.record :yield }
ScratchPad.recorded.should == :yield
end
it "yields if Object.constants (as Symbols) does not include any of the arguments" do
Object.stub!(:constants).and_return([:SomeClass, :OtherClass])
conflicts_with(:AClass, :BClass) { ScratchPad.record :yield }
ScratchPad.recorded.should == :yield
end
end
describe Object, "#conflicts_with" do
before :each do
@guard = ConflictsGuard.new
ConflictsGuard.stub!(:new).and_return(@guard)
end
it "sets the name of the guard to :conflicts_with" do
conflicts_with(:AClass, :BClass) { }
@guard.name.should == :conflicts_with
end
it "calls #unregister even when an exception is raised in the guard block" do
@guard.should_receive(:unregister)
lambda do
conflicts_with(:AClass, :BClass) { raise Exception }
end.should raise_error(Exception)
end
end
| mit |
askl56/rubyspec | core/encoding/compatible_spec.rb | 13521 | # -*- encoding: ascii-8bit -*-
require File.expand_path('../../../spec_helper', __FILE__)
with_feature :encoding do
# TODO: add IO
describe "Encoding.compatible? String, String" do
describe "when the first's Encoding is valid US-ASCII" do
before :each do
@str = "abc".force_encoding Encoding::US_ASCII
end
it "returns US-ASCII when the second's is US-ASCII" do
Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::US_ASCII
end
it "returns US-ASCII if the second String is ASCII-8BIT and ASCII only" do
Encoding.compatible?(@str, "\x7f").should == Encoding::US_ASCII
end
it "returns ASCII-8BIT if the second String is ASCII-8BIT but not ASCII only" do
Encoding.compatible?(@str, "\xff").should == Encoding::ASCII_8BIT
end
it "returns US-ASCII if the second String is UTF-8 and ASCII only" do
Encoding.compatible?(@str, "\x7f".encode("utf-8")).should == Encoding::US_ASCII
end
it "returns UTF-8 if the second String is UTF-8 but not ASCII only" do
Encoding.compatible?(@str, "\u3042".encode("utf-8")).should == Encoding::UTF_8
end
end
describe "when the first's Encoding is ASCII compatible and ASCII only" do
it "returns the first's Encoding if the second is ASCII compatible and ASCII only" do
[ [Encoding, "abc".force_encoding("UTF-8"), "123".force_encoding("Shift_JIS"), Encoding::UTF_8],
[Encoding, "123".force_encoding("Shift_JIS"), "abc".force_encoding("UTF-8"), Encoding::Shift_JIS]
].should be_computed_by(:compatible?)
end
it "returns the first's Encoding if the second is ASCII compatible and ASCII only" do
[ [Encoding, "abc".force_encoding("ASCII-8BIT"), "123".force_encoding("US-ASCII"), Encoding::ASCII_8BIT],
[Encoding, "123".force_encoding("US-ASCII"), "abc".force_encoding("ASCII-8BIT"), Encoding::US_ASCII]
].should be_computed_by(:compatible?)
end
it "returns the second's Encoding if the second is ASCII compatible but not ASCII only" do
[ [Encoding, "abc".force_encoding("UTF-8"), "\xff".force_encoding("Shift_JIS"), Encoding::Shift_JIS],
[Encoding, "123".force_encoding("Shift_JIS"), "\xff".force_encoding("UTF-8"), Encoding::UTF_8],
[Encoding, "abc".force_encoding("ASCII-8BIT"), "\xff".force_encoding("US-ASCII"), Encoding::US_ASCII],
[Encoding, "123".force_encoding("US-ASCII"), "\xff".force_encoding("ASCII-8BIT"), Encoding::ASCII_8BIT],
].should be_computed_by(:compatible?)
end
it "returns nil if the second's Encoding is not ASCII compatible" do
a = "abc".force_encoding("UTF-8")
b = "123".force_encoding("UTF-16LE")
Encoding.compatible?(a, b).should be_nil
end
end
describe "when the first's Encoding is ASCII compatible but not ASCII only" do
it "returns the first's Encoding if the second's is valid US-ASCII" do
Encoding.compatible?("\xff", "def".encode("us-ascii")).should == Encoding::ASCII_8BIT
end
it "returns the first's Encoding if the second's is UTF-8 and ASCII only" do
Encoding.compatible?("\xff", "\u{7f}".encode("utf-8")).should == Encoding::ASCII_8BIT
end
it "returns nil if the second encoding is ASCII compatible but neither String's encoding is ASCII only" do
Encoding.compatible?("\xff", "\u3042".encode("utf-8")).should be_nil
end
end
describe "when the first's Encoding is not ASCII compatible" do
before :each do
@str = "abc".force_encoding Encoding::UTF_7
end
it "returns nil when the second String is US-ASCII" do
Encoding.compatible?(@str, "def".encode("us-ascii")).should be_nil
end
it "returns nil when the second String is ASCII-8BIT and ASCII only" do
Encoding.compatible?(@str, "\x7f").should be_nil
end
it "returns nil when the second String is ASCII-8BIT but not ASCII only" do
Encoding.compatible?(@str, "\xff").should be_nil
end
it "returns the Encoding when the second's Encoding is not ASCII compatible but the same as the first's Encoding" do
encoding = Encoding.compatible?(@str, "def".force_encoding("utf-7"))
encoding.should == Encoding::UTF_7
end
end
describe "when the first's Encoding is invalid" do
before :each do
@str = "\xff".force_encoding Encoding::UTF_8
end
it "returns the first's Encoding when the second's Encoding is US-ASCII" do
Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::UTF_8
end
it "returns the first's Encoding when the second String is ASCII only" do
Encoding.compatible?(@str, "\x7f").should == Encoding::UTF_8
end
it "returns nil when the second's Encoding is ASCII-8BIT but not ASCII only" do
Encoding.compatible?(@str, "\xff").should be_nil
end
it "returns nil when the second's Encoding is invalid and ASCII only" do
Encoding.compatible?(@str, "\x7f".force_encoding("utf-16be")).should be_nil
end
it "returns nil when the second's Encoding is invalid and not ASCII only" do
Encoding.compatible?(@str, "\xff".force_encoding("utf-16be")).should be_nil
end
it "returns the Encoding when the second's Encoding is invalid but the same as the first" do
Encoding.compatible?(@str, @str).should == Encoding::UTF_8
end
end
end
describe "Encoding.compatible? String, Regexp" do
it "returns US-ASCII if both are US-ASCII" do
str = "abc".force_encoding("us-ascii")
Encoding.compatible?(str, /abc/).should == Encoding::US_ASCII
end
it "returns the String's Encoding if it is not US-ASCII but both are ASCII only" do
[ [Encoding, "abc", Encoding::ASCII_8BIT],
[Encoding, "abc".encode("utf-8"), Encoding::UTF_8],
[Encoding, "abc".encode("euc-jp"), Encoding::EUC_JP],
[Encoding, "abc".encode("shift_jis"), Encoding::Shift_JIS],
].should be_computed_by(:compatible?, /abc/)
end
it "returns the String's Encoding if the String is not ASCII only" do
[ [Encoding, "\xff", Encoding::ASCII_8BIT],
[Encoding, "\u3042".encode("utf-8"), Encoding::UTF_8],
[Encoding, "\xa4\xa2".force_encoding("euc-jp"), Encoding::EUC_JP],
[Encoding, "\x82\xa0".force_encoding("shift_jis"), Encoding::Shift_JIS],
].should be_computed_by(:compatible?, /abc/)
end
end
describe "Encoding.compatible? String, Symbol" do
it "returns US-ASCII if both are ASCII only" do
str = "abc".force_encoding("us-ascii")
Encoding.compatible?(str, :abc).should == Encoding::US_ASCII
end
it "returns the String's Encoding if it is not US-ASCII but both are ASCII only" do
[ [Encoding, "abc", Encoding::ASCII_8BIT],
[Encoding, "abc".encode("utf-8"), Encoding::UTF_8],
[Encoding, "abc".encode("euc-jp"), Encoding::EUC_JP],
[Encoding, "abc".encode("shift_jis"), Encoding::Shift_JIS],
].should be_computed_by(:compatible?, :abc)
end
it "returns the String's Encoding if the String is not ASCII only" do
[ [Encoding, "\xff", Encoding::ASCII_8BIT],
[Encoding, "\u3042".encode("utf-8"), Encoding::UTF_8],
[Encoding, "\xa4\xa2".force_encoding("euc-jp"), Encoding::EUC_JP],
[Encoding, "\x82\xa0".force_encoding("shift_jis"), Encoding::Shift_JIS],
].should be_computed_by(:compatible?, :abc)
end
end
describe "Encoding.compatible? Regexp, String" do
it "returns US-ASCII if both are US-ASCII" do
str = "abc".force_encoding("us-ascii")
Encoding.compatible?(/abc/, str).should == Encoding::US_ASCII
end
end
describe "Encoding.compatible? Regexp, Regexp" do
it "returns US-ASCII if both are US-ASCII" do
Encoding.compatible?(/abc/, /def/).should == Encoding::US_ASCII
end
it "returns the first's Encoding if it is not US-ASCII and not ASCII only" do
[ [Encoding, Regexp.new("\xff"), Encoding::ASCII_8BIT],
[Encoding, Regexp.new("\u3042".encode("utf-8")), Encoding::UTF_8],
[Encoding, Regexp.new("\xa4\xa2".force_encoding("euc-jp")), Encoding::EUC_JP],
[Encoding, Regexp.new("\x82\xa0".force_encoding("shift_jis")), Encoding::Shift_JIS],
].should be_computed_by(:compatible?, /abc/)
end
end
describe "Encoding.compatible? Regexp, Symbol" do
it "returns US-ASCII if both are US-ASCII" do
Encoding.compatible?(/abc/, :def).should == Encoding::US_ASCII
end
it "returns the first's Encoding if it is not US-ASCII and not ASCII only" do
[ [Encoding, Regexp.new("\xff"), Encoding::ASCII_8BIT],
[Encoding, Regexp.new("\u3042".encode("utf-8")), Encoding::UTF_8],
[Encoding, Regexp.new("\xa4\xa2".force_encoding("euc-jp")), Encoding::EUC_JP],
[Encoding, Regexp.new("\x82\xa0".force_encoding("shift_jis")), Encoding::Shift_JIS],
].should be_computed_by(:compatible?, /abc/)
end
end
describe "Encoding.compatible? Symbol, String" do
it "returns US-ASCII if both are ASCII only" do
str = "abc".force_encoding("us-ascii")
Encoding.compatible?(str, :abc).should == Encoding::US_ASCII
end
end
describe "Encoding.compatible? Symbol, Regexp" do
it "returns US-ASCII if both are US-ASCII" do
Encoding.compatible?(:abc, /def/).should == Encoding::US_ASCII
end
it "returns the Regexp's Encoding if it is not US-ASCII and not ASCII only" do
a = Regexp.new("\xff")
b = Regexp.new("\u3042".encode("utf-8"))
c = Regexp.new("\xa4\xa2".force_encoding("euc-jp"))
d = Regexp.new("\x82\xa0".force_encoding("shift_jis"))
[ [Encoding, :abc, a, Encoding::ASCII_8BIT],
[Encoding, :abc, b, Encoding::UTF_8],
[Encoding, :abc, c, Encoding::EUC_JP],
[Encoding, :abc, d, Encoding::Shift_JIS],
].should be_computed_by(:compatible?)
end
end
describe "Encoding.compatible? Symbol, Symbol" do
it "returns US-ASCII if both are US-ASCII" do
Encoding.compatible?(:abc, :def).should == Encoding::US_ASCII
end
it "returns the first's Encoding if it is not ASCII only" do
[ [Encoding, "\xff".to_sym, Encoding::ASCII_8BIT],
[Encoding, "\u3042".encode("utf-8").to_sym, Encoding::UTF_8],
[Encoding, "\xa4\xa2".force_encoding("euc-jp").to_sym, Encoding::EUC_JP],
[Encoding, "\x82\xa0".force_encoding("shift_jis").to_sym, Encoding::Shift_JIS],
].should be_computed_by(:compatible?, :abc)
end
end
describe "Encoding.compatible? Encoding, Encoding" do
it "returns nil if one of the encodings is a dummy encoding" do
[ [Encoding, Encoding::UTF_7, Encoding::US_ASCII, nil],
[Encoding, Encoding::US_ASCII, Encoding::UTF_7, nil],
[Encoding, Encoding::EUC_JP, Encoding::UTF_7, nil],
[Encoding, Encoding::UTF_7, Encoding::EUC_JP, nil],
[Encoding, Encoding::UTF_7, Encoding::ASCII_8BIT, nil],
[Encoding, Encoding::ASCII_8BIT, Encoding::UTF_7, nil],
].should be_computed_by(:compatible?)
end
it "returns nil if one of the encodings is not US-ASCII" do
[ [Encoding, Encoding::UTF_8, Encoding::ASCII_8BIT, nil],
[Encoding, Encoding::ASCII_8BIT, Encoding::UTF_8, nil],
[Encoding, Encoding::ASCII_8BIT, Encoding::EUC_JP, nil],
[Encoding, Encoding::Shift_JIS, Encoding::EUC_JP, nil],
].should be_computed_by(:compatible?)
end
it "returns the first if the second is US-ASCII" do
[ [Encoding, Encoding::UTF_8, Encoding::US_ASCII, Encoding::UTF_8],
[Encoding, Encoding::EUC_JP, Encoding::US_ASCII, Encoding::EUC_JP],
[Encoding, Encoding::Shift_JIS, Encoding::US_ASCII, Encoding::Shift_JIS],
[Encoding, Encoding::ASCII_8BIT, Encoding::US_ASCII, Encoding::ASCII_8BIT],
].should be_computed_by(:compatible?)
end
it "returns the Encoding if both are the same" do
[ [Encoding, Encoding::UTF_8, Encoding::UTF_8, Encoding::UTF_8],
[Encoding, Encoding::US_ASCII, Encoding::US_ASCII, Encoding::US_ASCII],
[Encoding, Encoding::ASCII_8BIT, Encoding::ASCII_8BIT, Encoding::ASCII_8BIT],
[Encoding, Encoding::UTF_7, Encoding::UTF_7, Encoding::UTF_7],
].should be_computed_by(:compatible?)
end
end
describe "Encoding.compatible? Object, Object" do
it "returns nil for Object, String" do
Encoding.compatible?(Object.new, "abc").should be_nil
end
it "returns nil for Object, Regexp" do
Encoding.compatible?(Object.new, /./).should be_nil
end
it "returns nil for Object, Symbol" do
Encoding.compatible?(Object.new, :sym).should be_nil
end
it "returns nil for String, Object" do
Encoding.compatible?("abc", Object.new).should be_nil
end
it "returns nil for Regexp, Object" do
Encoding.compatible?(/./, Object.new).should be_nil
end
it "returns nil for Symbol, Object" do
Encoding.compatible?(:sym, Object.new).should be_nil
end
end
end
| mit |
DmitriySalnikov/godot | scene/gui/aspect_ratio_container.h | 3502 | /*************************************************************************/
/* aspect_ratio_container.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef ASPECT_RATIO_CONTAINER_H
#define ASPECT_RATIO_CONTAINER_H
#include "scene/gui/container.h"
class AspectRatioContainer : public Container {
GDCLASS(AspectRatioContainer, Container);
protected:
void _notification(int p_what);
static void _bind_methods();
virtual Size2 get_minimum_size() const override;
public:
enum StretchMode {
STRETCH_WIDTH_CONTROLS_HEIGHT,
STRETCH_HEIGHT_CONTROLS_WIDTH,
STRETCH_FIT,
STRETCH_COVER,
};
enum AlignMode {
ALIGN_BEGIN,
ALIGN_CENTER,
ALIGN_END,
};
private:
float ratio = 1.0;
StretchMode stretch_mode = STRETCH_FIT;
AlignMode alignment_horizontal = ALIGN_CENTER;
AlignMode alignment_vertical = ALIGN_CENTER;
public:
void set_ratio(float p_ratio);
float get_ratio() const { return ratio; }
void set_stretch_mode(StretchMode p_mode);
StretchMode get_stretch_mode() const { return stretch_mode; }
void set_alignment_horizontal(AlignMode p_alignment_horizontal);
AlignMode get_alignment_horizontal() const { return alignment_horizontal; }
void set_alignment_vertical(AlignMode p_alignment_vertical);
AlignMode get_alignment_vertical() const { return alignment_vertical; }
};
VARIANT_ENUM_CAST(AspectRatioContainer::StretchMode);
VARIANT_ENUM_CAST(AspectRatioContainer::AlignMode);
#endif // ASPECT_RATIO_CONTAINER_H
| mit |
localheinz/symfony | src/Symfony/Component/Mailer/Bridge/Amazon/Tests/Transport/SesApiTransportTest.php | 4500 | <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <[email protected]>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mailer\Bridge\Amazon\Tests\Transport;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpClient\MockHttpClient;
use Symfony\Component\HttpClient\Response\MockResponse;
use Symfony\Component\Mailer\Bridge\Amazon\Transport\SesApiTransport;
use Symfony\Component\Mailer\Exception\HttpTransportException;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Contracts\HttpClient\ResponseInterface;
class SesApiTransportTest extends TestCase
{
/**
* @dataProvider getTransportData
*/
public function testToString(SesApiTransport $transport, string $expected)
{
$this->assertSame($expected, (string) $transport);
}
public function getTransportData()
{
return [
[
new SesApiTransport('ACCESS_KEY', 'SECRET_KEY'),
'ses+api://[email protected]',
],
[
new SesApiTransport('ACCESS_KEY', 'SECRET_KEY', 'us-east-1'),
'ses+api://[email protected]',
],
[
(new SesApiTransport('ACCESS_KEY', 'SECRET_KEY'))->setHost('example.com'),
'ses+api://[email protected]',
],
[
(new SesApiTransport('ACCESS_KEY', 'SECRET_KEY'))->setHost('example.com')->setPort(99),
'ses+api://[email protected]:99',
],
];
}
public function testSend()
{
$client = new MockHttpClient(function (string $method, string $url, array $options): ResponseInterface {
$this->assertSame('POST', $method);
$this->assertSame('https://email.eu-west-1.amazonaws.com:8984/', $url);
$this->assertStringContainsStringIgnoringCase('X-Amzn-Authorization: AWS3-HTTPS AWSAccessKeyId=ACCESS_KEY,Algorithm=HmacSHA256,Signature=', $options['headers'][0] ?? $options['request_headers'][0]);
parse_str($options['body'], $content);
$this->assertSame('Hello!', $content['Message_Subject_Data']);
$this->assertSame('Saif Eddin <[email protected]>', $content['Destination_ToAddresses_member'][0]);
$this->assertSame('Fabien <[email protected]>', $content['Source']);
$this->assertSame('Hello There!', $content['Message_Body_Text_Data']);
$xml = '<SendEmailResponse xmlns="https://email.amazonaws.com/doc/2010-03-31/">
<SendEmailResult>
<MessageId>foobar</MessageId>
</SendEmailResult>
</SendEmailResponse>';
return new MockResponse($xml, [
'http_code' => 200,
]);
});
$transport = new SesApiTransport('ACCESS_KEY', 'SECRET_KEY', null, $client);
$transport->setPort(8984);
$mail = new Email();
$mail->subject('Hello!')
->to(new Address('[email protected]', 'Saif Eddin'))
->from(new Address('[email protected]', 'Fabien'))
->text('Hello There!');
$message = $transport->send($mail);
$this->assertSame('foobar', $message->getMessageId());
}
public function testSendThrowsForErrorResponse()
{
$client = new MockHttpClient(function (string $method, string $url, array $options): ResponseInterface {
$xml = "<SendEmailResponse xmlns=\"https://email.amazonaws.com/doc/2010-03-31/\">
<Error>
<Message>i'm a teapot</Message>
<Code>418</Code>
</Error>
</SendEmailResponse>";
return new MockResponse($xml, [
'http_code' => 418,
]);
});
$transport = new SesApiTransport('ACCESS_KEY', 'SECRET_KEY', null, $client);
$transport->setPort(8984);
$mail = new Email();
$mail->subject('Hello!')
->to(new Address('[email protected]', 'Saif Eddin'))
->from(new Address('[email protected]', 'Fabien'))
->text('Hello There!');
$this->expectException(HttpTransportException::class);
$this->expectExceptionMessage('Unable to send an email: i\'m a teapot (code 418).');
$transport->send($mail);
}
}
| mit |
iobeam/plottable | quicktests/overlaying/tests/functional/formatter.js | 3212 | function makeData() {
"use strict";
return [makeRandomData(10), makeRandomData(10)];
}
function run(svg, data, Plottable) {
"use strict";
var largeX = function(d, i){
d.x = Math.pow(10, i);
};
var bigNumbers = [];
deepCopy(data[0], bigNumbers);
bigNumbers.forEach(largeX);
var dataseries1 = new Plottable.Dataset(bigNumbers);
//Axis
var xScale = new Plottable.Scales.Linear();
var yScale = new Plottable.Scales.Linear();
var xAxis = new Plottable.Axes.Numeric(xScale, "bottom");
var yAxis = new Plottable.Axes.Numeric(yScale, "left");
var IdTitle = new Plottable.Components.Label("Identity");
var GenTitle = new Plottable.Components.Label("General");
var FixTitle = new Plottable.Components.Label("Fixed");
var CurrTitle = new Plottable.Components.Label("Currency");
var PerTitle = new Plottable.Components.Label("Percentage");
var SITitle = new Plottable.Components.Label("SI");
var SSTitle = new Plottable.Components.Label("Short Scale");
var plot = new Plottable.Plots.Line().addDataset(dataseries1);
plot.x(function(d) { return d.x; }, xScale).y(function(d) { return d.y; }, yScale);
var basicTable = new Plottable.Components.Table([[yAxis, plot], [null, xAxis]]);
var formatChoices = new Plottable.Components.Table([[IdTitle, GenTitle, FixTitle], [CurrTitle, null, PerTitle], [SITitle, null, SSTitle]]);
var bigTable = new Plottable.Components.Table([[basicTable], [formatChoices]]);
formatChoices.xAlignment("center");
bigTable.renderTo(svg);
function useIdentityFormatter() {
xAxis.formatter(Plottable.Formatters.identity(2.1));
yAxis.formatter(Plottable.Formatters.identity());
}
function useGeneralFormatter() {
xAxis.formatter(Plottable.Formatters.general(7));
yAxis.formatter(Plottable.Formatters.general(3));
}
function useFixedFormatter() {
xAxis.formatter(Plottable.Formatters.fixed(2.00));
yAxis.formatter(Plottable.Formatters.fixed(7.00));
}
function useCurrencyFormatter() {
xAxis.formatter(Plottable.Formatters.currency(3, "$", true));
yAxis.formatter(Plottable.Formatters.currency(3, "$", true));
}
function usePercentageFormatter() {
xAxis.formatter(Plottable.Formatters.percentage(12.3 - 11.3));
yAxis.formatter(Plottable.Formatters.percentage(2.5 + 1.5));
}
function useSIFormatter() {
xAxis.formatter(Plottable.Formatters.siSuffix(7));
yAxis.formatter(Plottable.Formatters.siSuffix(14));
}
function useSSFormatter() {
xAxis.formatter(Plottable.Formatters.shortScale(0));
yAxis.formatter(Plottable.Formatters.shortScale(0));
}
new Plottable.Interactions.Click().onClick(useIdentityFormatter).attachTo(IdTitle);
new Plottable.Interactions.Click().onClick(useGeneralFormatter).attachTo(GenTitle);
new Plottable.Interactions.Click().onClick(useFixedFormatter).attachTo(FixTitle);
new Plottable.Interactions.Click().onClick(useCurrencyFormatter).attachTo(CurrTitle);
new Plottable.Interactions.Click().onClick(usePercentageFormatter).attachTo(PerTitle);
new Plottable.Interactions.Click().onClick(useSIFormatter).attachTo(SITitle);
new Plottable.Interactions.Click().onClick(useSSFormatter).attachTo(SSTitle);
}
| mit |
FleetingClouds/Letterpress | server/api/webhooks-api.js | 187 | JsonRoutes.add('post', '/' + Meteor.settings.private.stripe.webhookEndpoint, function (req, res) {
Letterpress.Services.Buy.handleEvent(req.body);
JsonRoutes.sendResult(res, 200);
}); | mit |
rishigb/NodeProject_IOTstyle | socketIo/VideoLiveStreamSockets/node_modules/exprestify/node_modules/pem/lib/pem.js | 24288 | 'use strict';
var spawn = require('child_process').spawn;
var os = require('os');
var pathlib = require('path');
var fs = require('fs');
var net = require('net');
var crypto = require('crypto');
var which = require('which');
var pathOpenSSL;
var tempDir = process.env.PEMJS_TMPDIR || (os.tmpdir || os.tmpDir) && (os.tmpdir || os.tmpDir)() || '/tmp';
module.exports.createPrivateKey = createPrivateKey;
module.exports.createDhparam = createDhparam;
module.exports.createCSR = createCSR;
module.exports.createCertificate = createCertificate;
module.exports.readCertificateInfo = readCertificateInfo;
module.exports.getPublicKey = getPublicKey;
module.exports.getFingerprint = getFingerprint;
module.exports.getModulus = getModulus;
module.exports.config = config;
// PUBLIC API
/**
* Creates a private key
*
* @param {Number} [keyBitsize=2048] Size of the key, defaults to 2048bit
* @param {Object} [options] object of cipher and password {cipher:'aes128',password:'xxx'}, defaults empty object
* @param {Function} callback Callback function with an error object and {key}
*/
function createPrivateKey(keyBitsize, options, callback) {
var clientKeyPassword;
if (!callback && !options && typeof keyBitsize === 'function') {
callback = keyBitsize;
keyBitsize = undefined;
options = {};
}
else if (!callback && keyBitsize && typeof options === 'function') {
callback = options;
options = {};
}
keyBitsize = Number(keyBitsize) || 2048;
var params = ['genrsa',
'-rand',
'/var/log/mail:/var/log/messages'
];
var cipher = ["aes128", "aes192", "aes256", "camellia128", "camellia192", "camellia256", "des", "des3", "idea"];
if (options && options.cipher && ( -1 !== Number(cipher.indexOf(options.cipher)) ) && options.password){
clientKeyPassword = pathlib.join(tempDir, crypto.randomBytes(20).toString('hex'));
fs.writeFileSync(clientKeyPassword, options.password);
params.push( '-' + options.cipher );
params.push( '-passout' );
params.push( 'file:' + clientKeyPassword );
}
params.push(keyBitsize);
execOpenSSL(params, 'RSA PRIVATE KEY', function(error, key) {
if(clientKeyPassword) {
fs.unlink(clientKeyPassword);
}
if (error) {
return callback(error);
}
return callback(null, {
key: key
});
});
}
/**
* Creates a dhparam key
*
* @param {Number} [keyBitsize=512] Size of the key, defaults to 512bit
* @param {Function} callback Callback function with an error object and {dhparam}
*/
function createDhparam(keyBitsize, callback) {
if (!callback && typeof keyBitsize === 'function') {
callback = keyBitsize;
keyBitsize = undefined;
}
keyBitsize = Number(keyBitsize) || 512;
var params = ['dhparam',
'-outform',
'PEM',
keyBitsize
];
execOpenSSL(params, 'DH PARAMETERS', function(error, dhparam) {
if (error) {
return callback(error);
}
return callback(null, {
dhparam: dhparam
});
});
}
/**
* Creates a Certificate Signing Request
*
* If client key is undefined, a new key is created automatically. The used key is included
* in the callback return as clientKey
*
* @param {Object} [options] Optional options object
* @param {String} [options.clientKey] Optional client key to use
* @param {Number} [options.keyBitsize] If clientKey is undefined, bit size to use for generating a new key (defaults to 2048)
* @param {String} [options.hash] Hash function to use (either md5 sha1 or sha256, defaults to sha256)
* @param {String} [options.country] CSR country field
* @param {String} [options.state] CSR state field
* @param {String} [options.locality] CSR locality field
* @param {String} [options.organization] CSR organization field
* @param {String} [options.organizationUnit] CSR organizational unit field
* @param {String} [options.commonName='localhost'] CSR common name field
* @param {String} [options.emailAddress] CSR email address field
* @param {Array} [options.altNames] is a list of subjectAltNames in the subjectAltName field
* @param {Function} callback Callback function with an error object and {csr, clientKey}
*/
function createCSR(options, callback) {
if (!callback && typeof options === 'function') {
callback = options;
options = undefined;
}
options = options || {};
// http://stackoverflow.com/questions/14089872/why-does-node-js-accept-ip-addresses-in-certificates-only-for-san-not-for-cn
if (options.commonName && (net.isIPv4(options.commonName) || net.isIPv6(options.commonName))) {
if (!options.altNames) {
options.altNames = [options.commonName];
} else if (options.altNames.indexOf(options.commonName) === -1) {
options.altNames = options.altNames.concat([options.commonName]);
}
}
if (!options.clientKey) {
createPrivateKey(options.keyBitsize || 2048, function(error, keyData) {
if (error) {
return callback(error);
}
options.clientKey = keyData.key;
createCSR(options, callback);
});
return;
}
var params = ['req',
'-new',
'-' + (options.hash || 'sha256'),
'-subj',
generateCSRSubject(options),
'-key',
'--TMPFILE--'
];
var tmpfiles = [options.clientKey];
var config = null;
if (options.altNames) {
params.push('-extensions');
params.push('v3_req');
params.push('-config');
params.push('--TMPFILE--');
var altNamesRep = [];
for (var i = 0; i < options.altNames.length; i++) {
altNamesRep.push((net.isIP(options.altNames[i]) ? 'IP' : 'DNS') + '.' + (i + 1) + ' = ' + options.altNames[i]);
}
tmpfiles.push(config = [
'[req]',
'req_extensions = v3_req',
'distinguished_name = req_distinguished_name',
'[v3_req]',
'subjectAltName = @alt_names',
'[alt_names]',
altNamesRep.join('\n'),
'[req_distinguished_name]',
'commonName = Common Name',
'commonName_max = 64',
].join('\n'));
}
var passwordFilePath = null;
if (options.clientKeyPassword) {
passwordFilePath = pathlib.join(tempDir, crypto.randomBytes(20).toString('hex'));
fs.writeFileSync(passwordFilePath, options.clientKeyPassword);
params.push('-passin');
params.push('file:' + passwordFilePath);
}
execOpenSSL(params, 'CERTIFICATE REQUEST', tmpfiles, function(error, data) {
if (passwordFilePath) {
fs.unlink(passwordFilePath);
}
if (error) {
return callback(error);
}
var response = {
csr: data,
config: config,
clientKey: options.clientKey
};
return callback(null, response);
});
}
/**
* Creates a certificate based on a CSR. If CSR is not defined, a new one
* will be generated automatically. For CSR generation all the options values
* can be used as with createCSR.
*
* @param {Object} [options] Optional options object
* @param {String} [options.serviceKey] Private key for signing the certificate, if not defined a new one is generated
* @param {Boolean} [options.selfSigned] If set to true and serviceKey is not defined, use clientKey for signing
* @param {String} [options.hash] Hash function to use (either md5 sha1 or sha256, defaults to sha256)
* @param {String} [options.csr] CSR for the certificate, if not defined a new one is generated
* @param {Number} [options.days] Certificate expire time in days
* @param {Function} callback Callback function with an error object and {certificate, csr, clientKey, serviceKey}
*/
function createCertificate(options, callback) {
if (!callback && typeof options === 'function') {
callback = options;
options = undefined;
}
options = options || {};
if (!options.csr) {
createCSR(options, function(error, keyData) {
if (error) {
return callback(error);
}
options.csr = keyData.csr;
options.config = keyData.config;
options.clientKey = keyData.clientKey;
createCertificate(options, callback);
});
return;
}
if (!options.serviceKey) {
if (options.selfSigned) {
options.serviceKey = options.clientKey;
} else {
createPrivateKey(options.keyBitsize || 2048, function(error, keyData) {
if (error) {
return callback(error);
}
options.serviceKey = keyData.key;
createCertificate(options, callback);
});
return;
}
}
var params = ['x509',
'-req',
'-' + (options.hash || 'sha256'),
'-days',
Number(options.days) || '365',
'-in',
'--TMPFILE--'
];
var tmpfiles = [options.csr];
if (options.serviceCertificate) {
if (!options.serial) {
return callback(new Error('serial option required for CA signing'));
}
params.push('-CA');
params.push('--TMPFILE--');
params.push('-CAkey');
params.push('--TMPFILE--');
params.push('-set_serial');
params.push('0x' + ('00000000' + options.serial.toString(16)).slice(-8));
tmpfiles.push(options.serviceCertificate);
tmpfiles.push(options.serviceKey);
} else {
params.push('-signkey');
params.push('--TMPFILE--');
tmpfiles.push(options.serviceKey);
}
if (options.config) {
params.push('-extensions');
params.push('v3_req');
params.push('-extfile');
params.push('--TMPFILE--');
tmpfiles.push(options.config);
}
execOpenSSL(params, 'CERTIFICATE', tmpfiles, function(error, data) {
if (error) {
return callback(error);
}
var response = {
csr: options.csr,
clientKey: options.clientKey,
certificate: data,
serviceKey: options.serviceKey
};
return callback(null, response);
});
}
/**
* Exports a public key from a private key, CSR or certificate
*
* @param {String} certificate PEM encoded private key, CSR or certificate
* @param {Function} callback Callback function with an error object and {publicKey}
*/
function getPublicKey(certificate, callback) {
if (!callback && typeof certificate === 'function') {
callback = certificate;
certificate = undefined;
}
certificate = (certificate || '').toString();
var params;
if (certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)) {
params = ['req',
'-in',
'--TMPFILE--',
'-pubkey',
'-noout'
];
} else if (certificate.match(/BEGIN RSA PRIVATE KEY/)) {
params = ['rsa',
'-in',
'--TMPFILE--',
'-pubout'
];
} else {
params = ['x509',
'-in',
'--TMPFILE--',
'-pubkey',
'-noout'
];
}
execOpenSSL(params, 'PUBLIC KEY', certificate, function(error, key) {
if (error) {
return callback(error);
}
return callback(null, {
publicKey: key
});
});
}
/**
* Reads subject data from a certificate or a CSR
*
* @param {String} certificate PEM encoded CSR or certificate
* @param {Function} callback Callback function with an error object and {country, state, locality, organization, organizationUnit, commonName, emailAddress}
*/
function readCertificateInfo(certificate, callback) {
if (!callback && typeof certificate === 'function') {
callback = certificate;
certificate = undefined;
}
certificate = (certificate || '').toString();
var type = certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/) ? 'req' : 'x509',
params = [type,
'-noout',
'-text',
'-in',
'--TMPFILE--'
];
spawnWrapper(params, certificate, function(err, code, stdout) {
if (err) {
return callback(err);
}
return fetchCertificateData(stdout, callback);
});
}
/**
* get the modulus from a certificate, a CSR or a private key
*
* @param {String} certificate PEM encoded, CSR PEM encoded, or private key
* @param {Function} callback Callback function with an error object and {modulus}
*/
function getModulus(certificate, callback) {
certificate = Buffer.isBuffer(certificate) && certificate.toString() || certificate;
var type = '';
if (certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)) {
type = 'req';
} else if (certificate.match(/BEGIN RSA PRIVATE KEY/)) {
type = 'rsa';
} else {
type = 'x509';
}
var params = [type,
'-noout',
'-modulus',
'-in',
'--TMPFILE--'
];
spawnWrapper(params, certificate, function(err, code, stdout) {
if (err) {
return callback(err);
}
var match = stdout.match(/Modulus=([0-9a-fA-F]+)$/m);
if (match) {
return callback(null, {
modulus: match[1]
});
} else {
return callback(new Error('No modulus'));
}
});
}
/**
* config the pem module
* @param {Object} options
*/
function config(options) {
if (options.pathOpenSSL) {
pathOpenSSL = options.pathOpenSSL;
}
}
/**
* Gets the fingerprint for a certificate
*
* @param {String} PEM encoded certificate
* @param {Function} callback Callback function with an error object and {fingerprint}
*/
function getFingerprint(certificate, hash, callback) {
if (!callback && typeof hash === 'function') {
callback = hash;
hash = undefined;
}
hash = hash || 'sha1';
var params = ['x509',
'-in',
'--TMPFILE--',
'-fingerprint',
'-noout',
'-' + hash
];
spawnWrapper(params, certificate, function(err, code, stdout) {
if (err) {
return callback(err);
}
var match = stdout.match(/Fingerprint=([0-9a-fA-F:]+)$/m);
if (match) {
return callback(null, {
fingerprint: match[1]
});
} else {
return callback(new Error('No fingerprint'));
}
});
}
// HELPER FUNCTIONS
function fetchCertificateData(certData, callback) {
certData = (certData || '').toString();
var subject, subject2, extra, tmp, certValues = {};
var validity = {};
var san;
if ((subject = certData.match(/Subject:([^\n]*)\n/)) && subject.length > 1) {
subject2 = linebrakes(subject[1] + '\n');
subject = subject[1];
extra = subject.split('/');
subject = extra.shift() + '\n';
extra = extra.join('/') + '\n';
// country
tmp = subject2.match(/\sC=([^\n].*?)[\n]/);
certValues.country = tmp && tmp[1] || '';
// state
tmp = subject2.match(/\sST=([^\n].*?)[\n]/);
certValues.state = tmp && tmp[1] || '';
// locality
tmp = subject2.match(/\sL=([^\n].*?)[\n]/);
certValues.locality = tmp && tmp[1] || '';
// organization
tmp = subject2.match(/\sO=([^\n].*?)[\n]/);
certValues.organization = tmp && tmp[1] || '';
// unit
tmp = subject2.match(/\sOU=([^\n].*?)[\n]/);
certValues.organizationUnit = tmp && tmp[1] || '';
// common name
tmp = subject2.match(/\sCN=([^\n].*?)[\n]/);
certValues.commonName = tmp && tmp[1] || '';
//email
tmp = extra.match(/emailAddress=([^\n\/].*?)[\n\/]/);
certValues.emailAddress = tmp && tmp[1] || '';
}
if ((san = certData.match(/X509v3 Subject Alternative Name: \n([^\n]*)\n/)) && san.length > 1) {
san = san[1].trim() + '\n';
certValues.san = {};
// country
tmp = preg_match_all('DNS:([^,\\n].*?)[,\\n]', san);
certValues.san.dns = tmp || '';
// country
tmp = preg_match_all('IP Address:([^,\\n].*?)[,\\n\\s]', san);
certValues.san.ip = tmp || '';
}
if ((tmp = certData.match(/Not Before\s?:\s?([^\n]*)\n/)) && tmp.length > 1) {
validity.start = Date.parse(tmp && tmp[1] || '');
}
if ((tmp = certData.match(/Not After\s?:\s?([^\n]*)\n/)) && tmp.length > 1) {
validity.end = Date.parse(tmp && tmp[1] || '');
}
if (validity.start && validity.end) {
certValues.validity = validity;
}
callback(null, certValues);
}
function linebrakes(content) {
var helper_x, p, subject;
helper_x = content.replace(/(C|L|O|OU|ST|CN)=/g, '\n$1=');
helper_x = preg_match_all('((C|L|O|OU|ST|CN)=[^\n].*)', helper_x);
for (p in helper_x) {
subject = helper_x[p].trim();
content = subject.split('/');
subject = content.shift();
helper_x[p] = rtrim(subject, ',');
}
return ' ' + helper_x.join('\n') + '\n';
}
function rtrim(str, charlist) {
charlist = !charlist ? ' \\s\u00A0' : (charlist + '')
.replace(/([\[\]\(\)\.\?\/\*\{\}\+\$\^\:])/g, '\\$1');
var re = new RegExp('[' + charlist + ']+$', 'g');
return (str + '')
.replace(re, '');
}
function preg_match_all(regex, haystack) {
var globalRegex = new RegExp(regex, 'g');
var globalMatch = haystack.match(globalRegex);
var matchArray = [],
nonGlobalRegex, nonGlobalMatch;
for (var i in globalMatch) {
nonGlobalRegex = new RegExp(regex);
nonGlobalMatch = globalMatch[i].match(nonGlobalRegex);
matchArray.push(nonGlobalMatch[1]);
}
return matchArray;
}
function generateCSRSubject(options) {
options = options || {};
var csrData = {
C: options.country || options.C || '',
ST: options.state || options.ST || '',
L: options.locality || options.L || '',
O: options.organization || options.O || '',
OU: options.organizationUnit || options.OU || '',
CN: options.commonName || options.CN || 'localhost',
emailAddress: options.emailAddress || ''
},
csrBuilder = [];
Object.keys(csrData).forEach(function(key) {
if (csrData[key]) {
csrBuilder.push('/' + key + '=' + csrData[key].replace(/[^\w \.\*\-@]+/g, ' ').trim());
}
});
return csrBuilder.join('');
}
/**
* Generically spawn openSSL, without processing the result
*
* @param {Array} params The parameters to pass to openssl
* @param {String|Array} tmpfiles Stuff to pass to tmpfiles
* @param {Function} callback Called with (error, exitCode, stdout, stderr)
*/
function spawnOpenSSL(params, callback) {
var pathBin = pathOpenSSL || process.env.OPENSSL_BIN || 'openssl';
testOpenSSLPath(pathBin, function(err) {
if (err) {
return callback(err);
}
var openssl = spawn(pathBin, params),
stdout = '',
stderr = '';
openssl.stdout.on('data', function(data) {
stdout += (data || '').toString('binary');
});
openssl.stderr.on('data', function(data) {
stderr += (data || '').toString('binary');
});
// We need both the return code and access to all of stdout. Stdout isn't
// *really* available until the close event fires; the timing nuance was
// making this fail periodically.
var needed = 2; // wait for both exit and close.
var code = -1;
var finished = false;
var done = function(err) {
if (finished) {
return;
}
if (err) {
finished = true;
return callback(err);
}
if (--needed < 1) {
finished = true;
if (code) {
callback(new Error('Invalid openssl exit code: ' + code + '\n% openssl ' + params.join(' ') + '\n' + stderr), code);
} else {
callback(null, code, stdout, stderr);
}
}
};
openssl.on('error', done);
openssl.on('exit', function(ret) {
code = ret;
done();
});
openssl.on('close', function() {
stdout = new Buffer(stdout, 'binary').toString('utf-8');
stderr = new Buffer(stderr, 'binary').toString('utf-8');
done();
});
});
}
function spawnWrapper(params, tmpfiles, callback) {
var files = [];
var toUnlink = [];
if (tmpfiles) {
tmpfiles = [].concat(tmpfiles || []);
params.forEach(function(value, i) {
var fpath;
if (value === '--TMPFILE--') {
fpath = pathlib.join(tempDir, crypto.randomBytes(20).toString('hex'));
files.push({
path: fpath,
contents: tmpfiles.shift()
});
params[i] = fpath;
}
});
}
var processFiles = function() {
var file = files.shift();
if (!file) {
return spawnSSL();
}
fs.writeFile(file.path, file.contents, function() {
toUnlink.push(file.path);
processFiles();
});
};
var spawnSSL = function() {
spawnOpenSSL(params, function(err, code, stdout, stderr) {
toUnlink.forEach(function(filePath) {
fs.unlink(filePath);
});
callback(err, code, stdout, stderr);
});
};
processFiles();
}
/**
* Spawn an openssl command
*/
function execOpenSSL(params, searchStr, tmpfiles, callback) {
if (!callback && typeof tmpfiles === 'function') {
callback = tmpfiles;
tmpfiles = false;
}
spawnWrapper(params, tmpfiles, function(err, code, stdout, stderr) {
var start, end;
if (err) {
return callback(err);
}
if ((start = stdout.match(new RegExp('\\-+BEGIN ' + searchStr + '\\-+$', 'm')))) {
start = start.index;
} else {
start = -1;
}
if ((end = stdout.match(new RegExp('^\\-+END ' + searchStr + '\\-+', 'm')))) {
end = end.index + (end[0] || '').length;
} else {
end = -1;
}
if (start >= 0 && end >= 0) {
return callback(null, stdout.substring(start, end));
} else {
return callback(new Error(searchStr + ' not found from openssl output:\n---stdout---\n' + stdout + '\n---stderr---\n' + stderr + '\ncode: ' + code));
}
});
}
/**
* Validates the pathBin for the openssl command.
*
* @param {String} pathBin The path to OpenSSL Bin
* @param {Function} callback Callback function with an error object
*/
function testOpenSSLPath(pathBin, callback) {
which(pathBin, function(error) {
if (error) {
return callback(new Error('Could not find openssl on your system on this path: ' + pathBin));
}
callback();
});
} | mit |
jconst/SoundDrop | SoundDrop/libpd/objc/PdDispatcher.h | 1537 | //
// PdDispatcher.h
// libpd
//
// Copyright (c) 2011 Peter Brinkmann ([email protected])
//
// For information on usage and redistribution, and for a DISCLAIMER OF ALL
// WARRANTIES, see the file, "LICENSE.txt," in this distribution.
//
#import <Foundation/Foundation.h>
#import "PdBase.h"
/// Implementation of the PdReceiverDelegate protocol from PdBase.h. Client code
/// registers one instance of this class with PdBase, and then listeners for individual
/// sources will be registered with the dispatcher object.
///
/// Printing from Pd is done via NSLog by default; subclass and override the receivePrint
/// method if you want different printing behavior.
@interface PdDispatcher : NSObject<PdReceiverDelegate> {
NSMutableDictionary *listenerMap;
NSMutableDictionary *subscriptions;
}
/// Adds a listener for the given source (i.e., send symbol) in Pd. If this is the first
/// listener for this source, a subscription for this symbol will automatically be registered
/// with PdBase.
- (int)addListener:(NSObject<PdListener> *)listener forSource:(NSString *)source;
/// Removes a listener for a source symbol and unsubscribes from messages to this symbol if
/// the listener was the last listener for this symbol.
- (int)removeListener:(NSObject<PdListener> *)listener forSource:(NSString *)source;
/// Removes all listeners.
- (void)removeAllListeners;
@end
/// Subclass of PdDispatcher that logs all callbacks, mostly for development and debugging.
@interface LoggingDispatcher : PdDispatcher {}
@end
| mit |
neos/eel | Tests/Unit/Helper/DateHelperTest.php | 7259 | <?php
namespace Neos\Eel\Tests\Unit;
/*
* This file is part of the Neos.Eel package.
*
* (c) Contributors of the Neos Project - www.neos.io
*
* This package is Open Source Software. For the full copyright and license
* information, please view the LICENSE file which was distributed with this
* source code.
*/
use Neos\Eel\Helper\DateHelper;
use Neos\Flow\I18n\Locale;
/**
* Tests for DateHelper
*/
class DateHelperTest extends \Neos\Flow\Tests\UnitTestCase
{
/**
* @return array
*/
public function parseExamples()
{
$date = \DateTime::createFromFormat('Y-m-d', '2013-07-03');
$dateTime = \DateTime::createFromFormat('Y-m-d H:i:s', '2013-07-03 12:34:56');
return [
'basic date' => ['2013-07-03', 'Y-m-d', $date],
'date with time' => ['2013-07-03 12:34:56', 'Y-m-d H:i:s', $dateTime]
];
}
/**
* @test
* @dataProvider parseExamples
*/
public function parseWorks($string, $format, $expected)
{
$helper = new DateHelper();
$result = $helper->parse($string, $format);
self::assertInstanceOf(\DateTime::class, $result);
self::assertEqualsWithDelta((float)$expected->format('U'), (float)$result->format('U'), 60, 'Timestamps should match');
}
/**
* @return array
*/
public function formatExamples()
{
$dateTime = \DateTime::createFromFormat('Y-m-d H:i:s', '2013-07-03 12:34:56');
return [
'DateTime object' => [$dateTime, 'Y-m-d H:i:s', '2013-07-03 12:34:56'],
'timestamp as integer' => [1372856513, 'Y-m-d', '2013-07-03'],
'now' => ['now', 'Y-m-d', date('Y-m-d')],
'interval' => [new \DateInterval('P1D'), '%d days', '1 days']
];
}
/**
* @test
* @dataProvider formatExamples
*/
public function formatWorks($dateOrString, $format, $expected)
{
$helper = new DateHelper();
$result = $helper->format($dateOrString, $format);
self::assertSame($expected, $result);
}
/**
* @test
*/
public function formatCldrThrowsOnEmptyArguments()
{
$this->expectException(\InvalidArgumentException::class);
$helper = new DateHelper();
$helper->formatCldr(null, null);
}
/**
* @test
*/
public function formatCldrWorksWithEmptyLocale()
{
$locale = new Locale('en');
$expected = 'whatever-value';
$configurationMock = $this->createMock(\Neos\Flow\I18n\Configuration::class);
$configurationMock->expects(self::atLeastOnce())->method('getCurrentLocale')->willReturn($locale);
$localizationServiceMock = $this->createMock(\Neos\Flow\I18n\Service::class);
$localizationServiceMock->expects(self::atLeastOnce())->method('getConfiguration')->willReturn($configurationMock);
$formatMock = $this->createMock(\Neos\Flow\I18n\Formatter\DatetimeFormatter::class);
$formatMock->expects(self::atLeastOnce())->method('formatDateTimeWithCustomPattern')->willReturn($expected);
$helper = new DateHelper();
$this->inject($helper, 'datetimeFormatter', $formatMock);
$this->inject($helper, 'localizationService', $localizationServiceMock);
$date = \DateTime::createFromFormat('Y-m-d H:i:s', '2013-07-03 12:34:56');
$format = 'whatever-format';
$helper->formatCldr($date, $format);
}
/**
* @test
*/
public function formatCldrCallsFormatService()
{
$date = \DateTime::createFromFormat('Y-m-d H:i:s', '2013-07-03 12:34:56');
$format = 'whatever-format';
$locale = 'en';
$expected = '2013-07-03 12:34:56';
$formatMock = $this->createMock(\Neos\Flow\I18n\Formatter\DatetimeFormatter::class);
$formatMock->expects(self::atLeastOnce())->method('formatDateTimeWithCustomPattern');
$helper = new DateHelper();
$this->inject($helper, 'datetimeFormatter', $formatMock);
$helper->formatCldr($date, $format, $locale);
}
/**
* @test
*/
public function nowWorks()
{
$helper = new DateHelper();
$result = $helper->now();
self::assertInstanceOf(\DateTime::class, $result);
self::assertEqualsWithDelta(time(), (integer)$result->format('U'), 1, 'Now should be now');
}
/**
* @test
*/
public function createWorks()
{
$helper = new DateHelper();
$result = $helper->create('yesterday noon');
$expected = new \DateTime('yesterday noon');
self::assertInstanceOf(\DateTime::class, $result);
self::assertEqualsWithDelta($expected->getTimestamp(), $result->getTimestamp(), 1, 'Created DateTime object should match expected');
}
/**
* @test
*/
public function todayWorks()
{
$helper = new DateHelper();
$result = $helper->today();
self::assertInstanceOf(\DateTime::class, $result);
$today = new \DateTime('today');
self::assertEqualsWithDelta($today->getTimestamp(), $result->getTimestamp(), 1, 'Today should be today');
}
/**
* @return array
*/
public function calculationExamples()
{
$dateTime = \DateTime::createFromFormat('Y-m-d H:i:s', '2013-07-03 12:34:56');
return [
'add DateTime with DateInterval' => ['add', $dateTime, new \DateInterval('P1D'), '2013-07-04 12:34:56'],
'add DateTime with string' => ['add', $dateTime, 'P1D', '2013-07-04 12:34:56'],
'subtract DateTime with DateInterval' => ['subtract', $dateTime, new \DateInterval('P1D'), '2013-07-02 12:34:56'],
'subtract DateTime with string' => ['subtract', $dateTime, 'P1D', '2013-07-02 12:34:56'],
];
}
/**
* @test
* @dataProvider calculationExamples
*/
public function calculationWorks($method, $dateTime, $interval, $expected)
{
$timestamp = $dateTime->getTimestamp();
$helper = new DateHelper();
$result = $helper->$method($dateTime, $interval);
self::assertEquals($timestamp, $dateTime->getTimeStamp(), 'DateTime should not be modified');
self::assertEquals($expected, $result->format('Y-m-d H:i:s'));
}
/**
* @test
*/
public function diffWorks()
{
$earlierTime = \DateTime::createFromFormat('Y-m-d H:i:s', '2013-07-03 12:34:56');
$futureTime = \DateTime::createFromFormat('Y-m-d H:i:s', '2013-07-10 12:33:56');
$helper = new DateHelper();
$result = $helper->diff($earlierTime, $futureTime);
self::assertEquals(6, $result->d);
self::assertEquals(23, $result->h);
self::assertEquals(59, $result->i);
}
/**
* @test
*/
public function dateAccessorsWork()
{
$helper = new DateHelper();
$date = new \DateTime('2013-10-16 14:59:27');
self::assertSame(2013, $helper->year($date));
self::assertSame(10, $helper->month($date));
self::assertSame(16, $helper->dayOfMonth($date));
self::assertSame(14, $helper->hour($date));
self::assertSame(59, $helper->minute($date));
self::assertSame(27, $helper->second($date));
}
}
| mit |
mseroczynski/platformio | scripts/mbed_to_package.py | 3667 | # Copyright (C) Ivan Kravets <[email protected]>
# See LICENSE for details.
import argparse
import zipfile
from os import getcwd, listdir, makedirs, mkdir, rename
from os.path import isdir, isfile, join
from shutil import move, rmtree
from sys import exit as sys_exit
from sys import path
path.append("..")
from platformio.util import exec_command, get_home_dir
def _unzip_generated_file(mbed_dir, output_dir, mcu):
filename = join(
mbed_dir, "build", "export", "MBED_A1_emblocks_%s.zip" % mcu)
variant_dir = join(output_dir, "variant", mcu)
if isfile(filename):
with zipfile.ZipFile(filename) as zfile:
mkdir(variant_dir)
zfile.extractall(variant_dir)
for f in listdir(join(variant_dir, "MBED_A1")):
if not f.lower().startswith("mbed"):
continue
move(join(variant_dir, "MBED_A1", f), variant_dir)
rename(join(variant_dir, "MBED_A1.eix"),
join(variant_dir, "%s.eix" % mcu))
rmtree(join(variant_dir, "MBED_A1"))
else:
print "Warning! Skipped board: %s" % mcu
def buildlib(mbed_dir, mcu, lib="mbed"):
build_command = [
"python",
join(mbed_dir, "workspace_tools", "build.py"),
"--mcu", mcu,
"-t", "GCC_ARM"
]
if lib is not "mbed":
build_command.append(lib)
build_result = exec_command(build_command, cwd=getcwd())
if build_result['returncode'] != 0:
print "* %s doesn't support %s library!" % (mcu, lib)
def copylibs(mbed_dir, output_dir):
libs = ["dsp", "fat", "net", "rtos", "usb", "usb_host"]
libs_dir = join(output_dir, "libs")
makedirs(libs_dir)
print "Moving generated libraries to framework dir..."
for lib in libs:
if lib == "net":
move(join(mbed_dir, "build", lib, "eth"), libs_dir)
continue
move(join(mbed_dir, "build", lib), libs_dir)
def main(mbed_dir, output_dir):
print "Starting..."
path.append(mbed_dir)
from workspace_tools.export import gccarm
if isdir(output_dir):
print "Deleting previous framework dir..."
rmtree(output_dir)
settings_file = join(mbed_dir, "workspace_tools", "private_settings.py")
if not isfile(settings_file):
with open(settings_file, "w") as f:
f.write("GCC_ARM_PATH = '%s'" %
join(get_home_dir(), "packages", "toolchain-gccarmnoneeabi",
"bin"))
makedirs(join(output_dir, "variant"))
mbed_libs = ["--rtos", "--dsp", "--fat", "--eth", "--usb", "--usb_host"]
for mcu in set(gccarm.GccArm.TARGETS):
print "Processing board: %s" % mcu
buildlib(mbed_dir, mcu)
for lib in mbed_libs:
buildlib(mbed_dir, mcu, lib)
result = exec_command(
["python", join(mbed_dir, "workspace_tools", "project.py"),
"--mcu", mcu, "-i", "emblocks", "-p", "0", "-b"], cwd=getcwd()
)
if result['returncode'] != 0:
print "Unable to build the project for %s" % mcu
continue
_unzip_generated_file(mbed_dir, output_dir, mcu)
copylibs(mbed_dir, output_dir)
with open(join(output_dir, "boards.txt"), "w") as fp:
fp.write("\n".join(sorted(listdir(join(output_dir, "variant")))))
print "Complete!"
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('--mbed', help="The path to mbed framework")
parser.add_argument('--output', help="The path to output directory")
args = vars(parser.parse_args())
sys_exit(main(args["mbed"], args["output"]))
| mit |
jaromirdalecky/concrete5 | concrete/src/Attribute/AttributeKeyInterface.php | 678 | <?php
namespace Concrete\Core\Attribute;
use Concrete\Core\Attribute\Key\SearchIndexer\SearchIndexerInterface;
interface AttributeKeyInterface
{
/**
* @return int
*/
public function getAttributeKeyID();
/**
* @return string
*/
public function getAttributeKeyHandle();
/**
* @return \Concrete\Core\Entity\Attribute\Type
*/
public function getAttributeType();
/**
* @return bool
*/
public function isAttributeKeySearchable();
/**
* @return SearchIndexerInterface
*/
public function getSearchIndexer();
/**
* @return Controller
*/
public function getController();
}
| mit |
newvem/pytz | pytz/zoneinfo/GMT_minus_0.py | 367 | '''tzinfo timezone information for GMT_minus_0.'''
from pytz.tzinfo import StaticTzInfo
from pytz.tzinfo import memorized_timedelta as timedelta
class GMT_minus_0(StaticTzInfo):
'''GMT_minus_0 timezone definition. See datetime.tzinfo for details'''
zone = 'GMT_minus_0'
_utcoffset = timedelta(seconds=0)
_tzname = 'GMT'
GMT_minus_0 = GMT_minus_0()
| mit |
DevKhater/symfony2-testing | vendor/namshi/jose/tests/bootstrap.php | 200 | <?php
$loader = require __DIR__.'/../vendor/autoload.php';
$loader->add('Namshi\\JOSE\\Test', __DIR__);
define('TEST_DIR', __DIR__);
define('SSL_KEYS_PATH', 'file://'.TEST_DIR.DIRECTORY_SEPARATOR);
| mit |
yugangw-msft/azure-cli | src/azure-cli/azure/cli/command_modules/cdn/tests/latest/test_nodes_scenarios.py | 543 | # --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# --------------------------------------------------------------------------------------------
from azure.cli.testsdk import ScenarioTest
class CdnEdgeNodecenarioTest(ScenarioTest):
def test_edge_node_crud(self):
self.cmd('cdn edge-node list', checks=self.check('length(@)', 3))
| mit |
mpdude/symfony | src/Symfony/Component/Lock/Tests/Store/AbstractRedisStoreTest.php | 3693 | <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <[email protected]>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Lock\Tests\Store;
use Symfony\Component\Cache\Traits\RedisClusterProxy;
use Symfony\Component\Cache\Traits\RedisProxy;
use Symfony\Component\Lock\Exception\InvalidArgumentException;
use Symfony\Component\Lock\Exception\LockConflictedException;
use Symfony\Component\Lock\Key;
use Symfony\Component\Lock\PersistingStoreInterface;
use Symfony\Component\Lock\Store\RedisStore;
/**
* @author Jérémy Derussé <[email protected]>
*/
abstract class AbstractRedisStoreTest extends AbstractStoreTest
{
use ExpiringStoreTestTrait;
/**
* {@inheritdoc}
*/
protected function getClockDelay()
{
return 250000;
}
abstract protected function getRedisConnection(): \Redis|\RedisArray|\RedisCluster|\Predis\ClientInterface;
/**
* {@inheritdoc}
*/
public function getStore(): PersistingStoreInterface
{
return new RedisStore($this->getRedisConnection());
}
public function testBackwardCompatibility()
{
$resource = uniqid(__METHOD__, true);
$key1 = new Key($resource);
$key2 = new Key($resource);
$oldStore = new Symfony51Store($this->getRedisConnection());
$newStore = $this->getStore();
$oldStore->save($key1);
$this->assertTrue($oldStore->exists($key1));
$this->expectException(LockConflictedException::class);
$newStore->save($key2);
}
}
class Symfony51Store
{
private $redis;
public function __construct($redis)
{
$this->redis = $redis;
}
public function save(Key $key)
{
$script = '
if redis.call("GET", KEYS[1]) == ARGV[1] then
return redis.call("PEXPIRE", KEYS[1], ARGV[2])
elseif redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2]) then
return 1
else
return 0
end
';
if (!$this->evaluate($script, (string) $key, [$this->getUniqueToken($key), (int) ceil(5 * 1000)])) {
throw new LockConflictedException();
}
}
public function exists(Key $key)
{
return $this->redis->get((string) $key) === $this->getUniqueToken($key);
}
private function evaluate(string $script, string $resource, array $args)
{
if (
$this->redis instanceof \Redis ||
$this->redis instanceof \RedisCluster ||
$this->redis instanceof RedisProxy ||
$this->redis instanceof RedisClusterProxy
) {
return $this->redis->eval($script, array_merge([$resource], $args), 1);
}
if ($this->redis instanceof \RedisArray) {
return $this->redis->_instance($this->redis->_target($resource))->eval($script, array_merge([$resource], $args), 1);
}
if ($this->redis instanceof \Predis\ClientInterface) {
return $this->redis->eval(...array_merge([$script, 1, $resource], $args));
}
throw new InvalidArgumentException(sprintf('"%s()" expects being initialized with a Redis, RedisArray, RedisCluster or Predis\ClientInterface, "%s" given.', __METHOD__, get_debug_type($this->redis)));
}
private function getUniqueToken(Key $key): string
{
if (!$key->hasState(__CLASS__)) {
$token = base64_encode(random_bytes(32));
$key->setState(__CLASS__, $token);
}
return $key->getState(__CLASS__);
}
}
| mit |
jbthibeault/plymouth-webapp | lib/PSU/Student/Finaid/Application/Factory.php | 1109 | <?php
class PSU_Student_Finaid_Application_Factory {
public function fetch_by_pidm_aidy_seqno( $pidm, $aidy, $seqno ) {
$args = array(
'pidm' => $pidm,
'aidy' => $aidy,
'seqno' => $seqno,
);
$where = array(
'rcrapp1_pidm = :pidm',
'rcrapp1_aidy_code = :aidy',
'rcrapp1_seq_no = :seqno',
);
$rset = $this->query( $args, $where );
return new PSU_Student_Finaid_Application( $rset );
}
public function query( $args, $where = array() ) {
$where[] = '1=1';
$where_sql = ' AND ' . implode( ' AND ', $where );
$sql = "
SELECT
rcrapp4_fath_ssn, rcrapp4_fath_last_name, rcrapp4_fath_first_name_ini, rcrapp4_fath_birth_date,
rcrapp4_moth_ssn, rcrapp4_moth_last_name, rcrapp4_moth_first_name_ini, rcrapp4_moth_birth_date
FROM
rcrapp1 LEFT JOIN rcrapp4 ON
rcrapp1_aidy_code = rcrapp4_aidy_code AND
rcrapp1_pidm = rcrapp4_pidm AND
rcrapp1_infc_code = rcrapp4_infc_code AND
rcrapp1_seq_no = rcrapp4_seq_no
WHERE
rcrapp1_infc_code = 'EDE'
$where_sql
";
$rset = PSU::db('banner')->GetRow( $sql, $args );
return $rset;
}
}
| mit |
ankushrgv/tollbooth-management-system | tb_management1/laxmi/includes/head_recharge.php | 1662 | <head>
<meta charset=utf-8>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Recharge</title>
<!-- Load Roboto font -->
<link href='http://fonts.googleapis.com/css?family=Roboto:400,300,700&subset=latin,latin-ext' rel='stylesheet' type='text/css'>
<!-- Load css styles -->
<link rel="stylesheet" type="text/css" href="css/bootstrap.css" />
<link rel="stylesheet" type="text/css" href="css/bootstrap-responsive.css" />
<link rel="stylesheet" type="text/css" href="css/stylemain_tb.css" />
<link rel="stylesheet" type="text/css" href="css/pluton.css" />
<link rel="stylesheet" type="text/css" href="css/style1_payment_portal.css" />
<!--[if IE 7]>
<link rel="stylesheet" type="text/css" href="css/pluton-ie7.css" />
<![endif]-->
<link rel="stylesheet" type="text/css" href="css/jquery.cslider_tb.css" />
<link rel="stylesheet" type="text/css" href="css/jquery.bxslider.css" />
<link rel="stylesheet" type="text/css" href="css/animate.css" />
<!-- Fav and touch icons -->
<link rel="apple-touch-icon-precomposed" sizes="144x144" href="images/ico/apple-touch-icon-144.png">
<link rel="apple-touch-icon-precomposed" sizes="114x114" href="images/ico/apple-touch-icon-114.png">
<link rel="apple-touch-icon-precomposed" sizes="72x72" href="images/apple-touch-icon-72.png">
<link rel="apple-touch-icon-precomposed" href="images/ico/apple-touch-icon-57.png">
<link rel="shortcut icon" href="images/ico/favicon.ico">
</head> | mit |
derrabus/symfony | src/Symfony/Component/Intl/Resources/data/locales/vi.php | 30213 | <?php
return [
'Names' => [
'af' => 'Tiếng Afrikaans',
'af_NA' => 'Tiếng Afrikaans (Namibia)',
'af_ZA' => 'Tiếng Afrikaans (Nam Phi)',
'ak' => 'Tiếng Akan',
'ak_GH' => 'Tiếng Akan (Ghana)',
'am' => 'Tiếng Amharic',
'am_ET' => 'Tiếng Amharic (Ethiopia)',
'ar' => 'Tiếng Ả Rập',
'ar_001' => 'Tiếng Ả Rập (Thế giới)',
'ar_AE' => 'Tiếng Ả Rập (Các Tiểu Vương quốc Ả Rập Thống nhất)',
'ar_BH' => 'Tiếng Ả Rập (Bahrain)',
'ar_DJ' => 'Tiếng Ả Rập (Djibouti)',
'ar_DZ' => 'Tiếng Ả Rập (Algeria)',
'ar_EG' => 'Tiếng Ả Rập (Ai Cập)',
'ar_EH' => 'Tiếng Ả Rập (Tây Sahara)',
'ar_ER' => 'Tiếng Ả Rập (Eritrea)',
'ar_IL' => 'Tiếng Ả Rập (Israel)',
'ar_IQ' => 'Tiếng Ả Rập (Iraq)',
'ar_JO' => 'Tiếng Ả Rập (Jordan)',
'ar_KM' => 'Tiếng Ả Rập (Comoros)',
'ar_KW' => 'Tiếng Ả Rập (Kuwait)',
'ar_LB' => 'Tiếng Ả Rập (Li-băng)',
'ar_LY' => 'Tiếng Ả Rập (Libya)',
'ar_MA' => 'Tiếng Ả Rập (Ma-rốc)',
'ar_MR' => 'Tiếng Ả Rập (Mauritania)',
'ar_OM' => 'Tiếng Ả Rập (Oman)',
'ar_PS' => 'Tiếng Ả Rập (Lãnh thổ Palestine)',
'ar_QA' => 'Tiếng Ả Rập (Qatar)',
'ar_SA' => 'Tiếng Ả Rập (Ả Rập Xê-út)',
'ar_SD' => 'Tiếng Ả Rập (Sudan)',
'ar_SO' => 'Tiếng Ả Rập (Somalia)',
'ar_SS' => 'Tiếng Ả Rập (Nam Sudan)',
'ar_SY' => 'Tiếng Ả Rập (Syria)',
'ar_TD' => 'Tiếng Ả Rập (Chad)',
'ar_TN' => 'Tiếng Ả Rập (Tunisia)',
'ar_YE' => 'Tiếng Ả Rập (Yemen)',
'as' => 'Tiếng Assam',
'as_IN' => 'Tiếng Assam (Ấn Độ)',
'az' => 'Tiếng Azerbaijan',
'az_AZ' => 'Tiếng Azerbaijan (Azerbaijan)',
'az_Cyrl' => 'Tiếng Azerbaijan (Chữ Kirin)',
'az_Cyrl_AZ' => 'Tiếng Azerbaijan (Chữ Kirin, Azerbaijan)',
'az_Latn' => 'Tiếng Azerbaijan (Chữ La tinh)',
'az_Latn_AZ' => 'Tiếng Azerbaijan (Chữ La tinh, Azerbaijan)',
'be' => 'Tiếng Belarus',
'be_BY' => 'Tiếng Belarus (Belarus)',
'bg' => 'Tiếng Bulgaria',
'bg_BG' => 'Tiếng Bulgaria (Bulgaria)',
'bm' => 'Tiếng Bambara',
'bm_ML' => 'Tiếng Bambara (Mali)',
'bn' => 'Tiếng Bangla',
'bn_BD' => 'Tiếng Bangla (Bangladesh)',
'bn_IN' => 'Tiếng Bangla (Ấn Độ)',
'bo' => 'Tiếng Tây Tạng',
'bo_CN' => 'Tiếng Tây Tạng (Trung Quốc)',
'bo_IN' => 'Tiếng Tây Tạng (Ấn Độ)',
'br' => 'Tiếng Breton',
'br_FR' => 'Tiếng Breton (Pháp)',
'bs' => 'Tiếng Bosnia',
'bs_BA' => 'Tiếng Bosnia (Bosnia và Herzegovina)',
'bs_Cyrl' => 'Tiếng Bosnia (Chữ Kirin)',
'bs_Cyrl_BA' => 'Tiếng Bosnia (Chữ Kirin, Bosnia và Herzegovina)',
'bs_Latn' => 'Tiếng Bosnia (Chữ La tinh)',
'bs_Latn_BA' => 'Tiếng Bosnia (Chữ La tinh, Bosnia và Herzegovina)',
'ca' => 'Tiếng Catalan',
'ca_AD' => 'Tiếng Catalan (Andorra)',
'ca_ES' => 'Tiếng Catalan (Tây Ban Nha)',
'ca_FR' => 'Tiếng Catalan (Pháp)',
'ca_IT' => 'Tiếng Catalan (Italy)',
'ce' => 'Tiếng Chechen',
'ce_RU' => 'Tiếng Chechen (Nga)',
'cs' => 'Tiếng Séc',
'cs_CZ' => 'Tiếng Séc (Séc)',
'cy' => 'Tiếng Wales',
'cy_GB' => 'Tiếng Wales (Vương quốc Anh)',
'da' => 'Tiếng Đan Mạch',
'da_DK' => 'Tiếng Đan Mạch (Đan Mạch)',
'da_GL' => 'Tiếng Đan Mạch (Greenland)',
'de' => 'Tiếng Đức',
'de_AT' => 'Tiếng Đức (Áo)',
'de_BE' => 'Tiếng Đức (Bỉ)',
'de_CH' => 'Tiếng Đức (Thụy Sĩ)',
'de_DE' => 'Tiếng Đức (Đức)',
'de_IT' => 'Tiếng Đức (Italy)',
'de_LI' => 'Tiếng Đức (Liechtenstein)',
'de_LU' => 'Tiếng Đức (Luxembourg)',
'dz' => 'Tiếng Dzongkha',
'dz_BT' => 'Tiếng Dzongkha (Bhutan)',
'ee' => 'Tiếng Ewe',
'ee_GH' => 'Tiếng Ewe (Ghana)',
'ee_TG' => 'Tiếng Ewe (Togo)',
'el' => 'Tiếng Hy Lạp',
'el_CY' => 'Tiếng Hy Lạp (Síp)',
'el_GR' => 'Tiếng Hy Lạp (Hy Lạp)',
'en' => 'Tiếng Anh',
'en_001' => 'Tiếng Anh (Thế giới)',
'en_150' => 'Tiếng Anh (Châu Âu)',
'en_AE' => 'Tiếng Anh (Các Tiểu Vương quốc Ả Rập Thống nhất)',
'en_AG' => 'Tiếng Anh (Antigua và Barbuda)',
'en_AI' => 'Tiếng Anh (Anguilla)',
'en_AS' => 'Tiếng Anh (Samoa thuộc Mỹ)',
'en_AT' => 'Tiếng Anh (Áo)',
'en_AU' => 'Tiếng Anh (Australia)',
'en_BB' => 'Tiếng Anh (Barbados)',
'en_BE' => 'Tiếng Anh (Bỉ)',
'en_BI' => 'Tiếng Anh (Burundi)',
'en_BM' => 'Tiếng Anh (Bermuda)',
'en_BS' => 'Tiếng Anh (Bahamas)',
'en_BW' => 'Tiếng Anh (Botswana)',
'en_BZ' => 'Tiếng Anh (Belize)',
'en_CA' => 'Tiếng Anh (Canada)',
'en_CC' => 'Tiếng Anh (Quần đảo Cocos [Keeling])',
'en_CH' => 'Tiếng Anh (Thụy Sĩ)',
'en_CK' => 'Tiếng Anh (Quần đảo Cook)',
'en_CM' => 'Tiếng Anh (Cameroon)',
'en_CX' => 'Tiếng Anh (Đảo Giáng Sinh)',
'en_CY' => 'Tiếng Anh (Síp)',
'en_DE' => 'Tiếng Anh (Đức)',
'en_DK' => 'Tiếng Anh (Đan Mạch)',
'en_DM' => 'Tiếng Anh (Dominica)',
'en_ER' => 'Tiếng Anh (Eritrea)',
'en_FI' => 'Tiếng Anh (Phần Lan)',
'en_FJ' => 'Tiếng Anh (Fiji)',
'en_FK' => 'Tiếng Anh (Quần đảo Falkland)',
'en_FM' => 'Tiếng Anh (Micronesia)',
'en_GB' => 'Tiếng Anh (Vương quốc Anh)',
'en_GD' => 'Tiếng Anh (Grenada)',
'en_GG' => 'Tiếng Anh (Guernsey)',
'en_GH' => 'Tiếng Anh (Ghana)',
'en_GI' => 'Tiếng Anh (Gibraltar)',
'en_GM' => 'Tiếng Anh (Gambia)',
'en_GU' => 'Tiếng Anh (Guam)',
'en_GY' => 'Tiếng Anh (Guyana)',
'en_HK' => 'Tiếng Anh (Đặc khu Hành chính Hồng Kông, Trung Quốc)',
'en_IE' => 'Tiếng Anh (Ireland)',
'en_IL' => 'Tiếng Anh (Israel)',
'en_IM' => 'Tiếng Anh (Đảo Man)',
'en_IN' => 'Tiếng Anh (Ấn Độ)',
'en_IO' => 'Tiếng Anh (Lãnh thổ Ấn Độ Dương thuộc Anh)',
'en_JE' => 'Tiếng Anh (Jersey)',
'en_JM' => 'Tiếng Anh (Jamaica)',
'en_KE' => 'Tiếng Anh (Kenya)',
'en_KI' => 'Tiếng Anh (Kiribati)',
'en_KN' => 'Tiếng Anh (St. Kitts và Nevis)',
'en_KY' => 'Tiếng Anh (Quần đảo Cayman)',
'en_LC' => 'Tiếng Anh (St. Lucia)',
'en_LR' => 'Tiếng Anh (Liberia)',
'en_LS' => 'Tiếng Anh (Lesotho)',
'en_MG' => 'Tiếng Anh (Madagascar)',
'en_MH' => 'Tiếng Anh (Quần đảo Marshall)',
'en_MO' => 'Tiếng Anh (Đặc khu Hành chính Macao, Trung Quốc)',
'en_MP' => 'Tiếng Anh (Quần đảo Bắc Mariana)',
'en_MS' => 'Tiếng Anh (Montserrat)',
'en_MT' => 'Tiếng Anh (Malta)',
'en_MU' => 'Tiếng Anh (Mauritius)',
'en_MW' => 'Tiếng Anh (Malawi)',
'en_MY' => 'Tiếng Anh (Malaysia)',
'en_NA' => 'Tiếng Anh (Namibia)',
'en_NF' => 'Tiếng Anh (Đảo Norfolk)',
'en_NG' => 'Tiếng Anh (Nigeria)',
'en_NL' => 'Tiếng Anh (Hà Lan)',
'en_NR' => 'Tiếng Anh (Nauru)',
'en_NU' => 'Tiếng Anh (Niue)',
'en_NZ' => 'Tiếng Anh (New Zealand)',
'en_PG' => 'Tiếng Anh (Papua New Guinea)',
'en_PH' => 'Tiếng Anh (Philippines)',
'en_PK' => 'Tiếng Anh (Pakistan)',
'en_PN' => 'Tiếng Anh (Quần đảo Pitcairn)',
'en_PR' => 'Tiếng Anh (Puerto Rico)',
'en_PW' => 'Tiếng Anh (Palau)',
'en_RW' => 'Tiếng Anh (Rwanda)',
'en_SB' => 'Tiếng Anh (Quần đảo Solomon)',
'en_SC' => 'Tiếng Anh (Seychelles)',
'en_SD' => 'Tiếng Anh (Sudan)',
'en_SE' => 'Tiếng Anh (Thụy Điển)',
'en_SG' => 'Tiếng Anh (Singapore)',
'en_SH' => 'Tiếng Anh (St. Helena)',
'en_SI' => 'Tiếng Anh (Slovenia)',
'en_SL' => 'Tiếng Anh (Sierra Leone)',
'en_SS' => 'Tiếng Anh (Nam Sudan)',
'en_SX' => 'Tiếng Anh (Sint Maarten)',
'en_SZ' => 'Tiếng Anh (Eswatini)',
'en_TC' => 'Tiếng Anh (Quần đảo Turks và Caicos)',
'en_TK' => 'Tiếng Anh (Tokelau)',
'en_TO' => 'Tiếng Anh (Tonga)',
'en_TT' => 'Tiếng Anh (Trinidad và Tobago)',
'en_TV' => 'Tiếng Anh (Tuvalu)',
'en_TZ' => 'Tiếng Anh (Tanzania)',
'en_UG' => 'Tiếng Anh (Uganda)',
'en_UM' => 'Tiếng Anh (Các tiểu đảo xa của Hoa Kỳ)',
'en_US' => 'Tiếng Anh (Hoa Kỳ)',
'en_VC' => 'Tiếng Anh (St. Vincent và Grenadines)',
'en_VG' => 'Tiếng Anh (Quần đảo Virgin thuộc Anh)',
'en_VI' => 'Tiếng Anh (Quần đảo Virgin thuộc Hoa Kỳ)',
'en_VU' => 'Tiếng Anh (Vanuatu)',
'en_WS' => 'Tiếng Anh (Samoa)',
'en_ZA' => 'Tiếng Anh (Nam Phi)',
'en_ZM' => 'Tiếng Anh (Zambia)',
'en_ZW' => 'Tiếng Anh (Zimbabwe)',
'eo' => 'Tiếng Quốc Tế Ngữ',
'eo_001' => 'Tiếng Quốc Tế Ngữ (Thế giới)',
'es' => 'Tiếng Tây Ban Nha',
'es_419' => 'Tiếng Tây Ban Nha (Châu Mỹ La-tinh)',
'es_AR' => 'Tiếng Tây Ban Nha (Argentina)',
'es_BO' => 'Tiếng Tây Ban Nha (Bolivia)',
'es_BR' => 'Tiếng Tây Ban Nha (Brazil)',
'es_BZ' => 'Tiếng Tây Ban Nha (Belize)',
'es_CL' => 'Tiếng Tây Ban Nha (Chile)',
'es_CO' => 'Tiếng Tây Ban Nha (Colombia)',
'es_CR' => 'Tiếng Tây Ban Nha (Costa Rica)',
'es_CU' => 'Tiếng Tây Ban Nha (Cuba)',
'es_DO' => 'Tiếng Tây Ban Nha (Cộng hòa Dominica)',
'es_EC' => 'Tiếng Tây Ban Nha (Ecuador)',
'es_ES' => 'Tiếng Tây Ban Nha (Tây Ban Nha)',
'es_GQ' => 'Tiếng Tây Ban Nha (Guinea Xích Đạo)',
'es_GT' => 'Tiếng Tây Ban Nha (Guatemala)',
'es_HN' => 'Tiếng Tây Ban Nha (Honduras)',
'es_MX' => 'Tiếng Tây Ban Nha (Mexico)',
'es_NI' => 'Tiếng Tây Ban Nha (Nicaragua)',
'es_PA' => 'Tiếng Tây Ban Nha (Panama)',
'es_PE' => 'Tiếng Tây Ban Nha (Peru)',
'es_PH' => 'Tiếng Tây Ban Nha (Philippines)',
'es_PR' => 'Tiếng Tây Ban Nha (Puerto Rico)',
'es_PY' => 'Tiếng Tây Ban Nha (Paraguay)',
'es_SV' => 'Tiếng Tây Ban Nha (El Salvador)',
'es_US' => 'Tiếng Tây Ban Nha (Hoa Kỳ)',
'es_UY' => 'Tiếng Tây Ban Nha (Uruguay)',
'es_VE' => 'Tiếng Tây Ban Nha (Venezuela)',
'et' => 'Tiếng Estonia',
'et_EE' => 'Tiếng Estonia (Estonia)',
'eu' => 'Tiếng Basque',
'eu_ES' => 'Tiếng Basque (Tây Ban Nha)',
'fa' => 'Tiếng Ba Tư',
'fa_AF' => 'Tiếng Ba Tư (Afghanistan)',
'fa_IR' => 'Tiếng Ba Tư (Iran)',
'ff' => 'Tiếng Fulah',
'ff_CM' => 'Tiếng Fulah (Cameroon)',
'ff_GN' => 'Tiếng Fulah (Guinea)',
'ff_Latn' => 'Tiếng Fulah (Chữ La tinh)',
'ff_Latn_BF' => 'Tiếng Fulah (Chữ La tinh, Burkina Faso)',
'ff_Latn_CM' => 'Tiếng Fulah (Chữ La tinh, Cameroon)',
'ff_Latn_GH' => 'Tiếng Fulah (Chữ La tinh, Ghana)',
'ff_Latn_GM' => 'Tiếng Fulah (Chữ La tinh, Gambia)',
'ff_Latn_GN' => 'Tiếng Fulah (Chữ La tinh, Guinea)',
'ff_Latn_GW' => 'Tiếng Fulah (Chữ La tinh, Guinea-Bissau)',
'ff_Latn_LR' => 'Tiếng Fulah (Chữ La tinh, Liberia)',
'ff_Latn_MR' => 'Tiếng Fulah (Chữ La tinh, Mauritania)',
'ff_Latn_NE' => 'Tiếng Fulah (Chữ La tinh, Niger)',
'ff_Latn_NG' => 'Tiếng Fulah (Chữ La tinh, Nigeria)',
'ff_Latn_SL' => 'Tiếng Fulah (Chữ La tinh, Sierra Leone)',
'ff_Latn_SN' => 'Tiếng Fulah (Chữ La tinh, Senegal)',
'ff_MR' => 'Tiếng Fulah (Mauritania)',
'ff_SN' => 'Tiếng Fulah (Senegal)',
'fi' => 'Tiếng Phần Lan',
'fi_FI' => 'Tiếng Phần Lan (Phần Lan)',
'fo' => 'Tiếng Faroe',
'fo_DK' => 'Tiếng Faroe (Đan Mạch)',
'fo_FO' => 'Tiếng Faroe (Quần đảo Faroe)',
'fr' => 'Tiếng Pháp',
'fr_BE' => 'Tiếng Pháp (Bỉ)',
'fr_BF' => 'Tiếng Pháp (Burkina Faso)',
'fr_BI' => 'Tiếng Pháp (Burundi)',
'fr_BJ' => 'Tiếng Pháp (Benin)',
'fr_BL' => 'Tiếng Pháp (St. Barthélemy)',
'fr_CA' => 'Tiếng Pháp (Canada)',
'fr_CD' => 'Tiếng Pháp (Congo - Kinshasa)',
'fr_CF' => 'Tiếng Pháp (Cộng hòa Trung Phi)',
'fr_CG' => 'Tiếng Pháp (Congo - Brazzaville)',
'fr_CH' => 'Tiếng Pháp (Thụy Sĩ)',
'fr_CI' => 'Tiếng Pháp (Côte d’Ivoire)',
'fr_CM' => 'Tiếng Pháp (Cameroon)',
'fr_DJ' => 'Tiếng Pháp (Djibouti)',
'fr_DZ' => 'Tiếng Pháp (Algeria)',
'fr_FR' => 'Tiếng Pháp (Pháp)',
'fr_GA' => 'Tiếng Pháp (Gabon)',
'fr_GF' => 'Tiếng Pháp (Guiana thuộc Pháp)',
'fr_GN' => 'Tiếng Pháp (Guinea)',
'fr_GP' => 'Tiếng Pháp (Guadeloupe)',
'fr_GQ' => 'Tiếng Pháp (Guinea Xích Đạo)',
'fr_HT' => 'Tiếng Pháp (Haiti)',
'fr_KM' => 'Tiếng Pháp (Comoros)',
'fr_LU' => 'Tiếng Pháp (Luxembourg)',
'fr_MA' => 'Tiếng Pháp (Ma-rốc)',
'fr_MC' => 'Tiếng Pháp (Monaco)',
'fr_MF' => 'Tiếng Pháp (St. Martin)',
'fr_MG' => 'Tiếng Pháp (Madagascar)',
'fr_ML' => 'Tiếng Pháp (Mali)',
'fr_MQ' => 'Tiếng Pháp (Martinique)',
'fr_MR' => 'Tiếng Pháp (Mauritania)',
'fr_MU' => 'Tiếng Pháp (Mauritius)',
'fr_NC' => 'Tiếng Pháp (New Caledonia)',
'fr_NE' => 'Tiếng Pháp (Niger)',
'fr_PF' => 'Tiếng Pháp (Polynesia thuộc Pháp)',
'fr_PM' => 'Tiếng Pháp (Saint Pierre và Miquelon)',
'fr_RE' => 'Tiếng Pháp (Réunion)',
'fr_RW' => 'Tiếng Pháp (Rwanda)',
'fr_SC' => 'Tiếng Pháp (Seychelles)',
'fr_SN' => 'Tiếng Pháp (Senegal)',
'fr_SY' => 'Tiếng Pháp (Syria)',
'fr_TD' => 'Tiếng Pháp (Chad)',
'fr_TG' => 'Tiếng Pháp (Togo)',
'fr_TN' => 'Tiếng Pháp (Tunisia)',
'fr_VU' => 'Tiếng Pháp (Vanuatu)',
'fr_WF' => 'Tiếng Pháp (Wallis và Futuna)',
'fr_YT' => 'Tiếng Pháp (Mayotte)',
'fy' => 'Tiếng Frisia',
'fy_NL' => 'Tiếng Frisia (Hà Lan)',
'ga' => 'Tiếng Ireland',
'ga_GB' => 'Tiếng Ireland (Vương quốc Anh)',
'ga_IE' => 'Tiếng Ireland (Ireland)',
'gd' => 'Tiếng Gael Scotland',
'gd_GB' => 'Tiếng Gael Scotland (Vương quốc Anh)',
'gl' => 'Tiếng Galician',
'gl_ES' => 'Tiếng Galician (Tây Ban Nha)',
'gu' => 'Tiếng Gujarati',
'gu_IN' => 'Tiếng Gujarati (Ấn Độ)',
'gv' => 'Tiếng Manx',
'gv_IM' => 'Tiếng Manx (Đảo Man)',
'ha' => 'Tiếng Hausa',
'ha_GH' => 'Tiếng Hausa (Ghana)',
'ha_NE' => 'Tiếng Hausa (Niger)',
'ha_NG' => 'Tiếng Hausa (Nigeria)',
'he' => 'Tiếng Do Thái',
'he_IL' => 'Tiếng Do Thái (Israel)',
'hi' => 'Tiếng Hindi',
'hi_IN' => 'Tiếng Hindi (Ấn Độ)',
'hr' => 'Tiếng Croatia',
'hr_BA' => 'Tiếng Croatia (Bosnia và Herzegovina)',
'hr_HR' => 'Tiếng Croatia (Croatia)',
'hu' => 'Tiếng Hungary',
'hu_HU' => 'Tiếng Hungary (Hungary)',
'hy' => 'Tiếng Armenia',
'hy_AM' => 'Tiếng Armenia (Armenia)',
'ia' => 'Tiếng Khoa Học Quốc Tế',
'ia_001' => 'Tiếng Khoa Học Quốc Tế (Thế giới)',
'id' => 'Tiếng Indonesia',
'id_ID' => 'Tiếng Indonesia (Indonesia)',
'ig' => 'Tiếng Igbo',
'ig_NG' => 'Tiếng Igbo (Nigeria)',
'ii' => 'Tiếng Di Tứ Xuyên',
'ii_CN' => 'Tiếng Di Tứ Xuyên (Trung Quốc)',
'is' => 'Tiếng Iceland',
'is_IS' => 'Tiếng Iceland (Iceland)',
'it' => 'Tiếng Italy',
'it_CH' => 'Tiếng Italy (Thụy Sĩ)',
'it_IT' => 'Tiếng Italy (Italy)',
'it_SM' => 'Tiếng Italy (San Marino)',
'it_VA' => 'Tiếng Italy (Thành Vatican)',
'ja' => 'Tiếng Nhật',
'ja_JP' => 'Tiếng Nhật (Nhật Bản)',
'jv' => 'Tiếng Java',
'jv_ID' => 'Tiếng Java (Indonesia)',
'ka' => 'Tiếng Georgia',
'ka_GE' => 'Tiếng Georgia (Georgia)',
'ki' => 'Tiếng Kikuyu',
'ki_KE' => 'Tiếng Kikuyu (Kenya)',
'kk' => 'Tiếng Kazakh',
'kk_KZ' => 'Tiếng Kazakh (Kazakhstan)',
'kl' => 'Tiếng Kalaallisut',
'kl_GL' => 'Tiếng Kalaallisut (Greenland)',
'km' => 'Tiếng Khmer',
'km_KH' => 'Tiếng Khmer (Campuchia)',
'kn' => 'Tiếng Kannada',
'kn_IN' => 'Tiếng Kannada (Ấn Độ)',
'ko' => 'Tiếng Hàn',
'ko_KP' => 'Tiếng Hàn (Triều Tiên)',
'ko_KR' => 'Tiếng Hàn (Hàn Quốc)',
'ks' => 'Tiếng Kashmir',
'ks_Arab' => 'Tiếng Kashmir (Chữ Ả Rập)',
'ks_Arab_IN' => 'Tiếng Kashmir (Chữ Ả Rập, Ấn Độ)',
'ks_IN' => 'Tiếng Kashmir (Ấn Độ)',
'ku' => 'Tiếng Kurd',
'ku_TR' => 'Tiếng Kurd (Thổ Nhĩ Kỳ)',
'kw' => 'Tiếng Cornwall',
'kw_GB' => 'Tiếng Cornwall (Vương quốc Anh)',
'ky' => 'Tiếng Kyrgyz',
'ky_KG' => 'Tiếng Kyrgyz (Kyrgyzstan)',
'lb' => 'Tiếng Luxembourg',
'lb_LU' => 'Tiếng Luxembourg (Luxembourg)',
'lg' => 'Tiếng Ganda',
'lg_UG' => 'Tiếng Ganda (Uganda)',
'ln' => 'Tiếng Lingala',
'ln_AO' => 'Tiếng Lingala (Angola)',
'ln_CD' => 'Tiếng Lingala (Congo - Kinshasa)',
'ln_CF' => 'Tiếng Lingala (Cộng hòa Trung Phi)',
'ln_CG' => 'Tiếng Lingala (Congo - Brazzaville)',
'lo' => 'Tiếng Lào',
'lo_LA' => 'Tiếng Lào (Lào)',
'lt' => 'Tiếng Litva',
'lt_LT' => 'Tiếng Litva (Litva)',
'lu' => 'Tiếng Luba-Katanga',
'lu_CD' => 'Tiếng Luba-Katanga (Congo - Kinshasa)',
'lv' => 'Tiếng Latvia',
'lv_LV' => 'Tiếng Latvia (Latvia)',
'mg' => 'Tiếng Malagasy',
'mg_MG' => 'Tiếng Malagasy (Madagascar)',
'mi' => 'Tiếng Māori',
'mi_NZ' => 'Tiếng Māori (New Zealand)',
'mk' => 'Tiếng Macedonia',
'mk_MK' => 'Tiếng Macedonia (Bắc Macedonia)',
'ml' => 'Tiếng Malayalam',
'ml_IN' => 'Tiếng Malayalam (Ấn Độ)',
'mn' => 'Tiếng Mông Cổ',
'mn_MN' => 'Tiếng Mông Cổ (Mông Cổ)',
'mr' => 'Tiếng Marathi',
'mr_IN' => 'Tiếng Marathi (Ấn Độ)',
'ms' => 'Tiếng Mã Lai',
'ms_BN' => 'Tiếng Mã Lai (Brunei)',
'ms_ID' => 'Tiếng Mã Lai (Indonesia)',
'ms_MY' => 'Tiếng Mã Lai (Malaysia)',
'ms_SG' => 'Tiếng Mã Lai (Singapore)',
'mt' => 'Tiếng Malta',
'mt_MT' => 'Tiếng Malta (Malta)',
'my' => 'Tiếng Miến Điện',
'my_MM' => 'Tiếng Miến Điện (Myanmar [Miến Điện])',
'nb' => 'Tiếng Na Uy [Bokmål]',
'nb_NO' => 'Tiếng Na Uy [Bokmål] (Na Uy)',
'nb_SJ' => 'Tiếng Na Uy [Bokmål] (Svalbard và Jan Mayen)',
'nd' => 'Tiếng Ndebele Miền Bắc',
'nd_ZW' => 'Tiếng Ndebele Miền Bắc (Zimbabwe)',
'ne' => 'Tiếng Nepal',
'ne_IN' => 'Tiếng Nepal (Ấn Độ)',
'ne_NP' => 'Tiếng Nepal (Nepal)',
'nl' => 'Tiếng Hà Lan',
'nl_AW' => 'Tiếng Hà Lan (Aruba)',
'nl_BE' => 'Tiếng Hà Lan (Bỉ)',
'nl_BQ' => 'Tiếng Hà Lan (Ca-ri-bê Hà Lan)',
'nl_CW' => 'Tiếng Hà Lan (Curaçao)',
'nl_NL' => 'Tiếng Hà Lan (Hà Lan)',
'nl_SR' => 'Tiếng Hà Lan (Suriname)',
'nl_SX' => 'Tiếng Hà Lan (Sint Maarten)',
'nn' => 'Tiếng Na Uy [Nynorsk]',
'nn_NO' => 'Tiếng Na Uy [Nynorsk] (Na Uy)',
'no' => 'Tiếng Na Uy',
'no_NO' => 'Tiếng Na Uy (Na Uy)',
'om' => 'Tiếng Oromo',
'om_ET' => 'Tiếng Oromo (Ethiopia)',
'om_KE' => 'Tiếng Oromo (Kenya)',
'or' => 'Tiếng Odia',
'or_IN' => 'Tiếng Odia (Ấn Độ)',
'os' => 'Tiếng Ossetic',
'os_GE' => 'Tiếng Ossetic (Georgia)',
'os_RU' => 'Tiếng Ossetic (Nga)',
'pa' => 'Tiếng Punjab',
'pa_Arab' => 'Tiếng Punjab (Chữ Ả Rập)',
'pa_Arab_PK' => 'Tiếng Punjab (Chữ Ả Rập, Pakistan)',
'pa_Guru' => 'Tiếng Punjab (Chữ Gurmukhi)',
'pa_Guru_IN' => 'Tiếng Punjab (Chữ Gurmukhi, Ấn Độ)',
'pa_IN' => 'Tiếng Punjab (Ấn Độ)',
'pa_PK' => 'Tiếng Punjab (Pakistan)',
'pl' => 'Tiếng Ba Lan',
'pl_PL' => 'Tiếng Ba Lan (Ba Lan)',
'ps' => 'Tiếng Pashto',
'ps_AF' => 'Tiếng Pashto (Afghanistan)',
'ps_PK' => 'Tiếng Pashto (Pakistan)',
'pt' => 'Tiếng Bồ Đào Nha',
'pt_AO' => 'Tiếng Bồ Đào Nha (Angola)',
'pt_BR' => 'Tiếng Bồ Đào Nha (Brazil)',
'pt_CH' => 'Tiếng Bồ Đào Nha (Thụy Sĩ)',
'pt_CV' => 'Tiếng Bồ Đào Nha (Cape Verde)',
'pt_GQ' => 'Tiếng Bồ Đào Nha (Guinea Xích Đạo)',
'pt_GW' => 'Tiếng Bồ Đào Nha (Guinea-Bissau)',
'pt_LU' => 'Tiếng Bồ Đào Nha (Luxembourg)',
'pt_MO' => 'Tiếng Bồ Đào Nha (Đặc khu Hành chính Macao, Trung Quốc)',
'pt_MZ' => 'Tiếng Bồ Đào Nha (Mozambique)',
'pt_PT' => 'Tiếng Bồ Đào Nha (Bồ Đào Nha)',
'pt_ST' => 'Tiếng Bồ Đào Nha (São Tomé và Príncipe)',
'pt_TL' => 'Tiếng Bồ Đào Nha (Timor-Leste)',
'qu' => 'Tiếng Quechua',
'qu_BO' => 'Tiếng Quechua (Bolivia)',
'qu_EC' => 'Tiếng Quechua (Ecuador)',
'qu_PE' => 'Tiếng Quechua (Peru)',
'rm' => 'Tiếng Romansh',
'rm_CH' => 'Tiếng Romansh (Thụy Sĩ)',
'rn' => 'Tiếng Rundi',
'rn_BI' => 'Tiếng Rundi (Burundi)',
'ro' => 'Tiếng Romania',
'ro_MD' => 'Tiếng Romania (Moldova)',
'ro_RO' => 'Tiếng Romania (Romania)',
'ru' => 'Tiếng Nga',
'ru_BY' => 'Tiếng Nga (Belarus)',
'ru_KG' => 'Tiếng Nga (Kyrgyzstan)',
'ru_KZ' => 'Tiếng Nga (Kazakhstan)',
'ru_MD' => 'Tiếng Nga (Moldova)',
'ru_RU' => 'Tiếng Nga (Nga)',
'ru_UA' => 'Tiếng Nga (Ukraina)',
'rw' => 'Tiếng Kinyarwanda',
'rw_RW' => 'Tiếng Kinyarwanda (Rwanda)',
'sa' => 'Tiếng Phạn',
'sa_IN' => 'Tiếng Phạn (Ấn Độ)',
'sc' => 'Tiếng Sardinia',
'sc_IT' => 'Tiếng Sardinia (Italy)',
'sd' => 'Tiếng Sindhi',
'sd_Arab' => 'Tiếng Sindhi (Chữ Ả Rập)',
'sd_Arab_PK' => 'Tiếng Sindhi (Chữ Ả Rập, Pakistan)',
'sd_Deva' => 'Tiếng Sindhi (Chữ Devanagari)',
'sd_Deva_IN' => 'Tiếng Sindhi (Chữ Devanagari, Ấn Độ)',
'sd_PK' => 'Tiếng Sindhi (Pakistan)',
'se' => 'Tiếng Sami Miền Bắc',
'se_FI' => 'Tiếng Sami Miền Bắc (Phần Lan)',
'se_NO' => 'Tiếng Sami Miền Bắc (Na Uy)',
'se_SE' => 'Tiếng Sami Miền Bắc (Thụy Điển)',
'sg' => 'Tiếng Sango',
'sg_CF' => 'Tiếng Sango (Cộng hòa Trung Phi)',
'sh' => 'Tiếng Serbo-Croatia',
'sh_BA' => 'Tiếng Serbo-Croatia (Bosnia và Herzegovina)',
'si' => 'Tiếng Sinhala',
'si_LK' => 'Tiếng Sinhala (Sri Lanka)',
'sk' => 'Tiếng Slovak',
'sk_SK' => 'Tiếng Slovak (Slovakia)',
'sl' => 'Tiếng Slovenia',
'sl_SI' => 'Tiếng Slovenia (Slovenia)',
'sn' => 'Tiếng Shona',
'sn_ZW' => 'Tiếng Shona (Zimbabwe)',
'so' => 'Tiếng Somali',
'so_DJ' => 'Tiếng Somali (Djibouti)',
'so_ET' => 'Tiếng Somali (Ethiopia)',
'so_KE' => 'Tiếng Somali (Kenya)',
'so_SO' => 'Tiếng Somali (Somalia)',
'sq' => 'Tiếng Albania',
'sq_AL' => 'Tiếng Albania (Albania)',
'sq_MK' => 'Tiếng Albania (Bắc Macedonia)',
'sr' => 'Tiếng Serbia',
'sr_BA' => 'Tiếng Serbia (Bosnia và Herzegovina)',
'sr_Cyrl' => 'Tiếng Serbia (Chữ Kirin)',
'sr_Cyrl_BA' => 'Tiếng Serbia (Chữ Kirin, Bosnia và Herzegovina)',
'sr_Cyrl_ME' => 'Tiếng Serbia (Chữ Kirin, Montenegro)',
'sr_Cyrl_RS' => 'Tiếng Serbia (Chữ Kirin, Serbia)',
'sr_Latn' => 'Tiếng Serbia (Chữ La tinh)',
'sr_Latn_BA' => 'Tiếng Serbia (Chữ La tinh, Bosnia và Herzegovina)',
'sr_Latn_ME' => 'Tiếng Serbia (Chữ La tinh, Montenegro)',
'sr_Latn_RS' => 'Tiếng Serbia (Chữ La tinh, Serbia)',
'sr_ME' => 'Tiếng Serbia (Montenegro)',
'sr_RS' => 'Tiếng Serbia (Serbia)',
'su' => 'Tiếng Sunda',
'su_ID' => 'Tiếng Sunda (Indonesia)',
'su_Latn' => 'Tiếng Sunda (Chữ La tinh)',
'su_Latn_ID' => 'Tiếng Sunda (Chữ La tinh, Indonesia)',
'sv' => 'Tiếng Thụy Điển',
'sv_AX' => 'Tiếng Thụy Điển (Quần đảo Åland)',
'sv_FI' => 'Tiếng Thụy Điển (Phần Lan)',
'sv_SE' => 'Tiếng Thụy Điển (Thụy Điển)',
'sw' => 'Tiếng Swahili',
'sw_CD' => 'Tiếng Swahili (Congo - Kinshasa)',
'sw_KE' => 'Tiếng Swahili (Kenya)',
'sw_TZ' => 'Tiếng Swahili (Tanzania)',
'sw_UG' => 'Tiếng Swahili (Uganda)',
'ta' => 'Tiếng Tamil',
'ta_IN' => 'Tiếng Tamil (Ấn Độ)',
'ta_LK' => 'Tiếng Tamil (Sri Lanka)',
'ta_MY' => 'Tiếng Tamil (Malaysia)',
'ta_SG' => 'Tiếng Tamil (Singapore)',
'te' => 'Tiếng Telugu',
'te_IN' => 'Tiếng Telugu (Ấn Độ)',
'tg' => 'Tiếng Tajik',
'tg_TJ' => 'Tiếng Tajik (Tajikistan)',
'th' => 'Tiếng Thái',
'th_TH' => 'Tiếng Thái (Thái Lan)',
'ti' => 'Tiếng Tigrinya',
'ti_ER' => 'Tiếng Tigrinya (Eritrea)',
'ti_ET' => 'Tiếng Tigrinya (Ethiopia)',
'tk' => 'Tiếng Turkmen',
'tk_TM' => 'Tiếng Turkmen (Turkmenistan)',
'tl' => 'Tiếng Tagalog',
'tl_PH' => 'Tiếng Tagalog (Philippines)',
'to' => 'Tiếng Tonga',
'to_TO' => 'Tiếng Tonga (Tonga)',
'tr' => 'Tiếng Thổ Nhĩ Kỳ',
'tr_CY' => 'Tiếng Thổ Nhĩ Kỳ (Síp)',
'tr_TR' => 'Tiếng Thổ Nhĩ Kỳ (Thổ Nhĩ Kỳ)',
'tt' => 'Tiếng Tatar',
'tt_RU' => 'Tiếng Tatar (Nga)',
'ug' => 'Tiếng Uyghur',
'ug_CN' => 'Tiếng Uyghur (Trung Quốc)',
'uk' => 'Tiếng Ukraina',
'uk_UA' => 'Tiếng Ukraina (Ukraina)',
'ur' => 'Tiếng Urdu',
'ur_IN' => 'Tiếng Urdu (Ấn Độ)',
'ur_PK' => 'Tiếng Urdu (Pakistan)',
'uz' => 'Tiếng Uzbek',
'uz_AF' => 'Tiếng Uzbek (Afghanistan)',
'uz_Arab' => 'Tiếng Uzbek (Chữ Ả Rập)',
'uz_Arab_AF' => 'Tiếng Uzbek (Chữ Ả Rập, Afghanistan)',
'uz_Cyrl' => 'Tiếng Uzbek (Chữ Kirin)',
'uz_Cyrl_UZ' => 'Tiếng Uzbek (Chữ Kirin, Uzbekistan)',
'uz_Latn' => 'Tiếng Uzbek (Chữ La tinh)',
'uz_Latn_UZ' => 'Tiếng Uzbek (Chữ La tinh, Uzbekistan)',
'uz_UZ' => 'Tiếng Uzbek (Uzbekistan)',
'vi' => 'Tiếng Việt',
'vi_VN' => 'Tiếng Việt (Việt Nam)',
'wo' => 'Tiếng Wolof',
'wo_SN' => 'Tiếng Wolof (Senegal)',
'xh' => 'Tiếng Xhosa',
'xh_ZA' => 'Tiếng Xhosa (Nam Phi)',
'yi' => 'Tiếng Yiddish',
'yi_001' => 'Tiếng Yiddish (Thế giới)',
'yo' => 'Tiếng Yoruba',
'yo_BJ' => 'Tiếng Yoruba (Benin)',
'yo_NG' => 'Tiếng Yoruba (Nigeria)',
'zh' => 'Tiếng Trung',
'zh_CN' => 'Tiếng Trung (Trung Quốc)',
'zh_HK' => 'Tiếng Trung (Đặc khu Hành chính Hồng Kông, Trung Quốc)',
'zh_Hans' => 'Tiếng Trung (Giản thể)',
'zh_Hans_CN' => 'Tiếng Trung (Giản thể, Trung Quốc)',
'zh_Hans_HK' => 'Tiếng Trung (Giản thể, Đặc khu Hành chính Hồng Kông, Trung Quốc)',
'zh_Hans_MO' => 'Tiếng Trung (Giản thể, Đặc khu Hành chính Macao, Trung Quốc)',
'zh_Hans_SG' => 'Tiếng Trung (Giản thể, Singapore)',
'zh_Hant' => 'Tiếng Trung (Phồn thể)',
'zh_Hant_HK' => 'Tiếng Trung (Phồn thể, Đặc khu Hành chính Hồng Kông, Trung Quốc)',
'zh_Hant_MO' => 'Tiếng Trung (Phồn thể, Đặc khu Hành chính Macao, Trung Quốc)',
'zh_Hant_TW' => 'Tiếng Trung (Phồn thể, Đài Loan)',
'zh_MO' => 'Tiếng Trung (Đặc khu Hành chính Macao, Trung Quốc)',
'zh_SG' => 'Tiếng Trung (Singapore)',
'zh_TW' => 'Tiếng Trung (Đài Loan)',
'zu' => 'Tiếng Zulu',
'zu_ZA' => 'Tiếng Zulu (Nam Phi)',
],
];
| mit |
xuvw/GRMustache | src/tests/Public/v7.0/Suites/spullara:mustache.java/GRMustacheJavaSuites/recurse_base.html | 30 | {{$content}}
Test
{{/content}} | mit |
ahocevar/cdnjs | ajax/libs/react-dom/16.3.0/cjs/react-dom-test-utils.development.js | 36533 | /** @license React v16.3.0
* react-dom-test-utils.development.js
*
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
'use strict';
if (process.env.NODE_ENV !== "production") {
(function() {
'use strict';
var _assign = require('object-assign');
var React = require('react');
var ReactDOM = require('react-dom');
var invariant = require('fbjs/lib/invariant');
var warning = require('fbjs/lib/warning');
var emptyFunction = require('fbjs/lib/emptyFunction');
var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
/**
* WARNING: DO NOT manually require this module.
* This is a replacement for `invariant(...)` used by the error code system
* and will _only_ be required by the corresponding babel pass.
* It always throws.
*/
/**
* `ReactInstanceMap` maintains a mapping from a public facing stateful
* instance (key) and the internal representation (value). This allows public
* methods to accept the user facing instance as an argument and map them back
* to internal methods.
*
* Note that this module is currently shared and assumed to be stateless.
* If this becomes an actual Map, that will break.
*/
/**
* This API should be called `delete` but we'd have to make sure to always
* transform these to strings for IE support. When this transform is fully
* supported we can rename it.
*/
function get(key) {
return key._reactInternalFiber;
}
var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
var ReactCurrentOwner = ReactInternals.ReactCurrentOwner;
var ReactDebugCurrentFrame = ReactInternals.ReactDebugCurrentFrame;
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
// Before we know whether it is functional or class
var FunctionalComponent = 1;
var ClassComponent = 2;
var HostRoot = 3; // Root of a host tree. Could be nested inside another node.
// A subtree. Could be an entry point to a different renderer.
var HostComponent = 5;
var HostText = 6;
// Don't change these two values. They're used by React Dev Tools.
var NoEffect = /* */0;
// You can change the rest (and add more).
var Placement = /* */2;
// Union of all host effects
var MOUNTING = 1;
var MOUNTED = 2;
var UNMOUNTED = 3;
function isFiberMountedImpl(fiber) {
var node = fiber;
if (!fiber.alternate) {
// If there is no alternate, this might be a new tree that isn't inserted
// yet. If it is, then it will have a pending insertion effect on it.
if ((node.effectTag & Placement) !== NoEffect) {
return MOUNTING;
}
while (node['return']) {
node = node['return'];
if ((node.effectTag & Placement) !== NoEffect) {
return MOUNTING;
}
}
} else {
while (node['return']) {
node = node['return'];
}
}
if (node.tag === HostRoot) {
// TODO: Check if this was a nested HostRoot when used with
// renderContainerIntoSubtree.
return MOUNTED;
}
// If we didn't hit the root, that means that we're in an disconnected tree
// that has been unmounted.
return UNMOUNTED;
}
function assertIsMounted(fiber) {
!(isFiberMountedImpl(fiber) === MOUNTED) ? invariant(false, 'Unable to find node on an unmounted component.') : void 0;
}
function findCurrentFiberUsingSlowPath(fiber) {
var alternate = fiber.alternate;
if (!alternate) {
// If there is no alternate, then we only need to check if it is mounted.
var state = isFiberMountedImpl(fiber);
!(state !== UNMOUNTED) ? invariant(false, 'Unable to find node on an unmounted component.') : void 0;
if (state === MOUNTING) {
return null;
}
return fiber;
}
// If we have two possible branches, we'll walk backwards up to the root
// to see what path the root points to. On the way we may hit one of the
// special cases and we'll deal with them.
var a = fiber;
var b = alternate;
while (true) {
var parentA = a['return'];
var parentB = parentA ? parentA.alternate : null;
if (!parentA || !parentB) {
// We're at the root.
break;
}
// If both copies of the parent fiber point to the same child, we can
// assume that the child is current. This happens when we bailout on low
// priority: the bailed out fiber's child reuses the current child.
if (parentA.child === parentB.child) {
var child = parentA.child;
while (child) {
if (child === a) {
// We've determined that A is the current branch.
assertIsMounted(parentA);
return fiber;
}
if (child === b) {
// We've determined that B is the current branch.
assertIsMounted(parentA);
return alternate;
}
child = child.sibling;
}
// We should never have an alternate for any mounting node. So the only
// way this could possibly happen is if this was unmounted, if at all.
invariant(false, 'Unable to find node on an unmounted component.');
}
if (a['return'] !== b['return']) {
// The return pointer of A and the return pointer of B point to different
// fibers. We assume that return pointers never criss-cross, so A must
// belong to the child set of A.return, and B must belong to the child
// set of B.return.
a = parentA;
b = parentB;
} else {
// The return pointers point to the same fiber. We'll have to use the
// default, slow path: scan the child sets of each parent alternate to see
// which child belongs to which set.
//
// Search parent A's child set
var didFindChild = false;
var _child = parentA.child;
while (_child) {
if (_child === a) {
didFindChild = true;
a = parentA;
b = parentB;
break;
}
if (_child === b) {
didFindChild = true;
b = parentA;
a = parentB;
break;
}
_child = _child.sibling;
}
if (!didFindChild) {
// Search parent B's child set
_child = parentB.child;
while (_child) {
if (_child === a) {
didFindChild = true;
a = parentB;
b = parentA;
break;
}
if (_child === b) {
didFindChild = true;
b = parentB;
a = parentA;
break;
}
_child = _child.sibling;
}
!didFindChild ? invariant(false, 'Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.') : void 0;
}
}
!(a.alternate === b) ? invariant(false, 'Return fibers should always be each others\' alternates. This error is likely caused by a bug in React. Please file an issue.') : void 0;
}
// If the root is not a host container, we're in a disconnected tree. I.e.
// unmounted.
!(a.tag === HostRoot) ? invariant(false, 'Unable to find node on an unmounted component.') : void 0;
if (a.stateNode.current === a) {
// We've determined that A is the current branch.
return fiber;
}
// Otherwise B has to be current branch.
return alternate;
}
/* eslint valid-typeof: 0 */
var didWarnForAddedNewProperty = false;
var EVENT_POOL_SIZE = 10;
var shouldBeReleasedProperties = ['dispatchConfig', '_targetInst', 'nativeEvent', 'isDefaultPrevented', 'isPropagationStopped', '_dispatchListeners', '_dispatchInstances'];
/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var EventInterface = {
type: null,
target: null,
// currentTarget is set when dispatching; no use in copying it here
currentTarget: emptyFunction.thatReturnsNull,
eventPhase: null,
bubbles: null,
cancelable: null,
timeStamp: function (event) {
return event.timeStamp || Date.now();
},
defaultPrevented: null,
isTrusted: null
};
/**
* Synthetic events are dispatched by event plugins, typically in response to a
* top-level event delegation handler.
*
* These systems should generally use pooling to reduce the frequency of garbage
* collection. The system should check `isPersistent` to determine whether the
* event should be released into the pool after being dispatched. Users that
* need a persisted event should invoke `persist`.
*
* Synthetic events (and subclasses) implement the DOM Level 3 Events API by
* normalizing browser quirks. Subclasses do not necessarily have to implement a
* DOM interface; custom application-specific events can also subclass this.
*
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {*} targetInst Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @param {DOMEventTarget} nativeEventTarget Target node.
*/
function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
{
// these have a getter/setter for warnings
delete this.nativeEvent;
delete this.preventDefault;
delete this.stopPropagation;
}
this.dispatchConfig = dispatchConfig;
this._targetInst = targetInst;
this.nativeEvent = nativeEvent;
var Interface = this.constructor.Interface;
for (var propName in Interface) {
if (!Interface.hasOwnProperty(propName)) {
continue;
}
{
delete this[propName]; // this has a getter/setter for warnings
}
var normalize = Interface[propName];
if (normalize) {
this[propName] = normalize(nativeEvent);
} else {
if (propName === 'target') {
this.target = nativeEventTarget;
} else {
this[propName] = nativeEvent[propName];
}
}
}
var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
if (defaultPrevented) {
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
} else {
this.isDefaultPrevented = emptyFunction.thatReturnsFalse;
}
this.isPropagationStopped = emptyFunction.thatReturnsFalse;
return this;
}
_assign(SyntheticEvent.prototype, {
preventDefault: function () {
this.defaultPrevented = true;
var event = this.nativeEvent;
if (!event) {
return;
}
if (event.preventDefault) {
event.preventDefault();
} else if (typeof event.returnValue !== 'unknown') {
event.returnValue = false;
}
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
},
stopPropagation: function () {
var event = this.nativeEvent;
if (!event) {
return;
}
if (event.stopPropagation) {
event.stopPropagation();
} else if (typeof event.cancelBubble !== 'unknown') {
// The ChangeEventPlugin registers a "propertychange" event for
// IE. This event does not support bubbling or cancelling, and
// any references to cancelBubble throw "Member not found". A
// typeof check of "unknown" circumvents this issue (and is also
// IE specific).
event.cancelBubble = true;
}
this.isPropagationStopped = emptyFunction.thatReturnsTrue;
},
/**
* We release all dispatched `SyntheticEvent`s after each event loop, adding
* them back into the pool. This allows a way to hold onto a reference that
* won't be added back into the pool.
*/
persist: function () {
this.isPersistent = emptyFunction.thatReturnsTrue;
},
/**
* Checks if this event should be released back into the pool.
*
* @return {boolean} True if this should not be released, false otherwise.
*/
isPersistent: emptyFunction.thatReturnsFalse,
/**
* `PooledClass` looks for `destructor` on each instance it releases.
*/
destructor: function () {
var Interface = this.constructor.Interface;
for (var propName in Interface) {
{
Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
}
}
for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
this[shouldBeReleasedProperties[i]] = null;
}
{
Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));
Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));
}
}
});
SyntheticEvent.Interface = EventInterface;
/**
* Helper to reduce boilerplate when creating subclasses.
*/
SyntheticEvent.extend = function (Interface) {
var Super = this;
var E = function () {};
E.prototype = Super.prototype;
var prototype = new E();
function Class() {
return Super.apply(this, arguments);
}
_assign(prototype, Class.prototype);
Class.prototype = prototype;
Class.prototype.constructor = Class;
Class.Interface = _assign({}, Super.Interface, Interface);
Class.extend = Super.extend;
addEventPoolingTo(Class);
return Class;
};
/** Proxying after everything set on SyntheticEvent
* to resolve Proxy issue on some WebKit browsers
* in which some Event properties are set to undefined (GH#10010)
*/
{
var isProxySupported = typeof Proxy === 'function' &&
// https://github.com/facebook/react/issues/12011
!Object.isSealed(new Proxy({}, {}));
if (isProxySupported) {
/*eslint-disable no-func-assign */
SyntheticEvent = new Proxy(SyntheticEvent, {
construct: function (target, args) {
return this.apply(target, Object.create(target.prototype), args);
},
apply: function (constructor, that, args) {
return new Proxy(constructor.apply(that, args), {
set: function (target, prop, value) {
if (prop !== 'isPersistent' && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {
warning(didWarnForAddedNewProperty || target.isPersistent(), "This synthetic event is reused for performance reasons. If you're " + "seeing this, you're adding a new property in the synthetic event object. " + 'The property is never released. See ' + 'https://fb.me/react-event-pooling for more information.');
didWarnForAddedNewProperty = true;
}
target[prop] = value;
return true;
}
});
}
});
/*eslint-enable no-func-assign */
}
}
addEventPoolingTo(SyntheticEvent);
/**
* Helper to nullify syntheticEvent instance properties when destructing
*
* @param {String} propName
* @param {?object} getVal
* @return {object} defineProperty object
*/
function getPooledWarningPropertyDefinition(propName, getVal) {
var isFunction = typeof getVal === 'function';
return {
configurable: true,
set: set,
get: get
};
function set(val) {
var action = isFunction ? 'setting the method' : 'setting the property';
warn(action, 'This is effectively a no-op');
return val;
}
function get() {
var action = isFunction ? 'accessing the method' : 'accessing the property';
var result = isFunction ? 'This is a no-op function' : 'This is set to null';
warn(action, result);
return getVal;
}
function warn(action, result) {
var warningCondition = false;
warning(warningCondition, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result);
}
}
function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
var EventConstructor = this;
if (EventConstructor.eventPool.length) {
var instance = EventConstructor.eventPool.pop();
EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
return instance;
}
return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
}
function releasePooledEvent(event) {
var EventConstructor = this;
!(event instanceof EventConstructor) ? invariant(false, 'Trying to release an event instance into a pool of a different type.') : void 0;
event.destructor();
if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
EventConstructor.eventPool.push(event);
}
}
function addEventPoolingTo(EventConstructor) {
EventConstructor.eventPool = [];
EventConstructor.getPooled = getPooledEvent;
EventConstructor.release = releasePooledEvent;
}
var SyntheticEvent$1 = SyntheticEvent;
/**
* Generate a mapping of standard vendor prefixes using the defined style property and event name.
*
* @param {string} styleProp
* @param {string} eventName
* @returns {object}
*/
function makePrefixMap(styleProp, eventName) {
var prefixes = {};
prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
prefixes['Webkit' + styleProp] = 'webkit' + eventName;
prefixes['Moz' + styleProp] = 'moz' + eventName;
prefixes['ms' + styleProp] = 'MS' + eventName;
prefixes['O' + styleProp] = 'o' + eventName.toLowerCase();
return prefixes;
}
/**
* A list of event names to a configurable list of vendor prefixes.
*/
var vendorPrefixes = {
animationend: makePrefixMap('Animation', 'AnimationEnd'),
animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
animationstart: makePrefixMap('Animation', 'AnimationStart'),
transitionend: makePrefixMap('Transition', 'TransitionEnd')
};
/**
* Event names that have already been detected and prefixed (if applicable).
*/
var prefixedEventNames = {};
/**
* Element to check for prefixes on.
*/
var style = {};
/**
* Bootstrap if a DOM exists.
*/
if (ExecutionEnvironment.canUseDOM) {
style = document.createElement('div').style;
// On some platforms, in particular some releases of Android 4.x,
// the un-prefixed "animation" and "transition" properties are defined on the
// style object but the events that fire will still be prefixed, so we need
// to check if the un-prefixed events are usable, and if not remove them from the map.
if (!('AnimationEvent' in window)) {
delete vendorPrefixes.animationend.animation;
delete vendorPrefixes.animationiteration.animation;
delete vendorPrefixes.animationstart.animation;
}
// Same as above
if (!('TransitionEvent' in window)) {
delete vendorPrefixes.transitionend.transition;
}
}
/**
* Attempts to determine the correct vendor prefixed event name.
*
* @param {string} eventName
* @returns {string}
*/
function getVendorPrefixedEventName(eventName) {
if (prefixedEventNames[eventName]) {
return prefixedEventNames[eventName];
} else if (!vendorPrefixes[eventName]) {
return eventName;
}
var prefixMap = vendorPrefixes[eventName];
for (var styleProp in prefixMap) {
if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
return prefixedEventNames[eventName] = prefixMap[styleProp];
}
}
return eventName;
}
/**
* Types of raw signals from the browser caught at the top level.
*
* For events like 'submit' or audio/video events which don't consistently
* bubble (which we trap at a lower node than `document`), binding
* at `document` would cause duplicate events so we don't include them here.
*/
var topLevelTypes = {
topAnimationEnd: getVendorPrefixedEventName('animationend'),
topAnimationIteration: getVendorPrefixedEventName('animationiteration'),
topAnimationStart: getVendorPrefixedEventName('animationstart'),
topBlur: 'blur',
topCancel: 'cancel',
topChange: 'change',
topClick: 'click',
topClose: 'close',
topCompositionEnd: 'compositionend',
topCompositionStart: 'compositionstart',
topCompositionUpdate: 'compositionupdate',
topContextMenu: 'contextmenu',
topCopy: 'copy',
topCut: 'cut',
topDoubleClick: 'dblclick',
topDrag: 'drag',
topDragEnd: 'dragend',
topDragEnter: 'dragenter',
topDragExit: 'dragexit',
topDragLeave: 'dragleave',
topDragOver: 'dragover',
topDragStart: 'dragstart',
topDrop: 'drop',
topFocus: 'focus',
topInput: 'input',
topKeyDown: 'keydown',
topKeyPress: 'keypress',
topKeyUp: 'keyup',
topLoad: 'load',
topLoadStart: 'loadstart',
topMouseDown: 'mousedown',
topMouseMove: 'mousemove',
topMouseOut: 'mouseout',
topMouseOver: 'mouseover',
topMouseUp: 'mouseup',
topPaste: 'paste',
topScroll: 'scroll',
topSelectionChange: 'selectionchange',
topTextInput: 'textInput',
topToggle: 'toggle',
topTouchCancel: 'touchcancel',
topTouchEnd: 'touchend',
topTouchMove: 'touchmove',
topTouchStart: 'touchstart',
topTransitionEnd: getVendorPrefixedEventName('transitionend'),
topWheel: 'wheel'
};
// There are so many media events, it makes sense to just
// maintain a list of them. Note these aren't technically
// "top-level" since they don't bubble. We should come up
// with a better naming convention if we come to refactoring
// the event system.
var mediaEventTypes = {
topAbort: 'abort',
topCanPlay: 'canplay',
topCanPlayThrough: 'canplaythrough',
topDurationChange: 'durationchange',
topEmptied: 'emptied',
topEncrypted: 'encrypted',
topEnded: 'ended',
topError: 'error',
topLoadedData: 'loadeddata',
topLoadedMetadata: 'loadedmetadata',
topLoadStart: 'loadstart',
topPause: 'pause',
topPlay: 'play',
topPlaying: 'playing',
topProgress: 'progress',
topRateChange: 'ratechange',
topSeeked: 'seeked',
topSeeking: 'seeking',
topStalled: 'stalled',
topSuspend: 'suspend',
topTimeUpdate: 'timeupdate',
topVolumeChange: 'volumechange',
topWaiting: 'waiting'
};
var findDOMNode = ReactDOM.findDOMNode;
var _ReactDOM$__SECRET_IN = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
var EventPluginHub = _ReactDOM$__SECRET_IN.EventPluginHub;
var EventPluginRegistry = _ReactDOM$__SECRET_IN.EventPluginRegistry;
var EventPropagators = _ReactDOM$__SECRET_IN.EventPropagators;
var ReactControlledComponent = _ReactDOM$__SECRET_IN.ReactControlledComponent;
var ReactDOMComponentTree = _ReactDOM$__SECRET_IN.ReactDOMComponentTree;
var ReactDOMEventListener = _ReactDOM$__SECRET_IN.ReactDOMEventListener;
function Event(suffix) {}
/**
* @class ReactTestUtils
*/
function findAllInRenderedFiberTreeInternal(fiber, test) {
if (!fiber) {
return [];
}
var currentParent = findCurrentFiberUsingSlowPath(fiber);
if (!currentParent) {
return [];
}
var node = currentParent;
var ret = [];
while (true) {
if (node.tag === HostComponent || node.tag === HostText || node.tag === ClassComponent || node.tag === FunctionalComponent) {
var publicInst = node.stateNode;
if (test(publicInst)) {
ret.push(publicInst);
}
}
if (node.child) {
node.child['return'] = node;
node = node.child;
continue;
}
if (node === currentParent) {
return ret;
}
while (!node.sibling) {
if (!node['return'] || node['return'] === currentParent) {
return ret;
}
node = node['return'];
}
node.sibling['return'] = node['return'];
node = node.sibling;
}
}
/**
* Utilities for making it easy to test React components.
*
* See https://reactjs.org/docs/test-utils.html
*
* Todo: Support the entire DOM.scry query syntax. For now, these simple
* utilities will suffice for testing purposes.
* @lends ReactTestUtils
*/
var ReactTestUtils = {
renderIntoDocument: function (element) {
var div = document.createElement('div');
// None of our tests actually require attaching the container to the
// DOM, and doing so creates a mess that we rely on test isolation to
// clean up, so we're going to stop honoring the name of this method
// (and probably rename it eventually) if no problems arise.
// document.documentElement.appendChild(div);
return ReactDOM.render(element, div);
},
isElement: function (element) {
return React.isValidElement(element);
},
isElementOfType: function (inst, convenienceConstructor) {
return React.isValidElement(inst) && inst.type === convenienceConstructor;
},
isDOMComponent: function (inst) {
return !!(inst && inst.nodeType === 1 && inst.tagName);
},
isDOMComponentElement: function (inst) {
return !!(inst && React.isValidElement(inst) && !!inst.tagName);
},
isCompositeComponent: function (inst) {
if (ReactTestUtils.isDOMComponent(inst)) {
// Accessing inst.setState warns; just return false as that'll be what
// this returns when we have DOM nodes as refs directly
return false;
}
return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function';
},
isCompositeComponentWithType: function (inst, type) {
if (!ReactTestUtils.isCompositeComponent(inst)) {
return false;
}
var internalInstance = get(inst);
var constructor = internalInstance.type;
return constructor === type;
},
findAllInRenderedTree: function (inst, test) {
if (!inst) {
return [];
}
!ReactTestUtils.isCompositeComponent(inst) ? invariant(false, 'findAllInRenderedTree(...): instance must be a composite component') : void 0;
var internalInstance = get(inst);
return findAllInRenderedFiberTreeInternal(internalInstance, test);
},
/**
* Finds all instance of components in the rendered tree that are DOM
* components with the class name matching `className`.
* @return {array} an array of all the matches.
*/
scryRenderedDOMComponentsWithClass: function (root, classNames) {
return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
if (ReactTestUtils.isDOMComponent(inst)) {
var className = inst.className;
if (typeof className !== 'string') {
// SVG, probably.
className = inst.getAttribute('class') || '';
}
var classList = className.split(/\s+/);
if (!Array.isArray(classNames)) {
!(classNames !== undefined) ? invariant(false, 'TestUtils.scryRenderedDOMComponentsWithClass expects a className as a second argument.') : void 0;
classNames = classNames.split(/\s+/);
}
return classNames.every(function (name) {
return classList.indexOf(name) !== -1;
});
}
return false;
});
},
/**
* Like scryRenderedDOMComponentsWithClass but expects there to be one result,
* and returns that one result, or throws exception if there is any other
* number of matches besides one.
* @return {!ReactDOMComponent} The one match.
*/
findRenderedDOMComponentWithClass: function (root, className) {
var all = ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className);
if (all.length !== 1) {
throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for class:' + className);
}
return all[0];
},
/**
* Finds all instance of components in the rendered tree that are DOM
* components with the tag name matching `tagName`.
* @return {array} an array of all the matches.
*/
scryRenderedDOMComponentsWithTag: function (root, tagName) {
return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
return ReactTestUtils.isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase();
});
},
/**
* Like scryRenderedDOMComponentsWithTag but expects there to be one result,
* and returns that one result, or throws exception if there is any other
* number of matches besides one.
* @return {!ReactDOMComponent} The one match.
*/
findRenderedDOMComponentWithTag: function (root, tagName) {
var all = ReactTestUtils.scryRenderedDOMComponentsWithTag(root, tagName);
if (all.length !== 1) {
throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for tag:' + tagName);
}
return all[0];
},
/**
* Finds all instances of components with type equal to `componentType`.
* @return {array} an array of all the matches.
*/
scryRenderedComponentsWithType: function (root, componentType) {
return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
return ReactTestUtils.isCompositeComponentWithType(inst, componentType);
});
},
/**
* Same as `scryRenderedComponentsWithType` but expects there to be one result
* and returns that one result, or throws exception if there is any other
* number of matches besides one.
* @return {!ReactComponent} The one match.
*/
findRenderedComponentWithType: function (root, componentType) {
var all = ReactTestUtils.scryRenderedComponentsWithType(root, componentType);
if (all.length !== 1) {
throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
}
return all[0];
},
/**
* Pass a mocked component module to this method to augment it with
* useful methods that allow it to be used as a dummy React component.
* Instead of rendering as usual, the component will become a simple
* <div> containing any provided children.
*
* @param {object} module the mock function object exported from a
* module that defines the component to be mocked
* @param {?string} mockTagName optional dummy root tag name to return
* from render method (overrides
* module.mockTagName if provided)
* @return {object} the ReactTestUtils object (for chaining)
*/
mockComponent: function (module, mockTagName) {
mockTagName = mockTagName || module.mockTagName || 'div';
module.prototype.render.mockImplementation(function () {
return React.createElement(mockTagName, null, this.props.children);
});
return this;
},
/**
* Simulates a top level event being dispatched from a raw event that occurred
* on an `Element` node.
* @param {Object} topLevelType A type from `BrowserEventConstants.topLevelTypes`
* @param {!Element} node The dom to simulate an event occurring on.
* @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
*/
simulateNativeEventOnNode: function (topLevelType, node, fakeNativeEvent) {
fakeNativeEvent.target = node;
ReactDOMEventListener.dispatchEvent(topLevelType, fakeNativeEvent);
},
/**
* Simulates a top level event being dispatched from a raw event that occurred
* on the `ReactDOMComponent` `comp`.
* @param {Object} topLevelType A type from `BrowserEventConstants.topLevelTypes`.
* @param {!ReactDOMComponent} comp
* @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
*/
simulateNativeEventOnDOMComponent: function (topLevelType, comp, fakeNativeEvent) {
ReactTestUtils.simulateNativeEventOnNode(topLevelType, findDOMNode(comp), fakeNativeEvent);
},
nativeTouchData: function (x, y) {
return {
touches: [{ pageX: x, pageY: y }]
};
},
Simulate: null,
SimulateNative: {}
};
/**
* Exports:
*
* - `ReactTestUtils.Simulate.click(Element)`
* - `ReactTestUtils.Simulate.mouseMove(Element)`
* - `ReactTestUtils.Simulate.change(Element)`
* - ... (All keys from event plugin `eventTypes` objects)
*/
function makeSimulator(eventType) {
return function (domNode, eventData) {
!!React.isValidElement(domNode) ? invariant(false, 'TestUtils.Simulate expected a DOM node as the first argument but received a React element. Pass the DOM node you wish to simulate the event on instead. Note that TestUtils.Simulate will not work if you are using shallow rendering.') : void 0;
!!ReactTestUtils.isCompositeComponent(domNode) ? invariant(false, 'TestUtils.Simulate expected a DOM node as the first argument but received a component instance. Pass the DOM node you wish to simulate the event on instead.') : void 0;
var dispatchConfig = EventPluginRegistry.eventNameDispatchConfigs[eventType];
var fakeNativeEvent = new Event();
fakeNativeEvent.target = domNode;
fakeNativeEvent.type = eventType.toLowerCase();
// We don't use SyntheticEvent.getPooled in order to not have to worry about
// properly destroying any properties assigned from `eventData` upon release
var targetInst = ReactDOMComponentTree.getInstanceFromNode(domNode);
var event = new SyntheticEvent$1(dispatchConfig, targetInst, fakeNativeEvent, domNode);
// Since we aren't using pooling, always persist the event. This will make
// sure it's marked and won't warn when setting additional properties.
event.persist();
_assign(event, eventData);
if (dispatchConfig.phasedRegistrationNames) {
EventPropagators.accumulateTwoPhaseDispatches(event);
} else {
EventPropagators.accumulateDirectDispatches(event);
}
ReactDOM.unstable_batchedUpdates(function () {
// Normally extractEvent enqueues a state restore, but we'll just always
// do that since we we're by-passing it here.
ReactControlledComponent.enqueueStateRestore(domNode);
EventPluginHub.runEventsInBatch(event, true);
});
ReactControlledComponent.restoreStateIfNeeded();
};
}
function buildSimulators() {
ReactTestUtils.Simulate = {};
var eventType = void 0;
for (eventType in EventPluginRegistry.eventNameDispatchConfigs) {
/**
* @param {!Element|ReactDOMComponent} domComponentOrNode
* @param {?object} eventData Fake event data to use in SyntheticEvent.
*/
ReactTestUtils.Simulate[eventType] = makeSimulator(eventType);
}
}
// Rebuild ReactTestUtils.Simulate whenever event plugins are injected
var oldInjectEventPluginOrder = EventPluginHub.injection.injectEventPluginOrder;
EventPluginHub.injection.injectEventPluginOrder = function () {
oldInjectEventPluginOrder.apply(this, arguments);
buildSimulators();
};
var oldInjectEventPlugins = EventPluginHub.injection.injectEventPluginsByName;
EventPluginHub.injection.injectEventPluginsByName = function () {
oldInjectEventPlugins.apply(this, arguments);
buildSimulators();
};
buildSimulators();
/**
* Exports:
*
* - `ReactTestUtils.SimulateNative.click(Element/ReactDOMComponent)`
* - `ReactTestUtils.SimulateNative.mouseMove(Element/ReactDOMComponent)`
* - `ReactTestUtils.SimulateNative.mouseIn/ReactDOMComponent)`
* - `ReactTestUtils.SimulateNative.mouseOut(Element/ReactDOMComponent)`
* - ... (All keys from `BrowserEventConstants.topLevelTypes`)
*
* Note: Top level event types are a subset of the entire set of handler types
* (which include a broader set of "synthetic" events). For example, onDragDone
* is a synthetic event. Except when testing an event plugin or React's event
* handling code specifically, you probably want to use ReactTestUtils.Simulate
* to dispatch synthetic events.
*/
function makeNativeSimulator(eventType) {
return function (domComponentOrNode, nativeEventData) {
var fakeNativeEvent = new Event(eventType);
_assign(fakeNativeEvent, nativeEventData);
if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
ReactTestUtils.simulateNativeEventOnDOMComponent(eventType, domComponentOrNode, fakeNativeEvent);
} else if (domComponentOrNode.tagName) {
// Will allow on actual dom nodes.
ReactTestUtils.simulateNativeEventOnNode(eventType, domComponentOrNode, fakeNativeEvent);
}
};
}
var eventKeys = [].concat(Object.keys(topLevelTypes), Object.keys(mediaEventTypes));
eventKeys.forEach(function (eventType) {
// Event type is stored as 'topClick' - we transform that to 'click'
var convenienceName = eventType.indexOf('top') === 0 ? eventType.charAt(3).toLowerCase() + eventType.substr(4) : eventType;
/**
* @param {!Element|ReactDOMComponent} domComponentOrNode
* @param {?Event} nativeEventData Fake native event to use in SyntheticEvent.
*/
ReactTestUtils.SimulateNative[convenienceName] = makeNativeSimulator(eventType);
});
var ReactTestUtils$2 = Object.freeze({
default: ReactTestUtils
});
var ReactTestUtils$3 = ( ReactTestUtils$2 && ReactTestUtils ) || ReactTestUtils$2;
// TODO: decide on the top-level export form.
// This is hacky but makes it work with both Rollup and Jest.
var testUtils = ReactTestUtils$3['default'] ? ReactTestUtils$3['default'] : ReactTestUtils$3;
module.exports = testUtils;
})();
}
| mit |
mrward/RefactoringEssentials | RefactoringEssentials/CSharp/CodeRefactorings/Synced/ConvertCoalescingToConditionalExpressionCodeRefactoringProvider.cs | 2856 | using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Formatting;
namespace RefactoringEssentials.CSharp.CodeRefactorings
{
[ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = "Convert '??' to '?:'")]
public class ConvertCoalescingToConditionalExpressionCodeRefactoringProvider : CodeRefactoringProvider
{
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var document = context.Document;
if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
return;
var span = context.Span;
if (!span.IsEmpty)
return;
var cancellationToken = context.CancellationToken;
if (cancellationToken.IsCancellationRequested)
return;
var root = await document.GetSyntaxRootAsync(cancellationToken);
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
return;
var node = root.FindNode(span) as BinaryExpressionSyntax;
if (node == null || !node.OperatorToken.IsKind(SyntaxKind.QuestionQuestionToken))
return;
context.RegisterRefactoring(
CodeActionFactory.Create(
span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("Replace '??' operator with '?:' expression"), t2 =>
{
var left = node.Left;
var info = model.GetTypeInfo(left, t2);
if (info.ConvertedType.IsNullableType())
left = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, FlipEqualsTargetAndArgumentCodeRefactoringProvider.AddParensIfRequired(left), SyntaxFactory.IdentifierName("Value"));
var ternary = SyntaxFactory.ConditionalExpression(
SyntaxFactory.BinaryExpression(
SyntaxKind.NotEqualsExpression,
node.Left,
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)
),
left,
node.Right
).WithAdditionalAnnotations(Formatter.Annotation);
return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode((SyntaxNode)node, (ExpressionSyntax)ternary)));
}
)
);
}
}
} | mit |
mcclatchy/lunchbox | www/js/waterbug.js | 18520 | // DOM elements
var $source;
var $photographer;
var $save;
var $textColor;
var $logo;
var $crop;
var $logoColor;
var $imageLoader;
var $imageLink;
var $imageLinkButton;
var $canvas;
var canvas;
var $qualityQuestions;
var $copyrightHolder;
var $dragHelp;
var $filename;
var $fileinput;
var $customFilename;
// Constants
var IS_MOBILE = Modernizr.touch && Modernizr.mq('screen and max-width(700px)');
var MIME_TYPES = ['image/jpeg', 'image/png', 'image/gif'];
// state
var scaledImageHeight;
var scaledImageWidth;
var previewScale = IS_MOBILE ? 0.32 : 0.64;
var dy = 0;
var dx = 0;
var image;
var imageFilename = 'image';
var currentCopyright;
var credit = 'Belal Khan/Flickr'
var shallowImage = false;
// JS objects
var ctx;
var img = new Image();
var logo = new Image();
var onDocumentLoad = function(e) {
$source = $('#source');
$photographer = $('#photographer');
$canvas = $('#imageCanvas');
canvas = $canvas[0];
$imageLoader = $('#imageLoader');
$imageLink = $('#imageLink');
$imageLinkButton = $('#imageLinkButton');
ctx = canvas.getContext('2d');
$save = $('.save-btn');
$textColor = $('input[name="textColor"]');
$crop = $('input[name="crop"]');
$logoColor = $('input[name="logoColor"]');
$qualityQuestions = $('.quality-question');
$copyrightHolder = $('.copyright-holder');
$dragHelp = $('.drag-help');
$filename = $('.fileinput-filename');
$fileinput = $('.fileinput');
$customFilename = $('.custom-filename');
$logosWrapper = $('.logos-wrapper');
img.src = defaultImage;
img.onload = onImageLoad;
logo.src = defaultLogo;
logo.onload = renderCanvas;
$photographer.on('keyup', renderCanvas);
$source.on('keyup', renderCanvas);
$imageLoader.on('change', handleImage);
$imageLinkButton.on('click', handleImageLink);
$save.on('click', onSaveClick);
$textColor.on('change', onTextColorChange);
$logoColor.on('change', onLogoColorChange);
$crop.on('change', onCropChange);
$canvas.on('mousedown touchstart', onDrag);
$copyrightHolder.on('change', onCopyrightChange);
$customFilename.on('click', function(e) {
e.stopPropagation();
})
$("body").on("contextmenu", "canvas", function(e) {
return false;
});
$imageLink.keypress(function(e) {
if (e.keyCode == 13) {
handleImageLink();
}
});
// $imageLink.on('paste', handleImageLink);
$(window).on('resize', resizeCanvas);
resizeCanvas();
buildForm();
}
var resizeCanvas = function() {
var scale = $('.canvas-cell').width() / canvasWidth;
$canvas.css({
'webkitTransform': 'scale(' + scale + ')',
'MozTransform': 'scale(' + scale + ')',
'msTransform': 'scale(' + scale + ')',
'OTransform': 'scale(' + scale + ')',
'transform': 'scale(' + scale + ')'
});
renderCanvas();
}
var buildForm = function() {
var copyrightKeys = Object.keys(copyrightOptions);
var logoKeys = Object.keys(logos);
for (var i = 0; i < copyrightKeys.length; i++) {
var key = copyrightKeys[i];
var display = copyrightOptions[key]['display'];
$copyrightHolder.append('<option value="' + key + '">' + display + '</option>');
}
if (logoKeys.length > 1) {
$logosWrapper.append('<div class="btn-group btn-group-justified btn-group-sm logos" data-toggle="buttons"></div>');
var $logos = $('.logos');
for (var j = 0; j < logoKeys.length; j++) {
var key = logoKeys[j];
var display = logos[key]['display']
$logos.append('<label class="btn btn-primary"><input type="radio" name="logo" id="' + key + '" value="' + key + '">' + display + '</label>');
disableLogo();
if (key === currentLogo) {
$('#' + key).attr('checked', true);
$('#' + key).parent('.btn').addClass('active');
}
}
$logo = $('input[name="logo"]');
$logo.on('change', onLogoChange);
} else {
$logosWrapper.hide();
}
}
/*
* Draw the image, then the logo, then the text
*/
var renderCanvas = function() {
// canvas is always the same width
canvas.width = canvasWidth;
// if we're cropping, use the aspect ratio for the height
if (currentCrop !== 'original') {
canvas.height = canvasWidth / (16/9);
}
// clear the canvas
ctx.clearRect(0,0,canvas.width,canvas.height);
// determine height of canvas and scaled image, then draw the image
var imageAspect = img.width / img.height;
if (currentCrop === 'original') {
canvas.height = canvasWidth / imageAspect;
scaledImageHeight = canvas.height;
ctx.drawImage(
img,
0,
0,
canvasWidth,
scaledImageHeight
);
} else {
if (img.width / img.height > canvas.width / canvas.height) {
shallowImage = true;
scaledImageHeight = canvasWidth / imageAspect;
scaledImageWidth = canvas.height * (img.width / img.height)
ctx.drawImage(
img,
0,
0,
img.width,
img.height,
dx,
dy,
scaledImageWidth,
canvas.height
);
} else {
shallowImage = false;
scaledImageHeight = canvasWidth / imageAspect;
ctx.drawImage(
img,
0,
0,
img.width,
img.height,
dx,
dy,
canvasWidth,
scaledImageHeight
);
}
}
// set alpha channel, draw the logo
if (currentLogoColor === 'white') {
ctx.globalAlpha = whiteLogoAlpha;
} else {
ctx.globalAlpha = blackLogoAlpha;
}
ctx.drawImage(
logo,
elementPadding,
currentLogo === 'npr'? elementPadding : elementPadding - 14,
logos[currentLogo]['w'],
logos[currentLogo]['h']
);
// reset alpha channel so text is not translucent
ctx.globalAlpha = "1";
// draw the text
ctx.textBaseline = 'bottom';
ctx.textAlign = 'left';
ctx.fillStyle = currentTextColor;
ctx.font = fontWeight + ' ' + fontSize + ' ' + fontFace;
if (currentTextColor === 'white') {
ctx.shadowColor = fontShadow;
ctx.shadowOffsetX = fontShadowOffsetX;
ctx.shadowOffsetY = fontShadowOffsetY;
ctx.shadowBlur = fontShadowBlur;
}
if (currentCopyright) {
credit = buildCreditString();
}
var creditWidth = ctx.measureText(credit);
ctx.fillText(
credit,
canvas.width - (creditWidth.width + elementPadding),
canvas.height - elementPadding
);
validateForm();
}
/*
* Build the proper format for the credit based on current copyright
*/
var buildCreditString = function() {
var creditString;
var val = $copyrightHolder.val();
if ($photographer.val() !== '') {
if (copyrightOptions[val]['source']) {
creditString = $photographer.val() + '/' + copyrightOptions[val]['source'];
} else {
creditString = $photographer.val() + '/' + $source.val();
}
} else {
if (copyrightOptions[val]['source']) {
creditString = copyrightOptions[val]['source'];
} else {
creditString = $source.val();
}
}
if (copyrightOptions[val]['photographerRequired']) {
if ($photographer.val() !== '') {
$photographer.parents('.form-group').removeClass('has-warning');
} else {
$photographer.parents('.form-group').addClass('has-warning');
}
}
if (copyrightOptions[val]['sourceRequired']) {
if ($source.val() !== '') {
$source.parents('.form-group').removeClass('has-warning');
} else {
$source.parents('.form-group').addClass('has-warning');
}
}
return creditString;
}
/*
* Check to see if any required fields have not been
* filled out before enabling saving
*/
var validateForm = function() {
if ($('.has-warning').length === 0 && currentCopyright) {
$save.removeAttr('disabled');
$("body").off("contextmenu", "canvas");
} else {
$save.attr('disabled', '');
$("body").on("contextmenu", "canvas", function(e) {
return false;
});
}
}
/*
* Handle dragging the image for crops when applicable
*/
var onDrag = function(e) {
e.preventDefault();
var originY = e.clientY||e.originalEvent.targetTouches[0].clientY;
originY = originY/previewScale;
var originX = e.clientX||e.originalEvent.targetTouches[0].clientX;
originX = originX/previewScale;
var startY = dy;
var startX = dx;
if (currentCrop === 'original') {
return;
}
function update(e) {
var dragY = e.clientY||e.originalEvent.targetTouches[0].clientY;
dragY = dragY/previewScale;
var dragX = e.clientX||e.originalEvent.targetTouches[0].clientX;
dragX = dragX/previewScale;
if (shallowImage === false) {
if (Math.abs(dragY - originY) > 1) {
dy = startY - (originY - dragY);
// Prevent dragging image below upper bound
if (dy > 0) {
dy = 0;
return;
}
// Prevent dragging image above lower bound
if (dy < canvas.height - scaledImageHeight) {
dy = canvas.height - scaledImageHeight;
return;
}
renderCanvas();
}
} else {
if (Math.abs(dragX - originX) > 1) {
dx = startX - (originX - dragX);
// Prevent dragging image below left bound
if (dx > 0) {
dx = 0;
return;
}
// Prevent dragging image above right bound
if (dx < canvas.width - scaledImageWidth) {
dx = canvas.width - scaledImageWidth;
return;
}
renderCanvas();
}
}
}
// Perform drag sequence:
$(document).on('mousemove.drag touchmove', _.debounce(update, 5, true))
.on('mouseup.drag touchend', function(e) {
$(document).off('mouseup.drag touchmove mousemove.drag');
update(e);
});
}
/*
* Take an image from file input and load it
*/
var handleImage = function(e) {
var reader = new FileReader();
reader.onload = function(e){
// reset dy value
dy = 0;
dx = 0;
image = e.target.result;
imageFilename = $('.fileinput-filename').text().split('.')[0];
img.src = image;
$customFilename.text(imageFilename);
$customFilename.parents('.form-group').addClass('has-file');
$imageLink.val('');
$imageLink.parents('.form-group').removeClass('has-file');
}
reader.readAsDataURL(e.target.files[0]);
}
/*
* Load a remote image
*/
var handleImageLink = function(e) {
var requestStatus =
// Test if image URL returns a 200
$.ajax({
url: $imageLink.val(),
success: function(data, status, xhr) {
var responseType = xhr.getResponseHeader('content-type').toLowerCase();
// if content type is jpeg, gif or png, load the image into the canvas
if (MIME_TYPES.indexOf(responseType) >= 0) {
// reset dy value
dy = 0;
dx = 0;
$fileinput.fileinput('clear');
$imageLink.parents('.form-group').addClass('has-file').removeClass('has-error');
$imageLink.parents('.input-group').next().text('Click to edit name');
img.src = $imageLink.val();
img.crossOrigin = "anonymous"
var filename = $imageLink.val().split('/');
imageFilename = filename[filename.length - 1].split('.')[0];
$imageLink.val(imageFilename);
// otherwise, display an error
} else {
$imageLink.parents('.form-group').addClass('has-error');
$imageLink.parents('.input-group').next().text('Not a valid image URL');
return;
}
},
error: function(data) {
$imageLink.parents('.form-group').addClass('has-error');
$imageLink.parents('.input-group').next().text('Not a valid image URL');
}
});
}
/*
* Set dragging status based on image aspect ratio and render canvas
*/
var onImageLoad = function(e) {
renderCanvas();
onCropChange();
}
/*
* Load the logo based on radio buttons
*/
var loadLogo = function() {
if (currentLogoColor === 'white') {
logo.src = logos[currentLogo]['whitePath'];
} else {
logo.src = logos[currentLogo]['blackPath'];
}
disableLogo();
}
/*
* If image paths not defined for the logo, grey it out
*/
var disableLogo = function(){
var whiteLogo = logos[currentLogo]['whitePath']
var blackLogo = logos[currentLogo]['blackPath']
if(typeof(whiteLogo) == "undefined"){
$("#whiteLogo").parent().addClass("disabled")
}else{
$("#whiteLogo").parent().removeClass("disabled")
}
if(typeof(blackLogo) == "undefined"){
$("#blackLogo").parent().addClass("disabled")
}else{
$("#blackLogo").parent().removeClass("disabled")
}
}
/*
* Download the image on save click
*/
var onSaveClick = function(e) {
e.preventDefault();
/// create an "off-screen" anchor tag
var link = document.createElement('a'),
e;
/// the key here is to set the download attribute of the a tag
if ($customFilename.text()) {
imageFilename = $customFilename.text();
}
if ($imageLink.val() !== "") {
var filename = $imageLink.val().split('/');
imageFilename = filename[filename.length - 1].split('.')[0];
}
link.download = 'waterbug-' + imageFilename + '.png';
/// convert canvas content to data-uri for link. When download
/// attribute is set the content pointed to by link will be
/// pushed as "download" in HTML5 capable browsers
link.href = canvas.toDataURL();
link.target = "_blank";
/// create a "fake" click-event to trigger the download
if (document.createEvent) {
e = document.createEvent("MouseEvents");
e.initMouseEvent("click", true, true, window,
0, 0, 0, 0, 0, false, false, false,
false, 0, null);
link.dispatchEvent(e);
} else if (link.fireEvent) {
link.fireEvent("onclick");
}
}
/*
* Handle logo radio button clicks
*/
var onLogoColorChange = function(e) {
currentLogoColor = $(this).val();
loadLogo();
renderCanvas();
}
/*
* Handle text color radio button clicks
*/
var onTextColorChange = function(e) {
currentTextColor = $(this).val();
renderCanvas();
}
/*
* Handle logo radio button clicks
*/
var onLogoChange = function(e) {
currentLogo = $(this).val();
loadLogo();
renderCanvas();
}
/*
* Handle crop radio button clicks
*/
var onCropChange = function() {
currentCrop = $crop.filter(':checked').val();
if (currentCrop !== 'original') {
var dragClass = shallowImage ? 'is-draggable shallow' : 'is-draggable';
$canvas.addClass(dragClass);
$dragHelp.show();
} else {
$canvas.removeClass('is-draggable shallow');
$dragHelp.hide();
}
renderCanvas();
}
/*
* Show the appropriate fields based on the chosen copyright
*/
var onCopyrightChange = function() {
currentCopyright = $copyrightHolder.val();
$photographer.parents('.form-group').removeClass('has-warning');
$source.parents('.form-group').removeClass('has-warning');
if (copyrightOptions[currentCopyright]) {
if (copyrightOptions[currentCopyright]['showPhotographer']) {
$photographer.parents('.form-group').slideDown();
if (copyrightOptions[currentCopyright]['photographerRequired']) {
$photographer.parents('.form-group').addClass('has-warning required');
} else {
$photographer.parents('.form-group').removeClass('required')
}
} else {
$photographer.parents('.form-group').slideUp();
}
if (copyrightOptions[currentCopyright]['showSource']) {
$source.parents('.form-group').slideDown();
if (copyrightOptions[currentCopyright]['sourceRequired']) {
$source.parents('.form-group').addClass('has-warning required');
} else {
$source.parents('.form-group').removeClass('required')
}
} else {
$source.parents('.form-group').slideUp();
}
} else {
$photographer.parents('.form-group').slideUp();
$source.parents('.form-group').slideUp();
credit = '';
}
// if (currentCopyright === 'npr') {
// $photographer.parents('.form-group').removeClass('required').slideDown();
// $source.parents('.form-group').slideUp();
// } else if (currentCopyright === 'freelance') {
// $photographer.parents('.form-group').slideDown();
// $source.parents('.form-group').slideUp();
// $photographer.parents('.form-group').addClass('has-warning required');
// } else if (currentCopyright === 'ap' || currentCopyright === 'getty') {
// $photographer.parents('.form-group').removeClass('required').slideDown();
// $source.parents('.form-group')
// .slideUp()
// .removeClass('has-warning required');
// } else if (currentCopyright === 'third-party') {
// $photographer.parents('.form-group').removeClass('required').slideDown();
// $source.parents('.form-group').slideDown();
// $source.parents('.form-group').addClass('has-warning required');
// } else {
// credit = '';
// $photographer.parents('.form-group').slideUp();
// $source.parents('.form-group')
// .slideUp()
// .parents('.form-group').removeClass('has-warning required');
// }
renderCanvas();
}
$(onDocumentLoad);
| mit |
syouts/NWNX-Combat | include_v03/include/structs/CServerExoApp.h | 1094 | /*
* NWNeXalt - Empty File
* (c) 2007 Doug Swarin ([email protected])
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id$
* $HeadURL$
*
*/
#ifndef _NX_NWN_STRUCT_CSERVEREXOAPP_
#define _NX_NWN_STRUCT_CSERVEREXOAPP_
struct CServerExoApp_s {
u_int32_t field_00;
CServerExoAppInternal *srv_internal;
};
#endif /* _NX_NWN_STRUCT_CSERVEREXOAPP_ */
/* vim: set sw=4: */
| gpl-2.0 |
nabnut/zabbix2.0-cookies | upgrades/dbpatches/1.6/mysql/patch/scripts.sql | 518 | CREATE TABLE scripts (
scriptid bigint unsigned DEFAULT '0' NOT NULL,
name varchar(255) DEFAULT '' NOT NULL,
command varchar(255) DEFAULT '' NOT NULL,
host_access integer DEFAULT '2' NOT NULL,
usrgrpid bigint unsigned DEFAULT '0' NOT NULL,
groupid bigint unsigned DEFAULT '0' NOT NULL,
PRIMARY KEY (scriptid)
) ENGINE=InnoDB;
| gpl-2.0 |
paranoiacblack/gcc | libgo/go/time/zoneinfo_test.go | 1871 | // Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package time_test
import (
"testing"
"time"
)
func TestVersion3(t *testing.T) {
t.Skip("gccgo does not use the zip file")
time.ForceZipFileForTesting(true)
defer time.ForceZipFileForTesting(false)
_, err := time.LoadLocation("Asia/Jerusalem")
if err != nil {
t.Fatal(err)
}
}
// Test that we get the correct results for times before the first
// transition time. To do this we explicitly check early dates in a
// couple of specific timezones.
func TestFirstZone(t *testing.T) {
t.Skip("gccgo does not use the zip file")
time.ForceZipFileForTesting(true)
defer time.ForceZipFileForTesting(false)
const format = "Mon, 02 Jan 2006 15:04:05 -0700 (MST)"
var tests = []struct {
zone string
unix int64
want1 string
want2 string
}{
{
"PST8PDT",
-1633269601,
"Sun, 31 Mar 1918 01:59:59 -0800 (PST)",
"Sun, 31 Mar 1918 03:00:00 -0700 (PDT)",
},
{
"Pacific/Fakaofo",
1325242799,
"Thu, 29 Dec 2011 23:59:59 -1100 (TKT)",
"Sat, 31 Dec 2011 00:00:00 +1300 (TKT)",
},
}
for _, test := range tests {
z, err := time.LoadLocation(test.zone)
if err != nil {
t.Fatal(err)
}
s := time.Unix(test.unix, 0).In(z).Format(format)
if s != test.want1 {
t.Errorf("for %s %d got %q want %q", test.zone, test.unix, s, test.want1)
}
s = time.Unix(test.unix+1, 0).In(z).Format(format)
if s != test.want2 {
t.Errorf("for %s %d got %q want %q", test.zone, test.unix, s, test.want2)
}
}
}
func TestLocationNames(t *testing.T) {
if time.Local.String() != "Local" {
t.Errorf(`invalid Local location name: got %q want "Local"`, time.Local)
}
if time.UTC.String() != "UTC" {
t.Errorf(`invalid UTC location name: got %q want "UTC"`, time.UTC)
}
}
| gpl-2.0 |
SrNetoChan/QGIS | src/core/qgsfeature_p.h | 2506 | /***************************************************************************
qgsfeature_p.h
---------------
Date : May-2015
Copyright : (C) 2015 by Nyall Dawson
email : nyall dot dawson at gmail dot com
***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef QGSFEATURE_PRIVATE_H
#define QGSFEATURE_PRIVATE_H
/// @cond PRIVATE
//
// W A R N I N G
// -------------
//
// This file is not part of the QGIS API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
/***************************************************************************
* This class is considered CRITICAL and any change MUST be accompanied with
* full unit tests in testqgsfeature.cpp.
* See details in QEP #17
****************************************************************************/
#include "qgsfields.h"
#include "qgsgeometry.h"
class QgsFeaturePrivate : public QSharedData
{
public:
explicit QgsFeaturePrivate( QgsFeatureId id )
: fid( id )
, valid( false )
{
}
QgsFeaturePrivate( const QgsFeaturePrivate &other )
: QSharedData( other )
, fid( other.fid )
, attributes( other.attributes )
, geometry( other.geometry )
, valid( other.valid )
, fields( other.fields )
{
}
~QgsFeaturePrivate()
{
}
//! Feature ID
QgsFeatureId fid;
//! Attributes accessed by field index
QgsAttributes attributes;
//! Geometry, may be empty if feature has no geometry
QgsGeometry geometry;
//! Flag to indicate if this feature is valid
bool valid;
//! Optional field map for name-based attribute lookups
QgsFields fields;
private:
QgsFeaturePrivate &operator=( const QgsFeaturePrivate & ) = delete;
};
/// @endcond
#endif //QGSFEATURE_PRIVATE_H
| gpl-2.0 |
ErickReyes/kernel-mst3000 | include/linux/fs.h | 92694 | #ifndef _LINUX_FS_H
#define _LINUX_FS_H
/*
* This file has definitions for some important file table
* structures etc.
*/
#include <linux/limits.h>
#include <linux/ioctl.h>
#include <linux/blk_types.h>
#include <linux/types.h>
/*
* It's silly to have NR_OPEN bigger than NR_FILE, but you can change
* the file limit at runtime and only root can increase the per-process
* nr_file rlimit, so it's safe to set up a ridiculously high absolute
* upper limit on files-per-process.
*
* Some programs (notably those using select()) may have to be
* recompiled to take full advantage of the new limits..
*/
/* Fixed constants first: */
#undef NR_OPEN
#define INR_OPEN_CUR 1024 /* Initial setting for nfile rlimits */
#define INR_OPEN_MAX 4096 /* Hard limit for nfile rlimits */
#define BLOCK_SIZE_BITS 10
#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
#define SEEK_SET 0 /* seek relative to beginning of file */
#define SEEK_CUR 1 /* seek relative to current file position */
#define SEEK_END 2 /* seek relative to end of file */
#define SEEK_DATA 3 /* seek to the next data */
#define SEEK_HOLE 4 /* seek to the next hole */
#define SEEK_MAX SEEK_HOLE
struct fstrim_range {
__u64 start;
__u64 len;
__u64 minlen;
};
/* And dynamically-tunable limits and defaults: */
struct files_stat_struct {
unsigned long nr_files; /* read only */
unsigned long nr_free_files; /* read only */
unsigned long max_files; /* tunable */
};
struct inodes_stat_t {
int nr_inodes;
int nr_unused;
int dummy[5]; /* padding for sysctl ABI compatibility */
};
#define NR_FILE 8192 /* this can well be larger on a larger system */
#define MAY_EXEC 0x00000001
#define MAY_WRITE 0x00000002
#define MAY_READ 0x00000004
#define MAY_APPEND 0x00000008
#define MAY_ACCESS 0x00000010
#define MAY_OPEN 0x00000020
#define MAY_CHDIR 0x00000040
/* called from RCU mode, don't block */
#define MAY_NOT_BLOCK 0x00000080
/*
* flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
* to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
*/
/* file is open for reading */
#define FMODE_READ ((__force fmode_t)0x1)
/* file is open for writing */
#define FMODE_WRITE ((__force fmode_t)0x2)
/* file is seekable */
#define FMODE_LSEEK ((__force fmode_t)0x4)
/* file can be accessed using pread */
#define FMODE_PREAD ((__force fmode_t)0x8)
/* file can be accessed using pwrite */
#define FMODE_PWRITE ((__force fmode_t)0x10)
/* File is opened for execution with sys_execve / sys_uselib */
#define FMODE_EXEC ((__force fmode_t)0x20)
/* File is opened with O_NDELAY (only set for block devices) */
#define FMODE_NDELAY ((__force fmode_t)0x40)
/* File is opened with O_EXCL (only set for block devices) */
#define FMODE_EXCL ((__force fmode_t)0x80)
/* File is opened using open(.., 3, ..) and is writeable only for ioctls
(specialy hack for floppy.c) */
#define FMODE_WRITE_IOCTL ((__force fmode_t)0x100)
/*
* Don't update ctime and mtime.
*
* Currently a special hack for the XFS open_by_handle ioctl, but we'll
* hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
*/
#define FMODE_NOCMTIME ((__force fmode_t)0x800)
/* Expect random access pattern */
#define FMODE_RANDOM ((__force fmode_t)0x1000)
/* File is huge (eg. /dev/kmem): treat loff_t as unsigned */
#define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000)
/* File is opened with O_PATH; almost nothing can be done with it */
#define FMODE_PATH ((__force fmode_t)0x4000)
/* File was opened by fanotify and shouldn't generate fanotify events */
#define FMODE_NONOTIFY ((__force fmode_t)0x1000000)
/*
* The below are the various read and write types that we support. Some of
* them include behavioral modifiers that send information down to the
* block layer and IO scheduler. Terminology:
*
* The block layer uses device plugging to defer IO a little bit, in
* the hope that we will see more IO very shortly. This increases
* coalescing of adjacent IO and thus reduces the number of IOs we
* have to send to the device. It also allows for better queuing,
* if the IO isn't mergeable. If the caller is going to be waiting
* for the IO, then he must ensure that the device is unplugged so
* that the IO is dispatched to the driver.
*
* All IO is handled async in Linux. This is fine for background
* writes, but for reads or writes that someone waits for completion
* on, we want to notify the block layer and IO scheduler so that they
* know about it. That allows them to make better scheduling
* decisions. So when the below references 'sync' and 'async', it
* is referencing this priority hint.
*
* With that in mind, the available types are:
*
* READ A normal read operation. Device will be plugged.
* READ_SYNC A synchronous read. Device is not plugged, caller can
* immediately wait on this read without caring about
* unplugging.
* READA Used for read-ahead operations. Lower priority, and the
* block layer could (in theory) choose to ignore this
* request if it runs into resource problems.
* WRITE A normal async write. Device will be plugged.
* WRITE_SYNC Synchronous write. Identical to WRITE, but passes down
* the hint that someone will be waiting on this IO
* shortly. The write equivalent of READ_SYNC.
* WRITE_ODIRECT Special case write for O_DIRECT only.
* WRITE_FLUSH Like WRITE_SYNC but with preceding cache flush.
* WRITE_FUA Like WRITE_SYNC but data is guaranteed to be on
* non-volatile media on completion.
* WRITE_FLUSH_FUA Combination of WRITE_FLUSH and FUA. The IO is preceded
* by a cache flush and data is guaranteed to be on
* non-volatile media on completion.
*
*/
#define RW_MASK REQ_WRITE
#define RWA_MASK REQ_RAHEAD
#define READ 0
#define WRITE RW_MASK
#define READA RWA_MASK
#define READ_SYNC (READ | REQ_SYNC)
#define WRITE_SYNC (WRITE | REQ_SYNC | REQ_NOIDLE)
#define WRITE_ODIRECT (WRITE | REQ_SYNC)
#define WRITE_FLUSH (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH)
#define WRITE_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FUA)
#define WRITE_FLUSH_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH | REQ_FUA)
#define SEL_IN 1
#define SEL_OUT 2
#define SEL_EX 4
/* public flags for file_system_type */
#define FS_REQUIRES_DEV 1
#define FS_BINARY_MOUNTDATA 2
#define FS_HAS_SUBTYPE 4
#define FS_REVAL_DOT 16384 /* Check the paths ".", ".." for staleness */
#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move()
* during rename() internally.
*/
/*
* These are the fs-independent mount-flags: up to 32 flags are supported
*/
#define MS_RDONLY 1 /* Mount read-only */
#define MS_NOSUID 2 /* Ignore suid and sgid bits */
#define MS_NODEV 4 /* Disallow access to device special files */
#define MS_NOEXEC 8 /* Disallow program execution */
#define MS_SYNCHRONOUS 16 /* Writes are synced at once */
#define MS_REMOUNT 32 /* Alter flags of a mounted FS */
#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
#define MS_DIRSYNC 128 /* Directory modifications are synchronous */
#define MS_NOATIME 1024 /* Do not update access times. */
#define MS_NODIRATIME 2048 /* Do not update directory access times */
#define MS_BIND 4096
#define MS_MOVE 8192
#define MS_REC 16384
#define MS_VERBOSE 32768 /* War is peace. Verbosity is silence.
MS_VERBOSE is deprecated. */
#define MS_SILENT 32768
#define MS_POSIXACL (1<<16) /* VFS does not apply the umask */
#define MS_UNBINDABLE (1<<17) /* change to unbindable */
#define MS_PRIVATE (1<<18) /* change to private */
#define MS_SLAVE (1<<19) /* change to slave */
#define MS_SHARED (1<<20) /* change to shared */
#define MS_RELATIME (1<<21) /* Update atime relative to mtime/ctime. */
#define MS_KERNMOUNT (1<<22) /* this is a kern_mount call */
#define MS_I_VERSION (1<<23) /* Update inode I_version field */
#define MS_STRICTATIME (1<<24) /* Always perform atime updates */
#define MS_NOSEC (1<<28)
#define MS_BORN (1<<29)
#define MS_ACTIVE (1<<30)
#define MS_NOUSER (1<<31)
/*
* Superblock flags that can be altered by MS_REMOUNT
*/
#define MS_RMT_MASK (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_I_VERSION)
/*
* Old magic mount flag and mask
*/
#define MS_MGC_VAL 0xC0ED0000
#define MS_MGC_MSK 0xffff0000
/* Inode flags - they have nothing to superblock flags now */
#define S_SYNC 1 /* Writes are synced at once */
#define S_NOATIME 2 /* Do not update access times */
#define S_APPEND 4 /* Append-only file */
#define S_IMMUTABLE 8 /* Immutable file */
#define S_DEAD 16 /* removed, but still open directory */
#define S_NOQUOTA 32 /* Inode is not counted to quota */
#define S_DIRSYNC 64 /* Directory modifications are synchronous */
#define S_NOCMTIME 128 /* Do not update file c/mtime */
#define S_SWAPFILE 256 /* Do not truncate: swapon got its bmaps */
#define S_PRIVATE 512 /* Inode is fs-internal */
#define S_IMA 1024 /* Inode has an associated IMA struct */
#define S_AUTOMOUNT 2048 /* Automount/referral quasi-directory */
#define S_NOSEC 4096 /* no suid or xattr security attributes */
/*
* Note that nosuid etc flags are inode-specific: setting some file-system
* flags just means all the inodes inherit those flags by default. It might be
* possible to override it selectively if you really wanted to with some
* ioctl() that is not currently implemented.
*
* Exception: MS_RDONLY is always applied to the entire file system.
*
* Unfortunately, it is possible to change a filesystems flags with it mounted
* with files in use. This means that all of the inodes will not have their
* i_flags updated. Hence, i_flags no longer inherit the superblock mount
* flags, so these have to be checked separately. -- [email protected]
*/
#define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
#define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
#define IS_SYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS) || \
((inode)->i_flags & S_SYNC))
#define IS_DIRSYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
#define IS_MANDLOCK(inode) __IS_FLG(inode, MS_MANDLOCK)
#define IS_NOATIME(inode) __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
#define IS_I_VERSION(inode) __IS_FLG(inode, MS_I_VERSION)
#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
#define IS_POSIXACL(inode) __IS_FLG(inode, MS_POSIXACL)
#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
/* the read-only stuff doesn't really belong here, but any other place is
probably as bad and I don't want to create yet another include file. */
#define BLKROSET _IO(0x12,93) /* set device read-only (0 = read-write) */
#define BLKROGET _IO(0x12,94) /* get read-only status (0 = read_write) */
#define BLKRRPART _IO(0x12,95) /* re-read partition table */
#define BLKGETSIZE _IO(0x12,96) /* return device size /512 (long *arg) */
#define BLKFLSBUF _IO(0x12,97) /* flush buffer cache */
#define BLKRASET _IO(0x12,98) /* set read ahead for block device */
#define BLKRAGET _IO(0x12,99) /* get current read ahead setting */
#define BLKFRASET _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
#define BLKFRAGET _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
#define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
#define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
#define BLKSSZGET _IO(0x12,104)/* get block device sector size */
#if 0
#define BLKPG _IO(0x12,105)/* See blkpg.h */
/* Some people are morons. Do not use sizeof! */
#define BLKELVGET _IOR(0x12,106,size_t)/* elevator get */
#define BLKELVSET _IOW(0x12,107,size_t)/* elevator set */
/* This was here just to show that the number is taken -
probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
#endif
/* A jump here: 108-111 have been used for various private purposes. */
#define BLKBSZGET _IOR(0x12,112,size_t)
#define BLKBSZSET _IOW(0x12,113,size_t)
#define BLKGETSIZE64 _IOR(0x12,114,size_t) /* return device size in bytes (u64 *arg) */
#define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
#define BLKTRACESTART _IO(0x12,116)
#define BLKTRACESTOP _IO(0x12,117)
#define BLKTRACETEARDOWN _IO(0x12,118)
#define BLKDISCARD _IO(0x12,119)
#define BLKIOMIN _IO(0x12,120)
#define BLKIOOPT _IO(0x12,121)
#define BLKALIGNOFF _IO(0x12,122)
#define BLKPBSZGET _IO(0x12,123)
#define BLKDISCARDZEROES _IO(0x12,124)
#define BLKSECDISCARD _IO(0x12,125)
#define BMAP_IOCTL 1 /* obsolete - kept for compatibility */
#define FIBMAP _IO(0x00,1) /* bmap access */
#define FIGETBSZ _IO(0x00,2) /* get the block size used for bmap */
#define FIFREEZE _IOWR('X', 119, int) /* Freeze */
#define FITHAW _IOWR('X', 120, int) /* Thaw */
#define FITRIM _IOWR('X', 121, struct fstrim_range) /* Trim */
#define FS_IOC_GETFLAGS _IOR('f', 1, long)
#define FS_IOC_SETFLAGS _IOW('f', 2, long)
#define FS_IOC_GETVERSION _IOR('v', 1, long)
#define FS_IOC_SETVERSION _IOW('v', 2, long)
#define FS_IOC_FIEMAP _IOWR('f', 11, struct fiemap)
#define FS_IOC32_GETFLAGS _IOR('f', 1, int)
#define FS_IOC32_SETFLAGS _IOW('f', 2, int)
#define FS_IOC32_GETVERSION _IOR('v', 1, int)
#define FS_IOC32_SETVERSION _IOW('v', 2, int)
/*
* Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
*/
#define FS_SECRM_FL 0x00000001 /* Secure deletion */
#define FS_UNRM_FL 0x00000002 /* Undelete */
#define FS_COMPR_FL 0x00000004 /* Compress file */
#define FS_SYNC_FL 0x00000008 /* Synchronous updates */
#define FS_IMMUTABLE_FL 0x00000010 /* Immutable file */
#define FS_APPEND_FL 0x00000020 /* writes to file may only append */
#define FS_NODUMP_FL 0x00000040 /* do not dump file */
#define FS_NOATIME_FL 0x00000080 /* do not update atime */
/* Reserved for compression usage... */
#define FS_DIRTY_FL 0x00000100
#define FS_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
#define FS_NOCOMP_FL 0x00000400 /* Don't compress */
#define FS_ECOMPR_FL 0x00000800 /* Compression error */
/* End compression flags --- maybe not all used */
#define FS_BTREE_FL 0x00001000 /* btree format dir */
#define FS_INDEX_FL 0x00001000 /* hash-indexed directory */
#define FS_IMAGIC_FL 0x00002000 /* AFS directory */
#define FS_JOURNAL_DATA_FL 0x00004000 /* Reserved for ext3 */
#define FS_NOTAIL_FL 0x00008000 /* file tail should not be merged */
#define FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
#define FS_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
#define FS_EXTENT_FL 0x00080000 /* Extents */
#define FS_DIRECTIO_FL 0x00100000 /* Use direct i/o */
#define FS_NOCOW_FL 0x00800000 /* Do not cow file */
#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */
#define FS_FL_USER_MODIFIABLE 0x000380FF /* User modifiable flags */
#define SYNC_FILE_RANGE_WAIT_BEFORE 1
#define SYNC_FILE_RANGE_WRITE 2
#define SYNC_FILE_RANGE_WAIT_AFTER 4
#ifdef __KERNEL__
#include <linux/linkage.h>
#include <linux/wait.h>
#include <linux/kdev_t.h>
#include <linux/dcache.h>
#include <linux/path.h>
#include <linux/stat.h>
#include <linux/cache.h>
#include <linux/list.h>
#include <linux/radix-tree.h>
#include <linux/prio_tree.h>
#include <linux/init.h>
#include <linux/pid.h>
#include <linux/mutex.h>
#include <linux/capability.h>
#include <linux/semaphore.h>
#include <linux/fiemap.h>
#include <linux/rculist_bl.h>
#include <linux/atomic.h>
#include <linux/shrinker.h>
#include <asm/byteorder.h>
struct export_operations;
struct hd_geometry;
struct iovec;
struct nameidata;
struct kiocb;
struct kobject;
struct pipe_inode_info;
struct poll_table_struct;
struct kstatfs;
struct vm_area_struct;
struct vfsmount;
struct cred;
extern void __init inode_init(void);
extern void __init inode_init_early(void);
extern void __init files_init(unsigned long);
extern struct files_stat_struct files_stat;
extern unsigned long get_max_files(void);
extern int sysctl_nr_open;
extern struct inodes_stat_t inodes_stat;
extern int leases_enable, lease_break_time;
struct buffer_head;
typedef int (get_block_t)(struct inode *inode, sector_t iblock,
struct buffer_head *bh_result, int create);
typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
ssize_t bytes, void *private, int ret,
bool is_async);
/*
* Attribute flags. These should be or-ed together to figure out what
* has been changed!
*/
#define ATTR_MODE (1 << 0)
#define ATTR_UID (1 << 1)
#define ATTR_GID (1 << 2)
#define ATTR_SIZE (1 << 3)
#define ATTR_ATIME (1 << 4)
#define ATTR_MTIME (1 << 5)
#define ATTR_CTIME (1 << 6)
#define ATTR_ATIME_SET (1 << 7)
#define ATTR_MTIME_SET (1 << 8)
#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
#define ATTR_ATTR_FLAG (1 << 10)
#define ATTR_KILL_SUID (1 << 11)
#define ATTR_KILL_SGID (1 << 12)
#define ATTR_FILE (1 << 13)
#define ATTR_KILL_PRIV (1 << 14)
#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
#define ATTR_TIMES_SET (1 << 16)
/*
* This is the Inode Attributes structure, used for notify_change(). It
* uses the above definitions as flags, to know which values have changed.
* Also, in this manner, a Filesystem can look at only the values it cares
* about. Basically, these are the attributes that the VFS layer can
* request to change from the FS layer.
*
* Derek Atkins <[email protected]> 94-10-20
*/
struct iattr {
unsigned int ia_valid;
umode_t ia_mode;
uid_t ia_uid;
gid_t ia_gid;
loff_t ia_size;
struct timespec ia_atime;
struct timespec ia_mtime;
struct timespec ia_ctime;
/*
* Not an attribute, but an auxiliary info for filesystems wanting to
* implement an ftruncate() like method. NOTE: filesystem should
* check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
*/
struct file *ia_file;
};
/*
* Includes for diskquotas.
*/
#include <linux/quota.h>
/**
* enum positive_aop_returns - aop return codes with specific semantics
*
* @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
* completed, that the page is still locked, and
* should be considered active. The VM uses this hint
* to return the page to the active list -- it won't
* be a candidate for writeback again in the near
* future. Other callers must be careful to unlock
* the page if they get this return. Returned by
* writepage();
*
* @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
* unlocked it and the page might have been truncated.
* The caller should back up to acquiring a new page and
* trying again. The aop will be taking reasonable
* precautions not to livelock. If the caller held a page
* reference, it should drop it before retrying. Returned
* by readpage().
*
* address_space_operation functions return these large constants to indicate
* special semantics to the caller. These are much larger than the bytes in a
* page to allow for functions that return the number of bytes operated on in a
* given page.
*/
enum positive_aop_returns {
AOP_WRITEPAGE_ACTIVATE = 0x80000,
AOP_TRUNCATED_PAGE = 0x80001,
};
#define AOP_FLAG_UNINTERRUPTIBLE 0x0001 /* will not do a short write */
#define AOP_FLAG_CONT_EXPAND 0x0002 /* called from cont_expand */
#define AOP_FLAG_NOFS 0x0004 /* used by filesystem to direct
* helper code (eg buffer layer)
* to clear GFP_FS from alloc */
/*
* oh the beauties of C type declarations.
*/
struct page;
struct address_space;
struct writeback_control;
struct iov_iter {
const struct iovec *iov;
unsigned long nr_segs;
size_t iov_offset;
size_t count;
};
size_t iov_iter_copy_from_user_atomic(struct page *page,
struct iov_iter *i, unsigned long offset, size_t bytes);
size_t iov_iter_copy_from_user(struct page *page,
struct iov_iter *i, unsigned long offset, size_t bytes);
void iov_iter_advance(struct iov_iter *i, size_t bytes);
int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
size_t iov_iter_single_seg_count(struct iov_iter *i);
static inline void iov_iter_init(struct iov_iter *i,
const struct iovec *iov, unsigned long nr_segs,
size_t count, size_t written)
{
i->iov = iov;
i->nr_segs = nr_segs;
i->iov_offset = 0;
i->count = count + written;
iov_iter_advance(i, written);
}
static inline size_t iov_iter_count(struct iov_iter *i)
{
return i->count;
}
/*
* "descriptor" for what we're up to with a read.
* This allows us to use the same read code yet
* have multiple different users of the data that
* we read from a file.
*
* The simplest case just copies the data to user
* mode.
*/
typedef struct {
size_t written;
size_t count;
union {
char __user *buf;
void *data;
} arg;
int error;
} read_descriptor_t;
typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
unsigned long, unsigned long);
struct address_space_operations {
int (*writepage)(struct page *page, struct writeback_control *wbc);
int (*readpage)(struct file *, struct page *);
/* Write back some dirty pages from this mapping. */
int (*writepages)(struct address_space *, struct writeback_control *);
/* Set a page dirty. Return true if this dirtied it */
int (*set_page_dirty)(struct page *page);
int (*readpages)(struct file *filp, struct address_space *mapping,
struct list_head *pages, unsigned nr_pages);
int (*write_begin)(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata);
int (*write_end)(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata);
/* Unfortunately this kludge is needed for FIBMAP. Don't use it */
sector_t (*bmap)(struct address_space *, sector_t);
void (*invalidatepage) (struct page *, unsigned long);
int (*releasepage) (struct page *, gfp_t);
void (*freepage)(struct page *);
ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
loff_t offset, unsigned long nr_segs);
int (*get_xip_mem)(struct address_space *, pgoff_t, int,
void **, unsigned long *);
/* migrate the contents of a page to the specified target */
int (*migratepage) (struct address_space *,
struct page *, struct page *);
int (*launder_page) (struct page *);
int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
unsigned long);
int (*error_remove_page)(struct address_space *, struct page *);
};
extern const struct address_space_operations empty_aops;
/*
* pagecache_write_begin/pagecache_write_end must be used by general code
* to write into the pagecache.
*/
int pagecache_write_begin(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata);
int pagecache_write_end(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata);
struct backing_dev_info;
struct address_space {
struct inode *host; /* owner: inode, block_device */
struct radix_tree_root page_tree; /* radix tree of all pages */
spinlock_t tree_lock; /* and lock protecting it */
unsigned int i_mmap_writable;/* count VM_SHARED mappings */
struct prio_tree_root i_mmap; /* tree of private and shared mappings */
struct list_head i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
struct mutex i_mmap_mutex; /* protect tree, count, list */
/* Protected by tree_lock together with the radix tree */
unsigned long nrpages; /* number of total pages */
pgoff_t writeback_index;/* writeback starts here */
const struct address_space_operations *a_ops; /* methods */
unsigned long flags; /* error bits/gfp mask */
struct backing_dev_info *backing_dev_info; /* device readahead, etc */
spinlock_t private_lock; /* for use by the address_space */
struct list_head private_list; /* ditto */
struct address_space *assoc_mapping; /* ditto */
} __attribute__((aligned(sizeof(long))));
/*
* On most architectures that alignment is already the case; but
* must be enforced here for CRIS, to let the least significant bit
* of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
*/
struct block_device {
dev_t bd_dev; /* not a kdev_t - it's a search key */
int bd_openers;
struct inode * bd_inode; /* will die */
struct super_block * bd_super;
struct mutex bd_mutex; /* open/close mutex */
struct list_head bd_inodes;
void * bd_claiming;
void * bd_holder;
int bd_holders;
bool bd_write_holder;
#ifdef CONFIG_SYSFS
struct list_head bd_holder_disks;
#endif
struct block_device * bd_contains;
unsigned bd_block_size;
struct hd_struct * bd_part;
/* number of times partitions within this device have been opened. */
unsigned bd_part_count;
int bd_invalidated;
struct gendisk * bd_disk;
struct list_head bd_list;
/*
* Private data. You must have bd_claim'ed the block_device
* to use this. NOTE: bd_claim allows an owner to claim
* the same device multiple times, the owner must take special
* care to not mess up bd_private for that case.
*/
unsigned long bd_private;
/* The counter of freeze processes */
int bd_fsfreeze_count;
/* Mutex for freeze */
struct mutex bd_fsfreeze_mutex;
};
/*
* Radix-tree tags, for tagging dirty and writeback pages within the pagecache
* radix trees
*/
#define PAGECACHE_TAG_DIRTY 0
#define PAGECACHE_TAG_WRITEBACK 1
#define PAGECACHE_TAG_TOWRITE 2
int mapping_tagged(struct address_space *mapping, int tag);
/*
* Might pages of this file be mapped into userspace?
*/
static inline int mapping_mapped(struct address_space *mapping)
{
return !prio_tree_empty(&mapping->i_mmap) ||
!list_empty(&mapping->i_mmap_nonlinear);
}
/*
* Might pages of this file have been modified in userspace?
* Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
* marks vma as VM_SHARED if it is shared, and the file was opened for
* writing i.e. vma may be mprotected writable even if now readonly.
*/
static inline int mapping_writably_mapped(struct address_space *mapping)
{
return mapping->i_mmap_writable != 0;
}
/*
* Use sequence counter to get consistent i_size on 32-bit processors.
*/
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
#include <linux/seqlock.h>
#define __NEED_I_SIZE_ORDERED
#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
#else
#define i_size_ordered_init(inode) do { } while (0)
#endif
struct posix_acl;
#define ACL_NOT_CACHED ((void *)(-1))
#define IOP_FASTPERM 0x0001
#define IOP_LOOKUP 0x0002
#define IOP_NOFOLLOW 0x0004
/*
* Keep mostly read-only and often accessed (especially for
* the RCU path lookup and 'stat' data) fields at the beginning
* of the 'struct inode'
*/
struct inode {
umode_t i_mode;
unsigned short i_opflags;
uid_t i_uid;
gid_t i_gid;
unsigned int i_flags;
#ifdef CONFIG_FS_POSIX_ACL
struct posix_acl *i_acl;
struct posix_acl *i_default_acl;
#endif
const struct inode_operations *i_op;
struct super_block *i_sb;
struct address_space *i_mapping;
#ifdef CONFIG_SECURITY
void *i_security;
#endif
/* Stat data, not accessed from path walking */
unsigned long i_ino;
/*
* Filesystems may only read i_nlink directly. They shall use the
* following functions for modification:
*
* (set|clear|inc|drop)_nlink
* inode_(inc|dec)_link_count
*/
union {
const unsigned int i_nlink;
unsigned int __i_nlink;
};
dev_t i_rdev;
struct timespec i_atime;
struct timespec i_mtime;
struct timespec i_ctime;
spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
unsigned short i_bytes;
blkcnt_t i_blocks;
loff_t i_size;
#ifdef __NEED_I_SIZE_ORDERED
seqcount_t i_size_seqcount;
#endif
/* Misc */
unsigned long i_state;
struct mutex i_mutex;
unsigned long dirtied_when; /* jiffies of first dirtying */
struct hlist_node i_hash;
struct list_head i_wb_list; /* backing dev IO list */
struct list_head i_lru; /* inode LRU list */
struct list_head i_sb_list;
union {
struct list_head i_dentry;
struct rcu_head i_rcu;
};
atomic_t i_count;
unsigned int i_blkbits;
u64 i_version;
atomic_t i_dio_count;
atomic_t i_writecount;
const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
struct file_lock *i_flock;
struct address_space i_data;
#ifdef CONFIG_QUOTA
struct dquot *i_dquot[MAXQUOTAS];
#endif
struct list_head i_devices;
union {
struct pipe_inode_info *i_pipe;
struct block_device *i_bdev;
struct cdev *i_cdev;
};
__u32 i_generation;
#ifdef CONFIG_FSNOTIFY
__u32 i_fsnotify_mask; /* all events this inode cares about */
struct hlist_head i_fsnotify_marks;
#endif
#ifdef CONFIG_IMA
atomic_t i_readcount; /* struct files open RO */
#endif
void *i_private; /* fs or device private pointer */
};
static inline int inode_unhashed(struct inode *inode)
{
return hlist_unhashed(&inode->i_hash);
}
/*
* inode->i_mutex nesting subclasses for the lock validator:
*
* 0: the object of the current VFS operation
* 1: parent
* 2: child/target
* 3: quota file
*
* The locking order between these classes is
* parent -> child -> normal -> xattr -> quota
*/
enum inode_i_mutex_lock_class
{
I_MUTEX_NORMAL,
I_MUTEX_PARENT,
I_MUTEX_CHILD,
I_MUTEX_XATTR,
I_MUTEX_QUOTA
};
/*
* NOTE: in a 32bit arch with a preemptable kernel and
* an UP compile the i_size_read/write must be atomic
* with respect to the local cpu (unlike with preempt disabled),
* but they don't need to be atomic with respect to other cpus like in
* true SMP (so they need either to either locally disable irq around
* the read or for example on x86 they can be still implemented as a
* cmpxchg8b without the need of the lock prefix). For SMP compiles
* and 64bit archs it makes no difference if preempt is enabled or not.
*/
static inline loff_t i_size_read(const struct inode *inode)
{
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
loff_t i_size;
unsigned int seq;
do {
seq = read_seqcount_begin(&inode->i_size_seqcount);
i_size = inode->i_size;
} while (read_seqcount_retry(&inode->i_size_seqcount, seq));
return i_size;
#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
loff_t i_size;
preempt_disable();
i_size = inode->i_size;
preempt_enable();
return i_size;
#else
return inode->i_size;
#endif
}
/*
* NOTE: unlike i_size_read(), i_size_write() does need locking around it
* (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
* can be lost, resulting in subsequent i_size_read() calls spinning forever.
*/
static inline void i_size_write(struct inode *inode, loff_t i_size)
{
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
write_seqcount_begin(&inode->i_size_seqcount);
inode->i_size = i_size;
write_seqcount_end(&inode->i_size_seqcount);
#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
preempt_disable();
inode->i_size = i_size;
preempt_enable();
#else
inode->i_size = i_size;
#endif
}
static inline unsigned iminor(const struct inode *inode)
{
return MINOR(inode->i_rdev);
}
static inline unsigned imajor(const struct inode *inode)
{
return MAJOR(inode->i_rdev);
}
extern struct block_device *I_BDEV(struct inode *inode);
struct fown_struct {
rwlock_t lock; /* protects pid, uid, euid fields */
struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
uid_t uid, euid; /* uid/euid of process setting the owner */
int signum; /* posix.1b rt signal to be delivered on IO */
};
/*
* Track a single file's readahead state
*/
struct file_ra_state {
pgoff_t start; /* where readahead started */
unsigned int size; /* # of readahead pages */
unsigned int async_size; /* do asynchronous readahead when
there are only # of pages ahead */
unsigned int ra_pages; /* Maximum readahead window */
unsigned int mmap_miss; /* Cache miss stat for mmap accesses */
loff_t prev_pos; /* Cache last read() position */
};
/*
* Check if @index falls in the readahead windows.
*/
static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
{
return (index >= ra->start &&
index < ra->start + ra->size);
}
#define FILE_MNT_WRITE_TAKEN 1
#define FILE_MNT_WRITE_RELEASED 2
struct file {
/*
* fu_list becomes invalid after file_free is called and queued via
* fu_rcuhead for RCU freeing
*/
union {
struct list_head fu_list;
struct rcu_head fu_rcuhead;
} f_u;
struct path f_path;
#define f_dentry f_path.dentry
#define f_vfsmnt f_path.mnt
const struct file_operations *f_op;
/*
* Protects f_ep_links, f_flags, f_pos vs i_size in lseek SEEK_CUR.
* Must not be taken from IRQ context.
*/
spinlock_t f_lock;
#ifdef CONFIG_SMP
int f_sb_list_cpu;
#endif
atomic_long_t f_count;
unsigned int f_flags;
fmode_t f_mode;
loff_t f_pos;
struct fown_struct f_owner;
const struct cred *f_cred;
struct file_ra_state f_ra;
u64 f_version;
#ifdef CONFIG_SECURITY
void *f_security;
#endif
/* needed for tty driver, and maybe others */
void *private_data;
#ifdef CONFIG_EPOLL
/* Used by fs/eventpoll.c to link all the hooks to this file */
struct list_head f_ep_links;
#endif /* #ifdef CONFIG_EPOLL */
struct address_space *f_mapping;
#ifdef CONFIG_DEBUG_WRITECOUNT
unsigned long f_mnt_write_state;
#endif
};
struct file_handle {
__u32 handle_bytes;
int handle_type;
/* file identifier */
unsigned char f_handle[0];
};
#define get_file(x) atomic_long_inc(&(x)->f_count)
#define fput_atomic(x) atomic_long_add_unless(&(x)->f_count, -1, 1)
#define file_count(x) atomic_long_read(&(x)->f_count)
#ifdef CONFIG_DEBUG_WRITECOUNT
static inline void file_take_write(struct file *f)
{
WARN_ON(f->f_mnt_write_state != 0);
f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN;
}
static inline void file_release_write(struct file *f)
{
f->f_mnt_write_state |= FILE_MNT_WRITE_RELEASED;
}
static inline void file_reset_write(struct file *f)
{
f->f_mnt_write_state = 0;
}
static inline void file_check_state(struct file *f)
{
/*
* At this point, either both or neither of these bits
* should be set.
*/
WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN);
WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_RELEASED);
}
static inline int file_check_writeable(struct file *f)
{
if (f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN)
return 0;
printk(KERN_WARNING "writeable file with no "
"mnt_want_write()\n");
WARN_ON(1);
return -EINVAL;
}
#else /* !CONFIG_DEBUG_WRITECOUNT */
static inline void file_take_write(struct file *filp) {}
static inline void file_release_write(struct file *filp) {}
static inline void file_reset_write(struct file *filp) {}
static inline void file_check_state(struct file *filp) {}
static inline int file_check_writeable(struct file *filp)
{
return 0;
}
#endif /* CONFIG_DEBUG_WRITECOUNT */
#define MAX_NON_LFS ((1UL<<31) - 1)
/* Page cache limit. The filesystems should put that into their s_maxbytes
limits, otherwise bad things can happen in VM. */
#if BITS_PER_LONG==32
#define MAX_LFS_FILESIZE (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
#elif BITS_PER_LONG==64
#define MAX_LFS_FILESIZE 0x7fffffffffffffffUL
#endif
#define FL_POSIX 1
#define FL_FLOCK 2
#define FL_ACCESS 8 /* not trying to lock, just looking */
#define FL_EXISTS 16 /* when unlocking, test for existence */
#define FL_LEASE 32 /* lease held on this file */
#define FL_CLOSE 64 /* unlock on close */
#define FL_SLEEP 128 /* A blocking lock */
#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */
#define FL_UNLOCK_PENDING 512 /* Lease is being broken */
/*
* Special return value from posix_lock_file() and vfs_lock_file() for
* asynchronous locking.
*/
#define FILE_LOCK_DEFERRED 1
/*
* The POSIX file lock owner is determined by
* the "struct files_struct" in the thread group
* (or NULL for no owner - BSD locks).
*
* Lockd stuffs a "host" pointer into this.
*/
typedef struct files_struct *fl_owner_t;
struct file_lock_operations {
void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
void (*fl_release_private)(struct file_lock *);
};
struct lock_manager_operations {
int (*lm_compare_owner)(struct file_lock *, struct file_lock *);
void (*lm_notify)(struct file_lock *); /* unblock callback */
int (*lm_grant)(struct file_lock *, struct file_lock *, int);
void (*lm_release_private)(struct file_lock *);
void (*lm_break)(struct file_lock *);
int (*lm_change)(struct file_lock **, int);
};
struct lock_manager {
struct list_head list;
};
void locks_start_grace(struct lock_manager *);
void locks_end_grace(struct lock_manager *);
int locks_in_grace(void);
/* that will die - we need it for nfs_lock_info */
#include <linux/nfs_fs_i.h>
struct file_lock {
struct file_lock *fl_next; /* singly linked list for this inode */
struct list_head fl_link; /* doubly linked list of all locks */
struct list_head fl_block; /* circular list of blocked processes */
fl_owner_t fl_owner;
unsigned int fl_flags;
unsigned char fl_type;
unsigned int fl_pid;
struct pid *fl_nspid;
wait_queue_head_t fl_wait;
struct file *fl_file;
loff_t fl_start;
loff_t fl_end;
struct fasync_struct * fl_fasync; /* for lease break notifications */
/* for lease breaks: */
unsigned long fl_break_time;
unsigned long fl_downgrade_time;
const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */
const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */
union {
struct nfs_lock_info nfs_fl;
struct nfs4_lock_info nfs4_fl;
struct {
struct list_head link; /* link in AFS vnode's pending_locks list */
int state; /* state of grant or error if -ve */
} afs;
} fl_u;
};
/* The following constant reflects the upper bound of the file/locking space */
#ifndef OFFSET_MAX
#define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
#define OFFSET_MAX INT_LIMIT(loff_t)
#define OFFT_OFFSET_MAX INT_LIMIT(off_t)
#endif
#include <linux/fcntl.h>
extern void send_sigio(struct fown_struct *fown, int fd, int band);
#ifdef CONFIG_FILE_LOCKING
extern int fcntl_getlk(struct file *, struct flock __user *);
extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
struct flock __user *);
#if BITS_PER_LONG == 32
extern int fcntl_getlk64(struct file *, struct flock64 __user *);
extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
struct flock64 __user *);
#endif
extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
extern int fcntl_getlease(struct file *filp);
/* fs/locks.c */
void locks_free_lock(struct file_lock *fl);
extern void locks_init_lock(struct file_lock *);
extern struct file_lock * locks_alloc_lock(void);
extern void locks_copy_lock(struct file_lock *, struct file_lock *);
extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
extern void locks_remove_posix(struct file *, fl_owner_t);
extern void locks_remove_flock(struct file *);
extern void locks_release_private(struct file_lock *);
extern void posix_test_lock(struct file *, struct file_lock *);
extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
extern int posix_lock_file_wait(struct file *, struct file_lock *);
extern int posix_unblock_lock(struct file *, struct file_lock *);
extern int vfs_test_lock(struct file *, struct file_lock *);
extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
extern int __break_lease(struct inode *inode, unsigned int flags);
extern void lease_get_mtime(struct inode *, struct timespec *time);
extern int generic_setlease(struct file *, long, struct file_lock **);
extern int vfs_setlease(struct file *, long, struct file_lock **);
extern int lease_modify(struct file_lock **, int);
extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
extern void lock_flocks(void);
extern void unlock_flocks(void);
#else /* !CONFIG_FILE_LOCKING */
static inline int fcntl_getlk(struct file *file, struct flock __user *user)
{
return -EINVAL;
}
static inline int fcntl_setlk(unsigned int fd, struct file *file,
unsigned int cmd, struct flock __user *user)
{
return -EACCES;
}
#if BITS_PER_LONG == 32
static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user)
{
return -EINVAL;
}
static inline int fcntl_setlk64(unsigned int fd, struct file *file,
unsigned int cmd, struct flock64 __user *user)
{
return -EACCES;
}
#endif
static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
{
return 0;
}
static inline int fcntl_getlease(struct file *filp)
{
return 0;
}
static inline void locks_init_lock(struct file_lock *fl)
{
return;
}
static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl)
{
return;
}
static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
{
return;
}
static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
{
return;
}
static inline void locks_remove_flock(struct file *filp)
{
return;
}
static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
{
return;
}
static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
struct file_lock *conflock)
{
return -ENOLCK;
}
static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
{
return -ENOLCK;
}
static inline int posix_unblock_lock(struct file *filp,
struct file_lock *waiter)
{
return -ENOENT;
}
static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
{
return 0;
}
static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
struct file_lock *fl, struct file_lock *conf)
{
return -ENOLCK;
}
static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
{
return 0;
}
static inline int flock_lock_file_wait(struct file *filp,
struct file_lock *request)
{
return -ENOLCK;
}
static inline int __break_lease(struct inode *inode, unsigned int mode)
{
return 0;
}
static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
{
return;
}
static inline int generic_setlease(struct file *filp, long arg,
struct file_lock **flp)
{
return -EINVAL;
}
static inline int vfs_setlease(struct file *filp, long arg,
struct file_lock **lease)
{
return -EINVAL;
}
static inline int lease_modify(struct file_lock **before, int arg)
{
return -EINVAL;
}
static inline int lock_may_read(struct inode *inode, loff_t start,
unsigned long len)
{
return 1;
}
static inline int lock_may_write(struct inode *inode, loff_t start,
unsigned long len)
{
return 1;
}
static inline void lock_flocks(void)
{
}
static inline void unlock_flocks(void)
{
}
#endif /* !CONFIG_FILE_LOCKING */
struct fasync_struct {
spinlock_t fa_lock;
int magic;
int fa_fd;
struct fasync_struct *fa_next; /* singly linked list */
struct file *fa_file;
struct rcu_head fa_rcu;
};
#define FASYNC_MAGIC 0x4601
/* SMP safe fasync helpers: */
extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
extern int fasync_remove_entry(struct file *, struct fasync_struct **);
extern struct fasync_struct *fasync_alloc(void);
extern void fasync_free(struct fasync_struct *);
/* can be called from interrupts */
extern void kill_fasync(struct fasync_struct **, int, int);
extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
extern int f_setown(struct file *filp, unsigned long arg, int force);
extern void f_delown(struct file *filp);
extern pid_t f_getown(struct file *filp);
extern int send_sigurg(struct fown_struct *fown);
/*
* Umount options
*/
#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
#define MNT_DETACH 0x00000002 /* Just detach from the tree */
#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */
extern struct list_head super_blocks;
extern spinlock_t sb_lock;
struct super_block {
struct list_head s_list; /* Keep this first */
dev_t s_dev; /* search index; _not_ kdev_t */
unsigned char s_dirt;
unsigned char s_blocksize_bits;
unsigned long s_blocksize;
loff_t s_maxbytes; /* Max file size */
struct file_system_type *s_type;
const struct super_operations *s_op;
const struct dquot_operations *dq_op;
const struct quotactl_ops *s_qcop;
const struct export_operations *s_export_op;
unsigned long s_flags;
unsigned long s_magic;
struct dentry *s_root;
struct rw_semaphore s_umount;
struct mutex s_lock;
int s_count;
atomic_t s_active;
#ifdef CONFIG_SECURITY
void *s_security;
#endif
const struct xattr_handler **s_xattr;
struct list_head s_inodes; /* all inodes */
struct hlist_bl_head s_anon; /* anonymous dentries for (nfs) exporting */
#ifdef CONFIG_SMP
struct list_head __percpu *s_files;
#else
struct list_head s_files;
#endif
/* s_dentry_lru, s_nr_dentry_unused protected by dcache.c lru locks */
struct list_head s_dentry_lru; /* unused dentry lru */
int s_nr_dentry_unused; /* # of dentry on lru */
/* s_inode_lru_lock protects s_inode_lru and s_nr_inodes_unused */
spinlock_t s_inode_lru_lock ____cacheline_aligned_in_smp;
struct list_head s_inode_lru; /* unused inode lru */
int s_nr_inodes_unused; /* # of inodes on lru */
struct block_device *s_bdev;
struct backing_dev_info *s_bdi;
struct mtd_info *s_mtd;
struct list_head s_instances;
struct quota_info s_dquot; /* Diskquota specific options */
int s_frozen;
wait_queue_head_t s_wait_unfrozen;
char s_id[32]; /* Informational name */
u8 s_uuid[16]; /* UUID */
void *s_fs_info; /* Filesystem private info */
fmode_t s_mode;
/* Granularity of c/m/atime in ns.
Cannot be worse than a second */
u32 s_time_gran;
/*
* The next field is for VFS *only*. No filesystems have any business
* even looking at it. You had been warned.
*/
struct mutex s_vfs_rename_mutex; /* Kludge */
/*
* Filesystem subtype. If non-empty the filesystem type field
* in /proc/mounts will be "type.subtype"
*/
char *s_subtype;
/*
* Saved mount options for lazy filesystems using
* generic_show_options()
*/
char __rcu *s_options;
const struct dentry_operations *s_d_op; /* default d_op for dentries */
/*
* Saved pool identifier for cleancache (-1 means none)
*/
int cleancache_poolid;
struct shrinker s_shrink; /* per-sb shrinker handle */
};
/* superblock cache pruning functions */
extern void prune_icache_sb(struct super_block *sb, int nr_to_scan);
extern void prune_dcache_sb(struct super_block *sb, int nr_to_scan);
extern struct timespec current_fs_time(struct super_block *sb);
/*
* Snapshotting support.
*/
enum {
SB_UNFROZEN = 0,
SB_FREEZE_WRITE = 1,
SB_FREEZE_TRANS = 2,
};
#define vfs_check_frozen(sb, level) \
wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
/*
* until VFS tracks user namespaces for inodes, just make all files
* belong to init_user_ns
*/
extern struct user_namespace init_user_ns;
#define inode_userns(inode) (&init_user_ns)
extern bool inode_owner_or_capable(const struct inode *inode);
/* not quite ready to be deprecated, but... */
extern void lock_super(struct super_block *);
extern void unlock_super(struct super_block *);
/*
* VFS helper functions..
*/
extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
extern int vfs_mkdir(struct inode *, struct dentry *, int);
extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
extern int vfs_symlink(struct inode *, struct dentry *, const char *);
extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
extern int vfs_rmdir(struct inode *, struct dentry *);
extern int vfs_unlink(struct inode *, struct dentry *);
extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
/*
* VFS dentry helper functions.
*/
extern void dentry_unhash(struct dentry *dentry);
/*
* VFS file helper functions.
*/
extern void inode_init_owner(struct inode *inode, const struct inode *dir,
mode_t mode);
/*
* VFS FS_IOC_FIEMAP helper definitions.
*/
struct fiemap_extent_info {
unsigned int fi_flags; /* Flags as passed from user */
unsigned int fi_extents_mapped; /* Number of mapped extents */
unsigned int fi_extents_max; /* Size of fiemap_extent array */
struct fiemap_extent __user *fi_extents_start; /* Start of
fiemap_extent array */
};
int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
u64 phys, u64 len, u32 flags);
int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
/*
* File types
*
* NOTE! These match bits 12..15 of stat.st_mode
* (ie "(i_mode >> 12) & 15").
*/
#define DT_UNKNOWN 0
#define DT_FIFO 1
#define DT_CHR 2
#define DT_DIR 4
#define DT_BLK 6
#define DT_REG 8
#define DT_LNK 10
#define DT_SOCK 12
#define DT_WHT 14
/*
* This is the "filldir" function type, used by readdir() to let
* the kernel specify what kind of dirent layout it wants to have.
* This allows the kernel to read directories into kernel space or
* to have different dirent layouts depending on the binary type.
*/
typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
struct block_device_operations;
/* These macros are for out of kernel modules to test that
* the kernel supports the unlocked_ioctl and compat_ioctl
* fields in struct file_operations. */
#define HAVE_COMPAT_IOCTL 1
#define HAVE_UNLOCKED_IOCTL 1
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
};
struct inode_operations {
struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
void * (*follow_link) (struct dentry *, struct nameidata *);
int (*permission) (struct inode *, int);
struct posix_acl * (*get_acl)(struct inode *, int);
int (*readlink) (struct dentry *, char __user *,int);
void (*put_link) (struct dentry *, struct nameidata *, void *);
int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
int (*link) (struct dentry *,struct inode *,struct dentry *);
int (*unlink) (struct inode *,struct dentry *);
int (*symlink) (struct inode *,struct dentry *,const char *);
int (*mkdir) (struct inode *,struct dentry *,int);
int (*rmdir) (struct inode *,struct dentry *);
int (*mknod) (struct inode *,struct dentry *,int,dev_t);
int (*rename) (struct inode *, struct dentry *,
struct inode *, struct dentry *);
void (*truncate) (struct inode *);
int (*setattr) (struct dentry *, struct iattr *);
int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
ssize_t (*listxattr) (struct dentry *, char *, size_t);
int (*removexattr) (struct dentry *, const char *);
void (*truncate_range)(struct inode *, loff_t, loff_t);
int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
u64 len);
} ____cacheline_aligned;
struct seq_file;
ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
unsigned long nr_segs, unsigned long fast_segs,
struct iovec *fast_pointer,
struct iovec **ret_pointer,
int check_access);
extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
unsigned long, loff_t *);
extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
unsigned long, loff_t *);
struct super_operations {
struct inode *(*alloc_inode)(struct super_block *sb);
void (*destroy_inode)(struct inode *);
void (*dirty_inode) (struct inode *, int flags);
int (*write_inode) (struct inode *, struct writeback_control *wbc);
int (*drop_inode) (struct inode *);
void (*evict_inode) (struct inode *);
void (*put_super) (struct super_block *);
void (*write_super) (struct super_block *);
int (*sync_fs)(struct super_block *sb, int wait);
int (*freeze_fs) (struct super_block *);
int (*unfreeze_fs) (struct super_block *);
int (*statfs) (struct dentry *, struct kstatfs *);
int (*remount_fs) (struct super_block *, int *, char *);
void (*umount_begin) (struct super_block *);
int (*show_options)(struct seq_file *, struct vfsmount *);
int (*show_devname)(struct seq_file *, struct vfsmount *);
int (*show_path)(struct seq_file *, struct vfsmount *);
int (*show_stats)(struct seq_file *, struct vfsmount *);
#ifdef CONFIG_QUOTA
ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
#endif
int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
int (*nr_cached_objects)(struct super_block *);
void (*free_cached_objects)(struct super_block *, int);
};
/*
* Inode state bits. Protected by inode->i_lock
*
* Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
* I_DIRTY_DATASYNC and I_DIRTY_PAGES.
*
* Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
* until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
* various stages of removing an inode.
*
* Two bits are used for locking and completion notification, I_NEW and I_SYNC.
*
* I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on
* fdatasync(). i_atime is the usual cause.
* I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
* these changes separately from I_DIRTY_SYNC so that we
* don't have to write inode on fdatasync() when only
* mtime has changed in it.
* I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean.
* I_NEW Serves as both a mutex and completion notification.
* New inodes set I_NEW. If two processes both create
* the same inode, one of them will release its inode and
* wait for I_NEW to be released before returning.
* Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
* also cause waiting on I_NEW, without I_NEW actually
* being set. find_inode() uses this to prevent returning
* nearly-dead inodes.
* I_WILL_FREE Must be set when calling write_inode_now() if i_count
* is zero. I_FREEING must be set when I_WILL_FREE is
* cleared.
* I_FREEING Set when inode is about to be freed but still has dirty
* pages or buffers attached or the inode itself is still
* dirty.
* I_CLEAR Added by end_writeback(). In this state the inode is clean
* and can be destroyed. Inode keeps I_FREEING.
*
* Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
* prohibited for many purposes. iget() must wait for
* the inode to be completely released, then create it
* anew. Other functions will just ignore such inodes,
* if appropriate. I_NEW is used for waiting.
*
* I_SYNC Synchonized write of dirty inode data. The bits is
* set during data writeback, and cleared with a wakeup
* on the bit address once it is done.
*
* I_REFERENCED Marks the inode as recently references on the LRU list.
*
* I_DIO_WAKEUP Never set. Only used as a key for wait_on_bit().
*
* Q: What is the difference between I_WILL_FREE and I_FREEING?
*/
#define I_DIRTY_SYNC (1 << 0)
#define I_DIRTY_DATASYNC (1 << 1)
#define I_DIRTY_PAGES (1 << 2)
#define __I_NEW 3
#define I_NEW (1 << __I_NEW)
#define I_WILL_FREE (1 << 4)
#define I_FREEING (1 << 5)
#define I_CLEAR (1 << 6)
#define __I_SYNC 7
#define I_SYNC (1 << __I_SYNC)
#define I_REFERENCED (1 << 8)
#define __I_DIO_WAKEUP 9
#define I_DIO_WAKEUP (1 << I_DIO_WAKEUP)
#define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
extern void __mark_inode_dirty(struct inode *, int);
static inline void mark_inode_dirty(struct inode *inode)
{
__mark_inode_dirty(inode, I_DIRTY);
}
static inline void mark_inode_dirty_sync(struct inode *inode)
{
__mark_inode_dirty(inode, I_DIRTY_SYNC);
}
/**
* set_nlink - directly set an inode's link count
* @inode: inode
* @nlink: new nlink (should be non-zero)
*
* This is a low-level filesystem helper to replace any
* direct filesystem manipulation of i_nlink.
*/
static inline void set_nlink(struct inode *inode, unsigned int nlink)
{
inode->__i_nlink = nlink;
}
/**
* inc_nlink - directly increment an inode's link count
* @inode: inode
*
* This is a low-level filesystem helper to replace any
* direct filesystem manipulation of i_nlink. Currently,
* it is only here for parity with dec_nlink().
*/
static inline void inc_nlink(struct inode *inode)
{
inode->__i_nlink++;
}
static inline void inode_inc_link_count(struct inode *inode)
{
inc_nlink(inode);
mark_inode_dirty(inode);
}
/**
* drop_nlink - directly drop an inode's link count
* @inode: inode
*
* This is a low-level filesystem helper to replace any
* direct filesystem manipulation of i_nlink. In cases
* where we are attempting to track writes to the
* filesystem, a decrement to zero means an imminent
* write when the file is truncated and actually unlinked
* on the filesystem.
*/
static inline void drop_nlink(struct inode *inode)
{
inode->__i_nlink--;
}
/**
* clear_nlink - directly zero an inode's link count
* @inode: inode
*
* This is a low-level filesystem helper to replace any
* direct filesystem manipulation of i_nlink. See
* drop_nlink() for why we care about i_nlink hitting zero.
*/
static inline void clear_nlink(struct inode *inode)
{
inode->__i_nlink = 0;
}
static inline void inode_dec_link_count(struct inode *inode)
{
drop_nlink(inode);
mark_inode_dirty(inode);
}
/**
* inode_inc_iversion - increments i_version
* @inode: inode that need to be updated
*
* Every time the inode is modified, the i_version field will be incremented.
* The filesystem has to be mounted with i_version flag
*/
static inline void inode_inc_iversion(struct inode *inode)
{
spin_lock(&inode->i_lock);
inode->i_version++;
spin_unlock(&inode->i_lock);
}
extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
static inline void file_accessed(struct file *file)
{
if (!(file->f_flags & O_NOATIME))
touch_atime(file->f_path.mnt, file->f_path.dentry);
}
int sync_inode(struct inode *inode, struct writeback_control *wbc);
int sync_inode_metadata(struct inode *inode, int wait);
struct file_system_type {
const char *name;
int fs_flags;
struct dentry *(*mount) (struct file_system_type *, int,
const char *, void *);
void (*kill_sb) (struct super_block *);
struct module *owner;
struct file_system_type * next;
struct list_head fs_supers;
struct lock_class_key s_lock_key;
struct lock_class_key s_umount_key;
struct lock_class_key s_vfs_rename_key;
struct lock_class_key i_lock_key;
struct lock_class_key i_mutex_key;
struct lock_class_key i_mutex_dir_key;
};
extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
void *data, int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_bdev(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data,
int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_single(struct file_system_type *fs_type,
int flags, void *data,
int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_nodev(struct file_system_type *fs_type,
int flags, void *data,
int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
void generic_shutdown_super(struct super_block *sb);
void kill_block_super(struct super_block *sb);
void kill_anon_super(struct super_block *sb);
void kill_litter_super(struct super_block *sb);
void deactivate_super(struct super_block *sb);
void deactivate_locked_super(struct super_block *sb);
int set_anon_super(struct super_block *s, void *data);
int get_anon_bdev(dev_t *);
void free_anon_bdev(dev_t);
struct super_block *sget(struct file_system_type *type,
int (*test)(struct super_block *,void *),
int (*set)(struct super_block *,void *),
void *data);
extern struct dentry *mount_pseudo(struct file_system_type *, char *,
const struct super_operations *ops,
const struct dentry_operations *dops,
unsigned long);
static inline void sb_mark_dirty(struct super_block *sb)
{
sb->s_dirt = 1;
}
static inline void sb_mark_clean(struct super_block *sb)
{
sb->s_dirt = 0;
}
static inline int sb_is_dirty(struct super_block *sb)
{
return sb->s_dirt;
}
/* Alas, no aliases. Too much hassle with bringing module.h everywhere */
#define fops_get(fops) \
(((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
#define fops_put(fops) \
do { if (fops) module_put((fops)->owner); } while(0)
extern int register_filesystem(struct file_system_type *);
extern int unregister_filesystem(struct file_system_type *);
extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
#define kern_mount(type) kern_mount_data(type, NULL)
extern void kern_unmount(struct vfsmount *mnt);
extern int may_umount_tree(struct vfsmount *);
extern int may_umount(struct vfsmount *);
extern long do_mount(char *, char *, char *, unsigned long, void *);
extern struct vfsmount *collect_mounts(struct path *);
extern void drop_collected_mounts(struct vfsmount *);
extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
struct vfsmount *);
extern int vfs_statfs(struct path *, struct kstatfs *);
extern int user_statfs(const char __user *, struct kstatfs *);
extern int fd_statfs(int, struct kstatfs *);
extern int statfs_by_dentry(struct dentry *, struct kstatfs *);
extern int freeze_super(struct super_block *super);
extern int thaw_super(struct super_block *super);
extern bool our_mnt(struct vfsmount *mnt);
extern int current_umask(void);
/* /sys/fs */
extern struct kobject *fs_kobj;
#define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK)
extern int rw_verify_area(int, struct file *, loff_t *, size_t);
#define FLOCK_VERIFY_READ 1
#define FLOCK_VERIFY_WRITE 2
#ifdef CONFIG_FILE_LOCKING
extern int locks_mandatory_locked(struct inode *);
extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
/*
* Candidates for mandatory locking have the setgid bit set
* but no group execute bit - an otherwise meaningless combination.
*/
static inline int __mandatory_lock(struct inode *ino)
{
return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
}
/*
* ... and these candidates should be on MS_MANDLOCK mounted fs,
* otherwise these will be advisory locks
*/
static inline int mandatory_lock(struct inode *ino)
{
return IS_MANDLOCK(ino) && __mandatory_lock(ino);
}
static inline int locks_verify_locked(struct inode *inode)
{
if (mandatory_lock(inode))
return locks_mandatory_locked(inode);
return 0;
}
static inline int locks_verify_truncate(struct inode *inode,
struct file *filp,
loff_t size)
{
if (inode->i_flock && mandatory_lock(inode))
return locks_mandatory_area(
FLOCK_VERIFY_WRITE, inode, filp,
size < inode->i_size ? size : inode->i_size,
(size < inode->i_size ? inode->i_size - size
: size - inode->i_size)
);
return 0;
}
static inline int break_lease(struct inode *inode, unsigned int mode)
{
if (inode->i_flock)
return __break_lease(inode, mode);
return 0;
}
#else /* !CONFIG_FILE_LOCKING */
static inline int locks_mandatory_locked(struct inode *inode)
{
return 0;
}
static inline int locks_mandatory_area(int rw, struct inode *inode,
struct file *filp, loff_t offset,
size_t count)
{
return 0;
}
static inline int __mandatory_lock(struct inode *inode)
{
return 0;
}
static inline int mandatory_lock(struct inode *inode)
{
return 0;
}
static inline int locks_verify_locked(struct inode *inode)
{
return 0;
}
static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
size_t size)
{
return 0;
}
static inline int break_lease(struct inode *inode, unsigned int mode)
{
return 0;
}
#endif /* CONFIG_FILE_LOCKING */
/* fs/open.c */
extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
struct file *filp);
extern int do_fallocate(struct file *file, int mode, loff_t offset,
loff_t len);
extern long do_sys_open(int dfd, const char __user *filename, int flags,
int mode);
extern struct file *filp_open(const char *, int, int);
extern struct file *file_open_root(struct dentry *, struct vfsmount *,
const char *, int);
extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
const struct cred *);
extern int filp_close(struct file *, fl_owner_t id);
extern char * getname(const char __user *);
/* fs/ioctl.c */
extern int ioctl_preallocate(struct file *filp, void __user *argp);
/* fs/dcache.c */
extern void __init vfs_caches_init_early(void);
extern void __init vfs_caches_init(unsigned long);
extern struct kmem_cache *names_cachep;
#define __getname_gfp(gfp) kmem_cache_alloc(names_cachep, (gfp))
#define __getname() __getname_gfp(GFP_KERNEL)
#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
#ifndef CONFIG_AUDITSYSCALL
#define putname(name) __putname(name)
#else
extern void putname(const char *name);
#endif
#ifdef CONFIG_BLOCK
extern int register_blkdev(unsigned int, const char *);
extern void unregister_blkdev(unsigned int, const char *);
extern struct block_device *bdget(dev_t);
extern struct block_device *bdgrab(struct block_device *bdev);
extern void bd_set_size(struct block_device *, loff_t size);
extern void bd_forget(struct inode *inode);
extern void bdput(struct block_device *);
extern void invalidate_bdev(struct block_device *);
extern int sync_blockdev(struct block_device *bdev);
extern struct super_block *freeze_bdev(struct block_device *);
extern void emergency_thaw_all(void);
extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
extern int fsync_bdev(struct block_device *);
#else
static inline void bd_forget(struct inode *inode) {}
static inline int sync_blockdev(struct block_device *bdev) { return 0; }
static inline void invalidate_bdev(struct block_device *bdev) {}
static inline struct super_block *freeze_bdev(struct block_device *sb)
{
return NULL;
}
static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
{
return 0;
}
#endif
extern int sync_filesystem(struct super_block *);
extern const struct file_operations def_blk_fops;
extern const struct file_operations def_chr_fops;
extern const struct file_operations bad_sock_fops;
extern const struct file_operations def_fifo_fops;
#ifdef CONFIG_BLOCK
extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder);
extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
void *holder);
extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
void *holder);
extern int blkdev_put(struct block_device *bdev, fmode_t mode);
#ifdef CONFIG_SYSFS
extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
extern void bd_unlink_disk_holder(struct block_device *bdev,
struct gendisk *disk);
#else
static inline int bd_link_disk_holder(struct block_device *bdev,
struct gendisk *disk)
{
return 0;
}
static inline void bd_unlink_disk_holder(struct block_device *bdev,
struct gendisk *disk)
{
}
#endif
#endif
/* fs/char_dev.c */
#define CHRDEV_MAJOR_HASH_SIZE 255
extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
extern int register_chrdev_region(dev_t, unsigned, const char *);
extern int __register_chrdev(unsigned int major, unsigned int baseminor,
unsigned int count, const char *name,
const struct file_operations *fops);
extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
unsigned int count, const char *name);
extern void unregister_chrdev_region(dev_t, unsigned);
extern void chrdev_show(struct seq_file *,off_t);
static inline int register_chrdev(unsigned int major, const char *name,
const struct file_operations *fops)
{
return __register_chrdev(major, 0, 256, name, fops);
}
static inline void unregister_chrdev(unsigned int major, const char *name)
{
__unregister_chrdev(major, 0, 256, name);
}
/* fs/block_dev.c */
#define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */
#define BDEVT_SIZE 10 /* Largest string for MAJ:MIN for blkdev */
#ifdef CONFIG_BLOCK
#define BLKDEV_MAJOR_HASH_SIZE 255
extern const char *__bdevname(dev_t, char *buffer);
extern const char *bdevname(struct block_device *bdev, char *buffer);
extern struct block_device *lookup_bdev(const char *);
extern void blkdev_show(struct seq_file *,off_t);
#else
#define BLKDEV_MAJOR_HASH_SIZE 0
#endif
extern void init_special_inode(struct inode *, umode_t, dev_t);
/* Invalid inode operations -- fs/bad_inode.c */
extern void make_bad_inode(struct inode *);
extern int is_bad_inode(struct inode *);
extern const struct file_operations read_pipefifo_fops;
extern const struct file_operations write_pipefifo_fops;
extern const struct file_operations rdwr_pipefifo_fops;
extern int fs_may_remount_ro(struct super_block *);
#ifdef CONFIG_BLOCK
/*
* return READ, READA, or WRITE
*/
#define bio_rw(bio) ((bio)->bi_rw & (RW_MASK | RWA_MASK))
/*
* return data direction, READ or WRITE
*/
#define bio_data_dir(bio) ((bio)->bi_rw & 1)
extern void check_disk_size_change(struct gendisk *disk,
struct block_device *bdev);
extern int revalidate_disk(struct gendisk *);
extern int check_disk_change(struct block_device *);
extern int __invalidate_device(struct block_device *, bool);
extern int invalidate_partition(struct gendisk *, int);
#endif
unsigned long invalidate_mapping_pages(struct address_space *mapping,
pgoff_t start, pgoff_t end);
static inline void invalidate_remote_inode(struct inode *inode)
{
if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
S_ISLNK(inode->i_mode))
invalidate_mapping_pages(inode->i_mapping, 0, -1);
}
extern int invalidate_inode_pages2(struct address_space *mapping);
extern int invalidate_inode_pages2_range(struct address_space *mapping,
pgoff_t start, pgoff_t end);
extern int write_inode_now(struct inode *, int);
extern int filemap_fdatawrite(struct address_space *);
extern int filemap_flush(struct address_space *);
extern int filemap_fdatawait(struct address_space *);
extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
loff_t lend);
extern int filemap_write_and_wait(struct address_space *mapping);
extern int filemap_write_and_wait_range(struct address_space *mapping,
loff_t lstart, loff_t lend);
extern int __filemap_fdatawrite_range(struct address_space *mapping,
loff_t start, loff_t end, int sync_mode);
extern int filemap_fdatawrite_range(struct address_space *mapping,
loff_t start, loff_t end);
extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
int datasync);
extern int vfs_fsync(struct file *file, int datasync);
extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);
extern void sync_supers(void);
extern void emergency_sync(void);
extern void emergency_remount(void);
#ifdef CONFIG_BLOCK
extern sector_t bmap(struct inode *, sector_t);
#endif
extern int notify_change(struct dentry *, struct iattr *);
extern int inode_permission(struct inode *, int);
extern int generic_permission(struct inode *, int);
static inline bool execute_ok(struct inode *inode)
{
return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
}
/*
* get_write_access() gets write permission for a file.
* put_write_access() releases this write permission.
* This is used for regular files.
* We cannot support write (and maybe mmap read-write shared) accesses and
* MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
* can have the following values:
* 0: no writers, no VM_DENYWRITE mappings
* < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
* > 0: (i_writecount) users are writing to the file.
*
* Normally we operate on that counter with atomic_{inc,dec} and it's safe
* except for the cases where we don't hold i_writecount yet. Then we need to
* use {get,deny}_write_access() - these functions check the sign and refuse
* to do the change if sign is wrong.
*/
static inline int get_write_access(struct inode *inode)
{
return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
}
static inline int deny_write_access(struct file *file)
{
struct inode *inode = file->f_path.dentry->d_inode;
return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
}
static inline void put_write_access(struct inode * inode)
{
atomic_dec(&inode->i_writecount);
}
static inline void allow_write_access(struct file *file)
{
if (file)
atomic_inc(&file->f_path.dentry->d_inode->i_writecount);
}
#ifdef CONFIG_IMA
static inline void i_readcount_dec(struct inode *inode)
{
BUG_ON(!atomic_read(&inode->i_readcount));
atomic_dec(&inode->i_readcount);
}
static inline void i_readcount_inc(struct inode *inode)
{
atomic_inc(&inode->i_readcount);
}
#else
static inline void i_readcount_dec(struct inode *inode)
{
return;
}
static inline void i_readcount_inc(struct inode *inode)
{
return;
}
#endif
extern int do_pipe_flags(int *, int);
extern struct file *create_read_pipe(struct file *f, int flags);
extern struct file *create_write_pipe(int flags);
extern void free_write_pipe(struct file *);
extern int kernel_read(struct file *, loff_t, char *, unsigned long);
extern struct file * open_exec(const char *);
/* fs/dcache.c -- generic fs support functions */
extern int is_subdir(struct dentry *, struct dentry *);
extern int path_is_under(struct path *, struct path *);
extern ino_t find_inode_number(struct dentry *, struct qstr *);
#include <linux/err.h>
/* needed for stackable file system support */
extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
extern int inode_init_always(struct super_block *, struct inode *);
extern void inode_init_once(struct inode *);
extern void address_space_init_once(struct address_space *mapping);
extern void ihold(struct inode * inode);
extern void iput(struct inode *);
extern struct inode * igrab(struct inode *);
extern ino_t iunique(struct super_block *, ino_t);
extern int inode_needs_sync(struct inode *inode);
extern int generic_delete_inode(struct inode *inode);
extern int generic_drop_inode(struct inode *inode);
extern struct inode *ilookup5_nowait(struct super_block *sb,
unsigned long hashval, int (*test)(struct inode *, void *),
void *data);
extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
int (*test)(struct inode *, void *), void *data);
extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
extern struct inode * iget_locked(struct super_block *, unsigned long);
extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
extern int insert_inode_locked(struct inode *);
#ifdef CONFIG_DEBUG_LOCK_ALLOC
extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
#else
static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
#endif
extern void unlock_new_inode(struct inode *);
extern unsigned int get_next_ino(void);
extern void __iget(struct inode * inode);
extern void iget_failed(struct inode *);
extern void end_writeback(struct inode *);
extern void __destroy_inode(struct inode *);
extern struct inode *new_inode_pseudo(struct super_block *sb);
extern struct inode *new_inode(struct super_block *sb);
extern void free_inode_nonrcu(struct inode *inode);
extern int should_remove_suid(struct dentry *);
extern int file_remove_suid(struct file *);
extern void __insert_inode_hash(struct inode *, unsigned long hashval);
static inline void insert_inode_hash(struct inode *inode)
{
__insert_inode_hash(inode, inode->i_ino);
}
extern void __remove_inode_hash(struct inode *);
static inline void remove_inode_hash(struct inode *inode)
{
if (!inode_unhashed(inode))
__remove_inode_hash(inode);
}
extern void inode_sb_list_add(struct inode *inode);
#ifdef CONFIG_BLOCK
extern void submit_bio(int, struct bio *);
extern int bdev_read_only(struct block_device *);
#endif
extern int set_blocksize(struct block_device *, int);
extern int sb_set_blocksize(struct super_block *, int);
extern int sb_min_blocksize(struct super_block *, int);
extern int generic_file_mmap(struct file *, struct vm_area_struct *);
extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
extern ssize_t __generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long,
loff_t *);
extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
unsigned long *, loff_t, loff_t *, size_t, size_t);
extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
unsigned long, loff_t, loff_t *, size_t, ssize_t);
extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
extern int generic_segment_checks(const struct iovec *iov,
unsigned long *nr_segs, size_t *count, int access_flags);
/* fs/block_dev.c */
extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos);
extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
int datasync);
/* fs/splice.c */
extern ssize_t generic_file_splice_read(struct file *, loff_t *,
struct pipe_inode_info *, size_t, unsigned int);
extern ssize_t default_file_splice_read(struct file *, loff_t *,
struct pipe_inode_info *, size_t, unsigned int);
extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
struct file *, loff_t *, size_t, unsigned int);
extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
struct file *out, loff_t *, size_t len, unsigned int flags);
extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
size_t len, unsigned int flags);
extern void
file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
extern loff_t noop_llseek(struct file *file, loff_t offset, int origin);
extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
int origin, loff_t maxsize);
extern int generic_file_open(struct inode * inode, struct file * filp);
extern int nonseekable_open(struct inode * inode, struct file * filp);
#ifdef CONFIG_FS_XIP
extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
loff_t *ppos);
extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
size_t len, loff_t *ppos);
extern int xip_truncate_page(struct address_space *mapping, loff_t from);
#else
static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
{
return 0;
}
#endif
#ifdef CONFIG_BLOCK
typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
loff_t file_offset);
enum {
/* need locking between buffered and direct access */
DIO_LOCKING = 0x01,
/* filesystem does not support filling holes */
DIO_SKIP_HOLES = 0x02,
};
void dio_end_io(struct bio *bio, int error);
void inode_dio_wait(struct inode *inode);
void inode_dio_done(struct inode *inode);
ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
struct block_device *bdev, const struct iovec *iov, loff_t offset,
unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
dio_submit_t submit_io, int flags);
static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
struct inode *inode, const struct iovec *iov, loff_t offset,
unsigned long nr_segs, get_block_t get_block)
{
return __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
offset, nr_segs, get_block, NULL, NULL,
DIO_LOCKING | DIO_SKIP_HOLES);
}
#else
static inline void inode_dio_wait(struct inode *inode)
{
}
#endif
extern const struct file_operations generic_ro_fops;
#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
extern int vfs_follow_link(struct nameidata *, const char *);
extern int page_readlink(struct dentry *, char __user *, int);
extern void *page_follow_link_light(struct dentry *, struct nameidata *);
extern void page_put_link(struct dentry *, struct nameidata *, void *);
extern int __page_symlink(struct inode *inode, const char *symname, int len,
int nofs);
extern int page_symlink(struct inode *inode, const char *symname, int len);
extern const struct inode_operations page_symlink_inode_operations;
extern int generic_readlink(struct dentry *, char __user *, int);
extern void generic_fillattr(struct inode *, struct kstat *);
extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
void __inode_add_bytes(struct inode *inode, loff_t bytes);
void inode_add_bytes(struct inode *inode, loff_t bytes);
void inode_sub_bytes(struct inode *inode, loff_t bytes);
loff_t inode_get_bytes(struct inode *inode);
void inode_set_bytes(struct inode *inode, loff_t bytes);
extern int vfs_readdir(struct file *, filldir_t, void *);
extern int vfs_stat(const char __user *, struct kstat *);
extern int vfs_lstat(const char __user *, struct kstat *);
extern int vfs_fstat(unsigned int, struct kstat *);
extern int vfs_fstatat(int , const char __user *, struct kstat *, int);
extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
unsigned long arg);
extern int __generic_block_fiemap(struct inode *inode,
struct fiemap_extent_info *fieinfo,
loff_t start, loff_t len,
get_block_t *get_block);
extern int generic_block_fiemap(struct inode *inode,
struct fiemap_extent_info *fieinfo, u64 start,
u64 len, get_block_t *get_block);
extern void get_filesystem(struct file_system_type *fs);
extern void put_filesystem(struct file_system_type *fs);
extern struct file_system_type *get_fs_type(const char *name);
extern struct super_block *get_super(struct block_device *);
extern struct super_block *get_active_super(struct block_device *bdev);
extern struct super_block *user_get_super(dev_t);
extern void drop_super(struct super_block *sb);
extern void iterate_supers(void (*)(struct super_block *, void *), void *);
extern void iterate_supers_type(struct file_system_type *,
void (*)(struct super_block *, void *), void *);
extern int dcache_dir_open(struct inode *, struct file *);
extern int dcache_dir_close(struct inode *, struct file *);
extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
extern int dcache_readdir(struct file *, void *, filldir_t);
extern int simple_setattr(struct dentry *, struct iattr *);
extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
extern int simple_statfs(struct dentry *, struct kstatfs *);
extern int simple_open(struct inode *inode, struct file *file);
extern int simple_link(struct dentry *, struct inode *, struct dentry *);
extern int simple_unlink(struct inode *, struct dentry *);
extern int simple_rmdir(struct inode *, struct dentry *);
extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
extern int noop_fsync(struct file *, loff_t, loff_t, int);
extern int simple_empty(struct dentry *);
extern int simple_readpage(struct file *file, struct page *page);
extern int simple_write_begin(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata);
extern int simple_write_end(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata);
extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
extern const struct file_operations simple_dir_operations;
extern const struct inode_operations simple_dir_inode_operations;
struct tree_descr { char *name; const struct file_operations *ops; int mode; };
struct dentry *d_alloc_name(struct dentry *, const char *);
extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *);
extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
extern void simple_release_fs(struct vfsmount **mount, int *count);
extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
loff_t *ppos, const void *from, size_t available);
extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
const void __user *from, size_t count);
extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
extern int generic_check_addressable(unsigned, u64);
#ifdef CONFIG_MIGRATION
extern int buffer_migrate_page(struct address_space *,
struct page *, struct page *);
#else
#define buffer_migrate_page NULL
#endif
extern int inode_change_ok(const struct inode *, struct iattr *);
extern int inode_newsize_ok(const struct inode *, loff_t offset);
extern void setattr_copy(struct inode *inode, const struct iattr *attr);
extern void file_update_time(struct file *file);
extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);
extern void save_mount_options(struct super_block *sb, char *options);
extern void replace_mount_options(struct super_block *sb, char *options);
static inline ino_t parent_ino(struct dentry *dentry)
{
ino_t res;
/*
* Don't strictly need d_lock here? If the parent ino could change
* then surely we'd have a deeper race in the caller?
*/
spin_lock(&dentry->d_lock);
res = dentry->d_parent->d_inode->i_ino;
spin_unlock(&dentry->d_lock);
return res;
}
/* Transaction based IO helpers */
/*
* An argresp is stored in an allocated page and holds the
* size of the argument or response, along with its content
*/
struct simple_transaction_argresp {
ssize_t size;
char data[0];
};
#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
char *simple_transaction_get(struct file *file, const char __user *buf,
size_t size);
ssize_t simple_transaction_read(struct file *file, char __user *buf,
size_t size, loff_t *pos);
int simple_transaction_release(struct inode *inode, struct file *file);
void simple_transaction_set(struct file *file, size_t n);
/*
* simple attribute files
*
* These attributes behave similar to those in sysfs:
*
* Writing to an attribute immediately sets a value, an open file can be
* written to multiple times.
*
* Reading from an attribute creates a buffer from the value that might get
* read with multiple read calls. When the attribute has been read
* completely, no further read calls are possible until the file is opened
* again.
*
* All attributes contain a text representation of a numeric value
* that are accessed with the get() and set() functions.
*/
#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
static int __fops ## _open(struct inode *inode, struct file *file) \
{ \
__simple_attr_check_format(__fmt, 0ull); \
return simple_attr_open(inode, file, __get, __set, __fmt); \
} \
static const struct file_operations __fops = { \
.owner = THIS_MODULE, \
.open = __fops ## _open, \
.release = simple_attr_release, \
.read = simple_attr_read, \
.write = simple_attr_write, \
.llseek = generic_file_llseek, \
};
static inline __printf(1, 2)
void __simple_attr_check_format(const char *fmt, ...)
{
/* don't do anything, just let the compiler check the arguments; */
}
int simple_attr_open(struct inode *inode, struct file *file,
int (*get)(void *, u64 *), int (*set)(void *, u64),
const char *fmt);
int simple_attr_release(struct inode *inode, struct file *file);
ssize_t simple_attr_read(struct file *file, char __user *buf,
size_t len, loff_t *ppos);
ssize_t simple_attr_write(struct file *file, const char __user *buf,
size_t len, loff_t *ppos);
struct ctl_table;
int proc_nr_files(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp, loff_t *ppos);
int proc_nr_dentry(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp, loff_t *ppos);
int proc_nr_inodes(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp, loff_t *ppos);
int __init get_filesystem_list(char *buf);
#define __FMODE_EXEC ((__force int) FMODE_EXEC)
#define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY)
#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
#define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
(flag & __FMODE_NONOTIFY)))
static inline int is_sxid(mode_t mode)
{
return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
}
static inline void inode_has_no_xattr(struct inode *inode)
{
if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & MS_NOSEC))
inode->i_flags |= S_NOSEC;
}
#endif /* __KERNEL__ */
#endif /* _LINUX_FS_H */
| gpl-2.0 |
apxii/barebox | arch/arm/boards/embest-riotboard/board.c | 2078 | /*
* Copyright (C) 2014 Eric Bénard <[email protected]>
* Copyright (C) 2013 Lucas Stach <[email protected]>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <asm/armlinux.h>
#include <asm/io.h>
#include <bootsource.h>
#include <common.h>
#include <environment.h>
#include <envfs.h>
#include <gpio.h>
#include <init.h>
#include <mach/generic.h>
#include <mach/imx6-regs.h>
#include <mach/imx6.h>
#include <mach/bbu.h>
#include <mfd/imx6q-iomuxc-gpr.h>
#include <linux/sizes.h>
#include <linux/phy.h>
static int ar8035_phy_fixup(struct phy_device *dev)
{
u16 val;
/* Ar803x phy SmartEEE feature cause link status generates glitch,
* which cause ethernet link down/up issue, so disable SmartEEE
*/
phy_write(dev, 0xd, 0x3);
phy_write(dev, 0xe, 0x805d);
phy_write(dev, 0xd, 0x4003);
val = phy_read(dev, 0xe);
phy_write(dev, 0xe, val & ~(1 << 8));
/* To enable AR8031 ouput a 125MHz clk from CLK_25M */
phy_write(dev, 0xd, 0x7);
phy_write(dev, 0xe, 0x8016);
phy_write(dev, 0xd, 0x4007);
val = phy_read(dev, 0xe);
val &= 0xffe3;
val |= 0x18;
phy_write(dev, 0xe, val);
/* introduce tx clock delay */
phy_write(dev, 0x1d, 0x5);
val = phy_read(dev, 0x1e);
val |= 0x0100;
phy_write(dev, 0x1e, val);
return 0;
}
static int riotboard_device_init(void)
{
if (!of_machine_is_compatible("embest,riotboard"))
return 0;
phy_register_fixup_for_uid(0x004dd072, 0xffffffef, ar8035_phy_fixup);
imx6_bbu_internal_mmc_register_handler("emmc", "/dev/mmc3.barebox",
BBU_HANDLER_FLAG_DEFAULT);
barebox_set_hostname("riotboard");
return 0;
}
device_initcall(riotboard_device_init);
| gpl-2.0 |
isaacl/openjdk-jdk | test/javax/print/attribute/TestUnsupportedResolution.java | 3739 | /*
* Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @bug 8033277
* @summary Confirm that scaling of printout is correct. Manual comparison with printout using a supported resolution is needed.
* @run main/manual TestUnsupportedResolution
*/
import java.awt.Graphics;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
import javax.print.*;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.PrintRequestAttributeSet;
import javax.print.attribute.standard.*;
import javax.print.attribute.ResolutionSyntax;
public class TestUnsupportedResolution implements Printable
{
public static void main(String[] args)
{
System.out.println("USAGE: default or no args: it will test 300 dpi\n args is \"600\" : it will test 600 dpi\n------------------------------------------------------\n");
TestUnsupportedResolution pt=new TestUnsupportedResolution();
pt.printWorks(args);
}
public void printWorks(String[] args)
{
PrinterJob job=PrinterJob.getPrinterJob();
job.setPrintable(this);
PrintRequestAttributeSet settings=new HashPrintRequestAttributeSet();
PrinterResolution pr = new PrinterResolution(300, 300, ResolutionSyntax.DPI);
if (args.length > 0 && (args[0].compareTo("600") == 0)) {
pr = new PrinterResolution(600, 600, ResolutionSyntax.DPI);
System.out.println("Adding 600 Dpi attribute");
} else {
System.out.println("Adding 300 Dpi attribute");
}
PrintService ps = job.getPrintService();
boolean resolutionSupported = ps.isAttributeValueSupported(pr, null, null);
System.out.println("Is "+pr+" supported by "+ps+"? "+resolutionSupported);
if (resolutionSupported) {
System.out.println("Resolution is supported.\nTest is not applicable, PASSED");
}
settings.add(pr);
if (args.length > 0 && (args[0].equalsIgnoreCase("fidelity"))) {
settings.add(Fidelity.FIDELITY_TRUE);
System.out.println("Adding Fidelity.FIDELITY_TRUE attribute");
}
if (job.printDialog(settings))
{
try {
job.print(settings);
} catch (PrinterException e) {
e.printStackTrace();
}
}
}
public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) throws PrinterException
{
if (pageIndex>0)
{
return NO_SUCH_PAGE;
}
StringBuffer s=new StringBuffer();
for (int i=0;i<10;i++)
{
s.append("1234567890ABCDEFGHIJ");
}
int x=(int) pageFormat.getImageableX();
int y=(int) (pageFormat.getImageableY()+50);
graphics.drawString(s.toString(), x, y);
return PAGE_EXISTS;
}
}
| gpl-2.0 |
LEPT-Development/android_kernel_lge_msm8916-old | drivers/soc/qcom/lge/lge_charging_scenario.c | 8601 | /*
* LGE charging scenario.
*
* Copyright (C) 2013 LG Electronics
* mansu.lee <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <soc/qcom/lge/lge_charging_scenario.h>
#include <linux/string.h>
/* */
#ifdef DEBUG_LCS
/* For fake battery temp' debug */
#ifdef DEBUG_LCS_DUMMY_TEMP
static int dummy_temp = 25;
static int time_order = 1;
#endif
#endif
#define CHG_MAXIDX 7
static struct batt_temp_table chg_temp_table[CHG_MAXIDX] = {
{INT_MIN, -11, CHG_BATTEMP_BL_M11},
{ -10, -5, CHG_BATTEMP_M10_M5},
{ -4, 41, CHG_BATTEMP_M4_41},
{ 42, 45, CHG_BATTEMP_42_45},
{ 46, 51, CHG_BATTEMP_46_51},
{ 52, 55, CHG_BATTEMP_52_OT},
{ 56, INT_MAX, CHG_BATTEMP_AB_OT},
};
static enum lge_charging_states charging_state;
static enum lge_states_changes states_change;
static int change_charger;
static int pseudo_chg_ui;
#ifdef CONFIG_LGE_THERMALE_CHG_CONTROL
static int last_thermal_current;
#endif
#ifdef CONFIG_LGE_ADJUST_BATT_TEMP
#define MAX_BATT_TEMP_CHECK_COUNT 2
static int adjust_batt_temp(int batt_temp)
{
static int prev_batt_temp = 25;
static int count = 1;
pr_info("before adjust batt_temp = %d\n", batt_temp);
if (batt_temp >= 40 && batt_temp <= 50
&& batt_temp - prev_batt_temp > -2
&& batt_temp - prev_batt_temp < 3) {
if (batt_temp == prev_batt_temp)
count++;
if (count >= MAX_BATT_TEMP_CHECK_COUNT) {
/* use the current temp */
count = 1;
} else {
/* use the previous temp */
batt_temp = prev_batt_temp;
}
} else {
count = 1;
}
prev_batt_temp = batt_temp;
return batt_temp;
}
#endif
static enum lge_battemp_states determine_batt_temp_state(int batt_temp)
{
int cnt;
#ifdef CONFIG_LGE_ADJUST_BATT_TEMP
batt_temp = adjust_batt_temp(batt_temp);
#endif
/* Decrease order */
for (cnt = (CHG_MAXIDX-1); 0 <= cnt; cnt--) {
if (chg_temp_table[cnt].min <= batt_temp &&
batt_temp <= chg_temp_table[cnt].max)
break;
}
return chg_temp_table[cnt].battemp_state;
}
static enum lge_charging_states
determine_lge_charging_state(enum lge_battemp_states battemp_st, int batt_volt)
{
enum lge_charging_states next_state = charging_state;
states_change = STS_CHE_NONE;
/* Determine next charging status Based on previous status */
switch (charging_state) {
case CHG_BATT_NORMAL_STATE:
if (battemp_st >= CHG_BATTEMP_AB_OT ||
battemp_st <= CHG_BATTEMP_BL_M11) {
states_change = STS_CHE_NORMAL_TO_STPCHG;
if (battemp_st <= CHG_BATTEMP_BL_M11)
#ifdef CONFIG_LGE_PSEUDO_CHG_UI
pseudo_chg_ui = 1;
#else
pseudo_chg_ui = 0;
#endif
else
pseudo_chg_ui = 0;
next_state = CHG_BATT_STPCHG_STATE;
} else if (battemp_st >= CHG_BATTEMP_46_51) {
if (batt_volt > DC_IUSB_VOLTUV) {
states_change = STS_CHE_NORMAL_TO_STPCHG;
pseudo_chg_ui = 1;
next_state = CHG_BATT_STPCHG_STATE;
} else {
states_change = STS_CHE_NORMAL_TO_DECCUR;
pseudo_chg_ui = 0;
next_state = CHG_BATT_DECCUR_STATE;
}
}
break;
case CHG_BATT_DECCUR_STATE:
if (battemp_st >= CHG_BATTEMP_AB_OT ||
battemp_st <= CHG_BATTEMP_BL_M11) {
states_change = STS_CHE_DECCUR_TO_STPCHG;
if (battemp_st <= CHG_BATTEMP_BL_M11)
#ifdef CONFIG_LGE_PSEUDO_CHG_UI
pseudo_chg_ui = 1;
#else
pseudo_chg_ui = 0;
#endif
else
pseudo_chg_ui = 0;
next_state = CHG_BATT_STPCHG_STATE;
} else if (battemp_st <= CHG_BATTEMP_M4_41) {
states_change = STS_CHE_DECCUR_TO_NORMAL;
pseudo_chg_ui = 0;
next_state = CHG_BATT_NORMAL_STATE;
} else if (batt_volt > DC_IUSB_VOLTUV) {
states_change = STS_CHE_DECCUR_TO_STPCHG;
pseudo_chg_ui = 1;
next_state = CHG_BATT_STPCHG_STATE;
}
break;
case CHG_BATT_WARNIG_STATE:
break;
case CHG_BATT_STPCHG_STATE:
if (battemp_st == CHG_BATTEMP_M4_41) {
states_change = STS_CHE_STPCHG_TO_NORMAL;
pseudo_chg_ui = 0;
next_state = CHG_BATT_NORMAL_STATE;
}
else if (batt_volt < DC_IUSB_VOLTUV &&
battemp_st < CHG_BATTEMP_52_OT &&
battemp_st > CHG_BATTEMP_M10_M5) {
states_change = STS_CHE_STPCHG_TO_DECCUR;
pseudo_chg_ui = 0;
next_state = CHG_BATT_DECCUR_STATE;
}
else if (batt_volt >= DC_IUSB_VOLTUV &&
battemp_st < CHG_BATTEMP_52_OT &&
battemp_st > CHG_BATTEMP_M10_M5) {
pseudo_chg_ui = 1;
}
else if (battemp_st >= CHG_BATTEMP_AB_OT) {
pseudo_chg_ui = 0;
next_state = CHG_BATT_STPCHG_STATE;
}
break;
default:
pr_err("unknown charging status. %d\n", charging_state);
break;
}
return next_state;
}
void lge_monitor_batt_temp(struct charging_info req, struct charging_rsp *res)
{
enum lge_battemp_states battemp_state;
enum lge_charging_states pre_state;
#ifdef DEBUG_LCS
#ifdef DEBUG_LCS_DUMMY_TEMP
if (time_order == 1) {
dummy_temp++;
if (dummy_temp > 65)
time_order = 0;
} else {
dummy_temp--;
if (dummy_temp < -15)
time_order = 1;
}
req.batt_temp = dummy_temp;
#endif
#endif
if (change_charger ^ req.is_charger || req.is_charger_changed) {
change_charger = req.is_charger;
if (req.is_charger) {
charging_state = CHG_BATT_NORMAL_STATE;
res->force_update = true;
} else
res->force_update = false;
} else {
res->force_update = false;
}
pre_state = charging_state;
battemp_state =
determine_batt_temp_state(req.batt_temp);
charging_state =
determine_lge_charging_state(battemp_state, req.batt_volt);
res->state = charging_state;
res->change_lvl = states_change;
res->disable_chg =
charging_state == CHG_BATT_STPCHG_STATE ? true : false;
#ifdef CONFIG_LGE_THERMALE_CHG_CONTROL
if (charging_state == CHG_BATT_NORMAL_STATE) {
if (req.chg_current_te <= req.chg_current_ma)
res->dc_current = req.chg_current_te;
else
res->dc_current = req.chg_current_ma;
} else if (charging_state == CHG_BATT_DECCUR_STATE) {
if (req.chg_current_te <= DC_IUSB_CURRENT)
res->dc_current = req.chg_current_te;
else
res->dc_current = DC_IUSB_CURRENT;
} else {
res->dc_current = DC_CURRENT_DEF;
}
if (last_thermal_current ^ res->dc_current) {
last_thermal_current = res->dc_current;
res->force_update = true;
}
#else
res->dc_current =
charging_state ==
CHG_BATT_DECCUR_STATE ? DC_IUSB_CURRENT : DC_CURRENT_DEF;
#endif
res->btm_state = BTM_HEALTH_GOOD;
if (battemp_state >= CHG_BATTEMP_AB_OT)
res->btm_state = BTM_HEALTH_OVERHEAT;
else if (battemp_state <= CHG_BATTEMP_BL_M11)
res->btm_state = BTM_HEALTH_COLD;
else
res->btm_state = BTM_HEALTH_GOOD;
res->pseudo_chg_ui = pseudo_chg_ui;
#ifdef DEBUG_LCS
pr_err("DLCS ==============================================\n");
#ifdef DEBUG_LCS_DUMMY_TEMP
pr_err("DLCS : dummy battery temperature = %d\n", dummy_temp);
#endif
pr_err("DLCS : battery temperature states = %d\n", battemp_state);
pr_err("DLCS : res -> state = %d\n", res->state);
pr_err("DLCS : res -> change_lvl = %d\n", res->change_lvl);
pr_err("DLCS : res -> force_update = %d\n", res->force_update ? 1 : 0);
pr_err("DLCS : res -> chg_disable = %d\n", res->disable_chg ? 1 : 0);
pr_err("DLCS : res -> dc_current = %d\n", res->dc_current);
pr_err("DLCS : res -> btm_state = %d\n", res->btm_state);
pr_err("DLCS : res -> is_charger = %d\n", req.is_charger);
pr_err("DLCS : res -> pseudo_chg_ui= %d\n", res->pseudo_chg_ui);
#ifdef CONFIG_LGE_THERMALE_CHG_CONTROL
pr_err("DLCS : req -> chg_current = %d\n", req.chg_current_te);
#endif
pr_err("DLCS ==============================================\n");
#endif
#ifdef CONFIG_LGE_THERMALE_CHG_CONTROL
pr_err("LGE charging scenario : state %d -> %d(%d-%d),",
pre_state, charging_state, res->change_lvl,
res->force_update ? 1 : 0);
pr_err(" temp=%d, volt=%d, BTM=%d, charger=%d,",
req.batt_temp, req.batt_volt / 1000,
res->btm_state, req.is_charger);
pr_err(" cur_set=%d/%d, chg_cur = %d\n",
req.chg_current_te, res->dc_current, req.current_now);
#else
pr_err("LGE charging scenario : state %d -> %d(%d-%d),",
pre_state, charging_state, res->change_lvl,
res->force_update ? 1 : 0);
pr_err(" temp=%d, volt=%d, BTM=%d,",
req.batt_temp, req.batt_volt / 1000, res->btm_state);
pr_err(" charger=%d, chg_cur = %d\n",
req.is_charger, req.current_now);
#endif
}
| gpl-2.0 |
groundwater/glibc | time/tzset.c | 17278 | /* Copyright (C) 1991-2014 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <ctype.h>
#include <errno.h>
#include <bits/libc-lock.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define NOID
#include <timezone/tzfile.h>
char *__tzname[2] = { (char *) "GMT", (char *) "GMT" };
int __daylight = 0;
long int __timezone = 0L;
weak_alias (__tzname, tzname)
weak_alias (__daylight, daylight)
weak_alias (__timezone, timezone)
/* This locks all the state variables in tzfile.c and this file. */
__libc_lock_define_initialized (static, tzset_lock)
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define sign(x) ((x) < 0 ? -1 : 1)
/* This structure contains all the information about a
timezone given in the POSIX standard TZ envariable. */
typedef struct
{
const char *name;
/* When to change. */
enum { J0, J1, M } type; /* Interpretation of: */
unsigned short int m, n, d; /* Month, week, day. */
int secs; /* Time of day. */
long int offset; /* Seconds east of GMT (west if < 0). */
/* We cache the computed time of change for a
given year so we don't have to recompute it. */
time_t change; /* When to change to this zone. */
int computed_for; /* Year above is computed for. */
} tz_rule;
/* tz_rules[0] is standard, tz_rules[1] is daylight. */
static tz_rule tz_rules[2];
static void compute_change (tz_rule *rule, int year) __THROW internal_function;
static void tzset_internal (int always, int explicit)
__THROW internal_function;
/* List of buffers containing time zone strings. */
struct tzstring_l
{
struct tzstring_l *next;
size_t len; /* strlen(data) - doesn't count terminating NUL! */
char data[0];
};
static struct tzstring_l *tzstring_list;
/* Allocate a permanent home for S. It will never be moved or deallocated,
but may share space with other strings.
Don't modify the returned string. */
char *
__tzstring (const char *s)
{
char *p;
struct tzstring_l *t, *u, *new;
size_t len = strlen (s);
/* Walk the list and look for a match. If this string is the same
as the end of an already-allocated string, it can share space. */
for (u = t = tzstring_list; t; u = t, t = t->next)
if (len <= t->len)
{
p = &t->data[t->len - len];
if (strcmp (s, p) == 0)
return p;
}
/* Not found; allocate a new buffer. */
new = malloc (sizeof (struct tzstring_l) + len + 1);
if (!new)
return NULL;
new->next = NULL;
new->len = len;
strcpy (new->data, s);
if (u)
u->next = new;
else
tzstring_list = new;
return new->data;
}
/* Maximum length of a timezone name. tzset_internal keeps this up to date
(never decreasing it) when ! __use_tzfile.
tzfile.c keeps it up to date when __use_tzfile. */
size_t __tzname_cur_max;
long int
__tzname_max (void)
{
__libc_lock_lock (tzset_lock);
tzset_internal (0, 0);
__libc_lock_unlock (tzset_lock);
return __tzname_cur_max;
}
static char *old_tz;
static void
internal_function
update_vars (void)
{
__daylight = tz_rules[0].offset != tz_rules[1].offset;
__timezone = -tz_rules[0].offset;
__tzname[0] = (char *) tz_rules[0].name;
__tzname[1] = (char *) tz_rules[1].name;
/* Keep __tzname_cur_max up to date. */
size_t len0 = strlen (__tzname[0]);
size_t len1 = strlen (__tzname[1]);
if (len0 > __tzname_cur_max)
__tzname_cur_max = len0;
if (len1 > __tzname_cur_max)
__tzname_cur_max = len1;
}
static unsigned int
__attribute_noinline__
compute_offset (unsigned int ss, unsigned int mm, unsigned int hh)
{
return min (ss, 59) + min (mm, 59) * 60 + min (hh, 24) * 60 * 60;
}
/* Parse the POSIX TZ-style string. */
void
__tzset_parse_tz (tz)
const char *tz;
{
unsigned short int hh, mm, ss;
/* Clear out old state and reset to unnamed UTC. */
memset (tz_rules, '\0', sizeof tz_rules);
tz_rules[0].name = tz_rules[1].name = "";
/* Get the standard timezone name. */
char *tzbuf = strdupa (tz);
int consumed;
if (sscanf (tz, "%[A-Za-z]%n", tzbuf, &consumed) != 1)
{
/* Check for the quoted version. */
char *wp = tzbuf;
if (__glibc_unlikely (*tz++ != '<'))
goto out;
while (isalnum (*tz) || *tz == '+' || *tz == '-')
*wp++ = *tz++;
if (__glibc_unlikely (*tz++ != '>' || wp - tzbuf < 3))
goto out;
*wp = '\0';
}
else if (__glibc_unlikely (consumed < 3))
goto out;
else
tz += consumed;
tz_rules[0].name = __tzstring (tzbuf);
/* Figure out the standard offset from UTC. */
if (*tz == '\0' || (*tz != '+' && *tz != '-' && !isdigit (*tz)))
goto out;
if (*tz == '-' || *tz == '+')
tz_rules[0].offset = *tz++ == '-' ? 1L : -1L;
else
tz_rules[0].offset = -1L;
switch (sscanf (tz, "%hu%n:%hu%n:%hu%n",
&hh, &consumed, &mm, &consumed, &ss, &consumed))
{
default:
tz_rules[0].offset = 0;
goto out;
case 1:
mm = 0;
case 2:
ss = 0;
case 3:
break;
}
tz_rules[0].offset *= compute_offset (ss, mm, hh);
tz += consumed;
/* Get the DST timezone name (if any). */
if (*tz != '\0')
{
if (sscanf (tz, "%[A-Za-z]%n", tzbuf, &consumed) != 1)
{
/* Check for the quoted version. */
char *wp = tzbuf;
const char *rp = tz;
if (__glibc_unlikely (*rp++ != '<'))
/* Punt on name, set up the offsets. */
goto done_names;
while (isalnum (*rp) || *rp == '+' || *rp == '-')
*wp++ = *rp++;
if (__glibc_unlikely (*rp++ != '>' || wp - tzbuf < 3))
/* Punt on name, set up the offsets. */
goto done_names;
*wp = '\0';
tz = rp;
}
else if (__glibc_unlikely (consumed < 3))
/* Punt on name, set up the offsets. */
goto done_names;
else
tz += consumed;
tz_rules[1].name = __tzstring (tzbuf);
/* Figure out the DST offset from GMT. */
if (*tz == '-' || *tz == '+')
tz_rules[1].offset = *tz++ == '-' ? 1L : -1L;
else
tz_rules[1].offset = -1L;
switch (sscanf (tz, "%hu%n:%hu%n:%hu%n",
&hh, &consumed, &mm, &consumed, &ss, &consumed))
{
default:
/* Default to one hour later than standard time. */
tz_rules[1].offset = tz_rules[0].offset + (60 * 60);
break;
case 1:
mm = 0;
case 2:
ss = 0;
case 3:
tz_rules[1].offset *= compute_offset (ss, mm, hh);
tz += consumed;
break;
}
if (*tz == '\0' || (tz[0] == ',' && tz[1] == '\0'))
{
/* There is no rule. See if there is a default rule file. */
__tzfile_default (tz_rules[0].name, tz_rules[1].name,
tz_rules[0].offset, tz_rules[1].offset);
if (__use_tzfile)
{
free (old_tz);
old_tz = NULL;
return;
}
}
}
else
{
/* There is no DST. */
tz_rules[1].name = tz_rules[0].name;
tz_rules[1].offset = tz_rules[0].offset;
goto out;
}
done_names:
/* Figure out the standard <-> DST rules. */
for (unsigned int whichrule = 0; whichrule < 2; ++whichrule)
{
tz_rule *tzr = &tz_rules[whichrule];
/* Ignore comma to support string following the incorrect
specification in early POSIX.1 printings. */
tz += *tz == ',';
/* Get the date of the change. */
if (*tz == 'J' || isdigit (*tz))
{
char *end;
tzr->type = *tz == 'J' ? J1 : J0;
if (tzr->type == J1 && !isdigit (*++tz))
goto out;
unsigned long int d = strtoul (tz, &end, 10);
if (end == tz || d > 365)
goto out;
if (tzr->type == J1 && d == 0)
goto out;
tzr->d = d;
tz = end;
}
else if (*tz == 'M')
{
tzr->type = M;
if (sscanf (tz, "M%hu.%hu.%hu%n",
&tzr->m, &tzr->n, &tzr->d, &consumed) != 3
|| tzr->m < 1 || tzr->m > 12
|| tzr->n < 1 || tzr->n > 5 || tzr->d > 6)
goto out;
tz += consumed;
}
else if (*tz == '\0')
{
/* Daylight time rules in the U.S. are defined in the
U.S. Code, Title 15, Chapter 6, Subchapter IX - Standard
Time. These dates were established by Congress in the
Energy Policy Act of 2005 [Pub. L. no. 109-58, 119 Stat 594
(2005)].
Below is the equivalent of "M3.2.0,M11.1.0" [/2 not needed
since 2:00AM is the default]. */
tzr->type = M;
if (tzr == &tz_rules[0])
{
tzr->m = 3;
tzr->n = 2;
tzr->d = 0;
}
else
{
tzr->m = 11;
tzr->n = 1;
tzr->d = 0;
}
}
else
goto out;
if (*tz != '\0' && *tz != '/' && *tz != ',')
goto out;
else if (*tz == '/')
{
/* Get the time of day of the change. */
int negative;
++tz;
if (*tz == '\0')
goto out;
negative = *tz == '-';
tz += negative;
consumed = 0;
switch (sscanf (tz, "%hu%n:%hu%n:%hu%n",
&hh, &consumed, &mm, &consumed, &ss, &consumed))
{
default:
hh = 2; /* Default to 2:00 AM. */
case 1:
mm = 0;
case 2:
ss = 0;
case 3:
break;
}
tz += consumed;
tzr->secs = (negative ? -1 : 1) * ((hh * 60 * 60) + (mm * 60) + ss);
}
else
/* Default to 2:00 AM. */
tzr->secs = 2 * 60 * 60;
tzr->computed_for = -1;
}
out:
update_vars ();
}
/* Interpret the TZ envariable. */
static void
internal_function
tzset_internal (always, explicit)
int always;
int explicit;
{
static int is_initialized;
const char *tz;
if (is_initialized && !always)
return;
is_initialized = 1;
/* Examine the TZ environment variable. */
tz = getenv ("TZ");
if (tz == NULL && !explicit)
/* Use the site-wide default. This is a file name which means we
would not see changes to the file if we compare only the file
name for change. We want to notice file changes if tzset() has
been called explicitly. Leave TZ as NULL in this case. */
tz = TZDEFAULT;
if (tz && *tz == '\0')
/* User specified the empty string; use UTC explicitly. */
tz = "Universal";
/* A leading colon means "implementation defined syntax".
We ignore the colon and always use the same algorithm:
try a data file, and if none exists parse the 1003.1 syntax. */
if (tz && *tz == ':')
++tz;
/* Check whether the value changed since the last run. */
if (old_tz != NULL && tz != NULL && strcmp (tz, old_tz) == 0)
/* No change, simply return. */
return;
if (tz == NULL)
/* No user specification; use the site-wide default. */
tz = TZDEFAULT;
tz_rules[0].name = NULL;
tz_rules[1].name = NULL;
/* Save the value of `tz'. */
free (old_tz);
old_tz = tz ? __strdup (tz) : NULL;
/* Try to read a data file. */
__tzfile_read (tz, 0, NULL);
if (__use_tzfile)
return;
/* No data file found. Default to UTC if nothing specified. */
if (tz == NULL || *tz == '\0'
|| (TZDEFAULT != NULL && strcmp (tz, TZDEFAULT) == 0))
{
memset (tz_rules, '\0', sizeof tz_rules);
tz_rules[0].name = tz_rules[1].name = "UTC";
if (J0 != 0)
tz_rules[0].type = tz_rules[1].type = J0;
tz_rules[0].change = tz_rules[1].change = (time_t) -1;
update_vars ();
return;
}
__tzset_parse_tz (tz);
}
/* Figure out the exact time (as a time_t) in YEAR
when the change described by RULE will occur and
put it in RULE->change, saving YEAR in RULE->computed_for. */
static void
internal_function
compute_change (rule, year)
tz_rule *rule;
int year;
{
time_t t;
if (year != -1 && rule->computed_for == year)
/* Operations on times in 2 BC will be slower. Oh well. */
return;
/* First set T to January 1st, 0:00:00 GMT in YEAR. */
if (year > 1970)
t = ((year - 1970) * 365
+ /* Compute the number of leapdays between 1970 and YEAR
(exclusive). There is a leapday every 4th year ... */
+ ((year - 1) / 4 - 1970 / 4)
/* ... except every 100th year ... */
- ((year - 1) / 100 - 1970 / 100)
/* ... but still every 400th year. */
+ ((year - 1) / 400 - 1970 / 400)) * SECSPERDAY;
else
t = 0;
switch (rule->type)
{
case J1:
/* Jn - Julian day, 1 == January 1, 60 == March 1 even in leap years.
In non-leap years, or if the day number is 59 or less, just
add SECSPERDAY times the day number-1 to the time of
January 1, midnight, to get the day. */
t += (rule->d - 1) * SECSPERDAY;
if (rule->d >= 60 && __isleap (year))
t += SECSPERDAY;
break;
case J0:
/* n - Day of year.
Just add SECSPERDAY times the day number to the time of Jan 1st. */
t += rule->d * SECSPERDAY;
break;
case M:
/* Mm.n.d - Nth "Dth day" of month M. */
{
unsigned int i;
int d, m1, yy0, yy1, yy2, dow;
const unsigned short int *myday =
&__mon_yday[__isleap (year)][rule->m];
/* First add SECSPERDAY for each day in months before M. */
t += myday[-1] * SECSPERDAY;
/* Use Zeller's Congruence to get day-of-week of first day of month. */
m1 = (rule->m + 9) % 12 + 1;
yy0 = (rule->m <= 2) ? (year - 1) : year;
yy1 = yy0 / 100;
yy2 = yy0 % 100;
dow = ((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
if (dow < 0)
dow += 7;
/* DOW is the day-of-week of the first day of the month. Get the
day-of-month (zero-origin) of the first DOW day of the month. */
d = rule->d - dow;
if (d < 0)
d += 7;
for (i = 1; i < rule->n; ++i)
{
if (d + 7 >= (int) myday[0] - myday[-1])
break;
d += 7;
}
/* D is the day-of-month (zero-origin) of the day we want. */
t += d * SECSPERDAY;
}
break;
}
/* T is now the Epoch-relative time of 0:00:00 GMT on the day we want.
Just add the time of day and local offset from GMT, and we're done. */
rule->change = t - rule->offset + rule->secs;
rule->computed_for = year;
}
/* Figure out the correct timezone for TM and set `__tzname',
`__timezone', and `__daylight' accordingly. */
void
internal_function
__tz_compute (timer, tm, use_localtime)
time_t timer;
struct tm *tm;
int use_localtime;
{
compute_change (&tz_rules[0], 1900 + tm->tm_year);
compute_change (&tz_rules[1], 1900 + tm->tm_year);
if (use_localtime)
{
int isdst;
/* We have to distinguish between northern and southern
hemisphere. For the latter the daylight saving time
ends in the next year. */
if (__builtin_expect (tz_rules[0].change
> tz_rules[1].change, 0))
isdst = (timer < tz_rules[1].change
|| timer >= tz_rules[0].change);
else
isdst = (timer >= tz_rules[0].change
&& timer < tz_rules[1].change);
tm->tm_isdst = isdst;
tm->tm_zone = __tzname[isdst];
tm->tm_gmtoff = tz_rules[isdst].offset;
}
}
/* Reinterpret the TZ environment variable and set `tzname'. */
#undef tzset
void
__tzset (void)
{
__libc_lock_lock (tzset_lock);
tzset_internal (1, 1);
if (!__use_tzfile)
{
/* Set `tzname'. */
__tzname[0] = (char *) tz_rules[0].name;
__tzname[1] = (char *) tz_rules[1].name;
}
__libc_lock_unlock (tzset_lock);
}
weak_alias (__tzset, tzset)
/* Return the `struct tm' representation of *TIMER in the local timezone.
Use local time if USE_LOCALTIME is nonzero, UTC otherwise. */
struct tm *
__tz_convert (const time_t *timer, int use_localtime, struct tm *tp)
{
long int leap_correction;
int leap_extra_secs;
if (timer == NULL)
{
__set_errno (EINVAL);
return NULL;
}
__libc_lock_lock (tzset_lock);
/* Update internal database according to current TZ setting.
POSIX.1 8.3.7.2 says that localtime_r is not required to set tzname.
This is a good idea since this allows at least a bit more parallelism. */
tzset_internal (tp == &_tmbuf && use_localtime, 1);
if (__use_tzfile)
__tzfile_compute (*timer, use_localtime, &leap_correction,
&leap_extra_secs, tp);
else
{
if (! __offtime (timer, 0, tp))
tp = NULL;
else
__tz_compute (*timer, tp, use_localtime);
leap_correction = 0L;
leap_extra_secs = 0;
}
if (tp)
{
if (! use_localtime)
{
tp->tm_isdst = 0;
tp->tm_zone = "GMT";
tp->tm_gmtoff = 0L;
}
if (__offtime (timer, tp->tm_gmtoff - leap_correction, tp))
tp->tm_sec += leap_extra_secs;
else
tp = NULL;
}
__libc_lock_unlock (tzset_lock);
return tp;
}
libc_freeres_fn (free_mem)
{
while (tzstring_list != NULL)
{
struct tzstring_l *old = tzstring_list;
tzstring_list = tzstring_list->next;
free (old);
}
free (old_tz);
old_tz = NULL;
}
| gpl-2.0 |
InES-HPMM/linux-l4t | arch/arm/mach-tegra/panel-s-wuxga-8-0.c | 6402 | /*
* arch/arm/mach-tegra/panel-s-wuxga-8-0.c
*
* Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <mach/dc.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/regulator/consumer.h>
#include <linux/platform/tegra/panel-cy8c.h>
#include "board.h"
#include "board-panel.h"
#include "devices.h"
#define DSI_PANEL_RESET 1
static bool reg_requested;
static struct regulator *avdd_lcd_3v0;
static struct regulator *dvdd_lcd_1v8;
static struct regulator *vpp_lcd;
static struct regulator *vmm_lcd;
static struct device *dc_dev;
static u16 en_panel_rst;
static int dsi_s_wuxga_8_0_regulator_get(struct device *dev)
{
int err = 0;
if (reg_requested)
return 0;
avdd_lcd_3v0 = regulator_get(dev, "avdd_lcd");
if (IS_ERR_OR_NULL(avdd_lcd_3v0)) {
pr_err("avdd_lcd regulator get failed\n");
err = PTR_ERR(avdd_lcd_3v0);
avdd_lcd_3v0 = NULL;
goto fail;
}
dvdd_lcd_1v8 = regulator_get(dev, "dvdd_lcd");
if (IS_ERR_OR_NULL(dvdd_lcd_1v8)) {
pr_err("dvdd_lcd_1v8 regulator get failed\n");
err = PTR_ERR(dvdd_lcd_1v8);
dvdd_lcd_1v8 = NULL;
goto fail;
}
vpp_lcd = regulator_get(dev, "outp");
if (IS_ERR_OR_NULL(vpp_lcd)) {
pr_err("vpp_lcd regulator get failed\n");
err = PTR_ERR(vpp_lcd);
vpp_lcd = NULL;
goto fail;
}
vmm_lcd = regulator_get(dev, "outn");
if (IS_ERR_OR_NULL(vmm_lcd)) {
pr_err("vmm_lcd regulator get failed\n");
err = PTR_ERR(vmm_lcd);
vmm_lcd = NULL;
goto fail;
}
reg_requested = true;
return 0;
fail:
return err;
}
static int dsi_s_wuxga_8_0_enable(struct device *dev)
{
int err = 0;
err = cy8c_panel_set_state(true);
if (!err)
goto success;
else if (err == -ENODEV)
err = 0; /* no cy8c, enable rails normally */
else {
pr_err("cy8c detected but panel enable failed\n");
goto fail;
}
err = dsi_s_wuxga_8_0_regulator_get(dev);
if (err < 0) {
pr_err("dsi regulator get failed\n");
goto fail;
}
err = tegra_panel_gpio_get_dt("s,wuxga-8-0", &panel_of);
if (err < 0) {
pr_err("display gpio get failed\n");
goto fail;
}
if (gpio_is_valid(panel_of.panel_gpio[TEGRA_GPIO_RESET]))
en_panel_rst = panel_of.panel_gpio[TEGRA_GPIO_RESET];
else {
pr_err("display reset gpio invalid\n");
goto fail;
}
if (dvdd_lcd_1v8) {
err = regulator_enable(dvdd_lcd_1v8);
if (err < 0) {
pr_err("dvdd_lcd regulator enable failed\n");
goto fail;
}
}
usleep_range(500, 1500);
if (avdd_lcd_3v0) {
err = regulator_enable(avdd_lcd_3v0);
if (err < 0) {
pr_err("avdd_lcd regulator enable failed\n");
goto fail;
}
}
usleep_range(500, 1500);
if (vpp_lcd) {
err = regulator_enable(vpp_lcd);
if (err < 0) {
pr_err("vpp_lcd regulator enable failed\n");
goto fail;
}
err = regulator_set_voltage(vpp_lcd, 5500000, 5500000);
if (err < 0) {
pr_err("vpp_lcd regulator failed changing voltage\n");
goto fail;
}
}
usleep_range(500, 1500);
if (vmm_lcd) {
err = regulator_enable(vmm_lcd);
if (err < 0) {
pr_err("vmm_lcd regulator enable failed\n");
goto fail;
}
err = regulator_set_voltage(vmm_lcd, 5500000, 5500000);
if (err < 0) {
pr_err("vmm_lcd regulator failed changing voltage\n");
goto fail;
}
}
usleep_range(7000, 8000);
#if DSI_PANEL_RESET
if (!tegra_dc_initialized(dev)) {
err = gpio_direction_output(en_panel_rst, 1);
if (err < 0) {
pr_err("setting display reset gpio value failed\n");
goto fail;
}
}
#endif
success:
dc_dev = dev;
return 0;
fail:
return err;
}
static int dsi_s_wuxga_8_0_disable(struct device *dev)
{
int err;
err = cy8c_panel_set_state(false);
if (!err)
goto end;
else if (err == -ENODEV)
err = 0; /* no cy8c, disable rails normally */
else {
pr_err("cy8c detected but panel disable failed\n");
goto end;
}
if (gpio_is_valid(en_panel_rst)) {
/* Wait for 50ms before triggering panel reset */
msleep(50);
gpio_set_value(en_panel_rst, 0);
usleep_range(500, 1000);
} else
pr_err("ERROR! display reset gpio invalid\n");
if (vmm_lcd)
regulator_disable(vmm_lcd);
usleep_range(1000, 2000);
if (vpp_lcd)
regulator_disable(vpp_lcd);
usleep_range(1500, 2000);
if (avdd_lcd_3v0)
regulator_disable(avdd_lcd_3v0);
usleep_range(1500, 2000);
if (dvdd_lcd_1v8)
regulator_disable(dvdd_lcd_1v8);
/* Min delay of 140ms required to avoid turning
* the panel on too soon after power off */
msleep(140);
end:
dc_dev = NULL;
return err;
}
static int dsi_s_wuxga_8_0_postsuspend(void)
{
return 0;
}
static int dsi_s_wuxga_8_0_bl_notify(struct device *dev, int brightness)
{
int cur_sd_brightness;
struct backlight_device *bl = NULL;
struct pwm_bl_data *pb = NULL;
bl = (struct backlight_device *)dev_get_drvdata(dev);
pb = (struct pwm_bl_data *)dev_get_drvdata(&bl->dev);
if (dc_dev)
nvsd_check_prism_thresh(dc_dev, brightness);
cur_sd_brightness = atomic_read(&sd_brightness);
/* SD brightness is a percentage */
brightness = (brightness * cur_sd_brightness) / 255;
/* Apply any backlight response curve */
if (brightness > 255)
pr_info("Error: Brightness > 255!\n");
else if (pb->bl_measured)
brightness = pb->bl_measured[brightness];
return brightness;
}
static int dsi_s_wuxga_8_0_check_fb(struct device *dev,
struct fb_info *info)
{
struct platform_device *pdev = NULL;
pdev = to_platform_device(bus_find_device_by_name(
&platform_bus_type, NULL, "tegradc.0"));
return info->device == &pdev->dev;
}
static struct pwm_bl_data_dt_ops dsi_s_wuxga_8_0_pwm_bl_ops = {
.notify = dsi_s_wuxga_8_0_bl_notify,
.check_fb = dsi_s_wuxga_8_0_check_fb,
.blnode_compatible = "s,wuxga-8-0-bl",
};
struct tegra_panel_ops dsi_s_wuxga_8_0_ops = {
.enable = dsi_s_wuxga_8_0_enable,
.disable = dsi_s_wuxga_8_0_disable,
.postsuspend = dsi_s_wuxga_8_0_postsuspend,
.pwm_bl_ops = &dsi_s_wuxga_8_0_pwm_bl_ops,
};
| gpl-2.0 |
TrinityCore/TrinityCore | sql/old/9.x/world/22012_2022_03_06/2022_02_27_06_world_2020_09_20_00_world.sql | 378 | --
DELETE FROM `trinity_string` WHERE `entry` IN (6,7,8,191,192,193,194);
INSERT INTO `trinity_string` (`entry`,`content_default`) VALUES
(6, 'Command \'%.*s\' does not exist'),
(7, 'Subcommand \'%.*s\' is ambiguous:'),
(8, 'Possible subcommands:'),
(191, '|- %.*s'),
(192, '|- %.*s ...'),
(193, 'Subcommand \'%.*s\' does not exist.'),
(194, 'Command \'%.*s\' is ambiguous:');
| gpl-2.0 |
md-5/jdk10 | test/hotspot/jtreg/vmTestbase/nsk/jvmti/GetThreadState/thrstat003/libthrstat003.cpp | 1327 | /*
* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include "native_thread.cpp"
#include "nsk_tools.cpp"
#include "jni_tools.cpp"
#include "jvmti_tools.cpp"
#include "agent_tools.cpp"
#include "jvmti_FollowRefObjects.cpp"
#include "Injector.cpp"
#include "JVMTITools.cpp"
#include "agent_common.cpp"
#include "thrstat003.cpp"
| gpl-2.0 |
enslyon/ensl | core/modules/node/src/Plugin/views/row/Rss.php | 4982 | <?php
namespace Drupal\node\Plugin\views\row;
use Drupal\Core\Entity\EntityDisplayRepositoryInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\views\Plugin\views\row\RssPluginBase;
/**
* Plugin which performs a node_view on the resulting object
* and formats it as an RSS item.
*
* @ViewsRow(
* id = "node_rss",
* title = @Translation("Content"),
* help = @Translation("Display the content with standard node view."),
* theme = "views_view_row_rss",
* register_theme = FALSE,
* base = {"node_field_data"},
* display_types = {"feed"}
* )
*/
class Rss extends RssPluginBase {
// Basic properties that let the row style follow relationships.
public $base_table = 'node_field_data';
public $base_field = 'nid';
// Stores the nodes loaded with preRender.
public $nodes = [];
/**
* {@inheritdoc}
*/
protected $entityTypeId = 'node';
/**
* The node storage
*
* @var \Drupal\node\NodeStorageInterface
*/
protected $nodeStorage;
/**
* Constructs the Rss object.
*
* @param array $configuration
* A configuration array containing information about the plugin instance.
* @param string $plugin_id
* The plugin_id for the plugin instance.
* @param mixed $plugin_definition
* The plugin implementation definition.
* @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
* The entity type manager.
* @param \Drupal\Core\Entity\EntityDisplayRepositoryInterface $entity_display_repository
* The entity display repository.
*/
public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeManagerInterface $entity_type_manager, EntityDisplayRepositoryInterface $entity_display_repository = NULL) {
parent::__construct($configuration, $plugin_id, $plugin_definition, $entity_type_manager, $entity_display_repository);
$this->nodeStorage = $entity_type_manager->getStorage('node');
}
/**
* {@inheritdoc}
*/
public function buildOptionsForm_summary_options() {
$options = parent::buildOptionsForm_summary_options();
$options['title'] = $this->t('Title only');
$options['default'] = $this->t('Use site default RSS settings');
return $options;
}
public function summaryTitle() {
$options = $this->buildOptionsForm_summary_options();
return $options[$this->options['view_mode']];
}
public function preRender($values) {
$nids = [];
foreach ($values as $row) {
$nids[] = $row->{$this->field_alias};
}
if (!empty($nids)) {
$this->nodes = $this->nodeStorage->loadMultiple($nids);
}
}
public function render($row) {
global $base_url;
$nid = $row->{$this->field_alias};
if (!is_numeric($nid)) {
return;
}
$display_mode = $this->options['view_mode'];
if ($display_mode == 'default') {
$display_mode = \Drupal::config('system.rss')->get('items.view_mode');
}
// Load the specified node:
/** @var \Drupal\node\NodeInterface $node */
$node = $this->nodes[$nid];
if (empty($node)) {
return;
}
$node->link = $node->toUrl('canonical', ['absolute' => TRUE])->toString();
$node->rss_namespaces = [];
$node->rss_elements = [
[
'key' => 'pubDate',
'value' => gmdate('r', $node->getCreatedTime()),
],
[
'key' => 'dc:creator',
'value' => $node->getOwner()->getDisplayName(),
],
[
'key' => 'guid',
'value' => $node->id() . ' at ' . $base_url,
'attributes' => ['isPermaLink' => 'false'],
],
];
// The node gets built and modules add to or modify $node->rss_elements
// and $node->rss_namespaces.
$build_mode = $display_mode;
$build = node_view($node, $build_mode);
unset($build['#theme']);
if (!empty($node->rss_namespaces)) {
$this->view->style_plugin->namespaces = array_merge($this->view->style_plugin->namespaces, $node->rss_namespaces);
}
elseif (function_exists('rdf_get_namespaces')) {
// Merge RDF namespaces in the XML namespaces in case they are used
// further in the RSS content.
$xml_rdf_namespaces = [];
foreach (rdf_get_namespaces() as $prefix => $uri) {
$xml_rdf_namespaces['xmlns:' . $prefix] = $uri;
}
$this->view->style_plugin->namespaces += $xml_rdf_namespaces;
}
$item = new \stdClass();
if ($display_mode != 'title') {
// We render node contents.
$item->description = $build;
}
$item->title = $node->label();
$item->link = $node->link;
// Provide a reference so that the render call in
// template_preprocess_views_view_row_rss() can still access it.
$item->elements = &$node->rss_elements;
$item->nid = $node->id();
$build = [
'#theme' => $this->themeFunctions(),
'#view' => $this->view,
'#options' => $this->options,
'#row' => $item,
];
return $build;
}
}
| gpl-2.0 |
Exodius/MistCore | sql/updates/world/worldpanda_old_world_updates_2012_2013/2013/08/2013_27_08_world_spell_data_cenarion_ward.sql | 141 | DELETE FROM spell_bonus_data WHERE entry = 102352;
INSERT INTO spell_bonus_data VALUE (102352, 0, 1.04, 0, 0, 'Druid - Cenarion Ward (HoT)'); | gpl-2.0 |
yxl/emscripten-calligra-mobile | plugins/formulashape/elements/TokenElement.cpp | 12060 | /* This file is part of the KDE project
Copyright (C) 2006-2007 Alfredo Beaumont Sainz <[email protected]>
2009 Jeremias Epperlein <[email protected]>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "TokenElement.h"
#include "AttributeManager.h"
#include "FormulaCursor.h"
#include "Dictionary.h"
#include "GlyphElement.h"
#include <KoXmlWriter.h>
#include <KoXmlReader.h>
#include <QPainter>
#include <kdebug.h>
TokenElement::TokenElement( BasicElement* parent ) : BasicElement( parent )
{
m_stretchHorizontally = false;
m_stretchVertically = false;
}
const QList<BasicElement*> TokenElement::childElements() const
{
// only return the mglyph elements
QList<BasicElement*> tmpList;
foreach( GlyphElement* tmp, m_glyphs )
tmpList << tmp;
return tmpList;
}
void TokenElement::paint( QPainter& painter, AttributeManager* am )
{
// set the painter to background color and paint it
painter.setPen( am->colorOf( "mathbackground", this ) );
painter.setBrush( QBrush( painter.pen().color() ) );
painter.drawRect( QRectF( 0.0, 0.0, width(), height() ) );
// set the painter to foreground color and paint the text in the content path
QColor color = am->colorOf( "mathcolor", this );
if (!color.isValid())
color = am->colorOf( "color", this );
painter.translate( m_xoffset, baseLine() );
if(m_stretchHorizontally || m_stretchVertically)
painter.scale(width() / m_originalSize.width(), height() / m_originalSize.height());
painter.setPen( color );
painter.setBrush( QBrush( color ) );
painter.drawPath( m_contentPath );
}
int TokenElement::endPosition() const
{
return m_rawString.length();
}
void TokenElement::layout( const AttributeManager* am )
{
m_offsets.erase(m_offsets.begin(),m_offsets.end());
m_offsets << 0.0;
// Query the font to use
m_font = am->font( this );
QFontMetricsF fm(m_font);
// save the token in an empty path
m_contentPath = QPainterPath();
/* Current bounding box. Note that the left can be negative, for italics etc */
QRectF boundingrect;
if(m_glyphs.isEmpty()) {//optimize for the common case
boundingrect = renderToPath(m_rawString, m_contentPath);
for (int j = 0; j < m_rawString.length(); ++j) {
m_offsets.append(fm.width(m_rawString.left(j+1)));
}
} else {
// replace all the object replacement characters with glyphs
// We have to keep track of the bounding box at all times
QString chunk;
int counter = 0;
for( int i = 0; i < m_rawString.length(); i++ ) {
if( m_rawString[ i ] != QChar::ObjectReplacementCharacter )
chunk.append( m_rawString[ i ] );
else {
m_contentPath.moveTo(boundingrect.right(), 0);
QRectF newbox = renderToPath( chunk, m_contentPath );
boundingrect.setRight( boundingrect.right() + newbox.right());
boundingrect.setTop( qMax(boundingrect.top(), newbox.top()));
boundingrect.setBottom( qMax(boundingrect.bottom(), newbox.bottom()));
qreal glyphoffset = m_offsets.last();
for (int j = 0; j < chunk.length(); ++j) {
m_offsets << fm.width(chunk.left(j+1)) + glyphoffset;
}
m_contentPath.moveTo(boundingrect.right(), 0);
newbox = m_glyphs[ counter ]->renderToPath( QString(), m_contentPath );
boundingrect.setRight( boundingrect.right() + newbox.right());
boundingrect.setTop( qMax(boundingrect.top(), newbox.top()));
boundingrect.setBottom( qMax(boundingrect.bottom(), newbox.bottom()));
m_offsets.append(newbox.width() + m_offsets.last());
counter++;
chunk.clear();
}
}
if( !chunk.isEmpty() ) {
m_contentPath.moveTo(boundingrect.right(), 0);
QRectF newbox = renderToPath( chunk, m_contentPath );
boundingrect.setRight( boundingrect.right() + newbox.right());
boundingrect.setTop( qMax(boundingrect.top(), newbox.top()));
boundingrect.setBottom( qMax(boundingrect.bottom(), newbox.bottom()));
// qreal glyphoffset = m_offsets.last();
for (int j = 0; j < chunk.length(); ++j) {
m_offsets << fm.width(chunk.left(j+1)) + m_offsets.last();
}
}
}
//FIXME: This is only a temporary solution
boundingrect=m_contentPath.boundingRect();
m_offsets.removeLast();
m_offsets.append(m_contentPath.boundingRect().right());
//The left side may be negative, because of italised letters etc. we need to adjust for this when painting
//The qMax is just incase. The bounding box left should never be >0
m_xoffset = qMax(-boundingrect.left(), (qreal)0.0);
// As the text is added to (0,0) the baseline equals the top edge of the
// elements bounding rect, while translating it down the text's baseline moves too
setBaseLine( -boundingrect.y() ); // set baseline accordingly
setWidth( boundingrect.right() + m_xoffset );
setHeight( boundingrect.height() );
m_originalSize = QSizeF(width(), height());
}
bool TokenElement::insertChild( int position, BasicElement* child )
{
Q_UNUSED( position)
Q_UNUSED( child )
//if( child && child->elementType() == Glyph ) {
//m_rawString.insert( QChar( QChar::ObjectReplacementCharacter ) );
// m_glyphs.insert();
// return false;
//} else {
return false;
//}
}
void TokenElement::insertGlyphs ( int position, QList< GlyphElement* > glyphs )
{
for (int i=0; i < glyphs.length(); ++i) {
m_glyphs.insert(position+i,glyphs[i]);
}
}
bool TokenElement::insertText ( int position, const QString& text )
{
m_rawString.insert (position,text);
return true;
}
QList< GlyphElement* > TokenElement::glyphList ( int position, int length )
{
QList<GlyphElement*> tmp;
//find out, how many glyphs we have
int counter=0;
for (int i=position; i<position+length; ++i) {
if (m_rawString[ position ] == QChar::ObjectReplacementCharacter) {
counter++;
}
}
int start=0;
//find out where we should start removing glyphs
if (counter>0) {
for (int i=0; i<position; ++i) {
if (m_rawString[position] == QChar::ObjectReplacementCharacter) {
start++;
}
}
}
for (int i=start; i<start+counter; ++i) {
tmp.append(m_glyphs.at(i));
}
return tmp;
}
int TokenElement::removeText ( int position, int length )
{
//find out, how many glyphs we have
int counter=0;
for (int i=position; i<position+length; ++i) {
if (m_rawString[ position ] == QChar::ObjectReplacementCharacter) {
counter++;
}
}
int start=0;
//find out where we should start removing glyphs
if (counter>0) {
for (int i=0; i<position; ++i) {
if (m_rawString[position] == QChar::ObjectReplacementCharacter) {
start++;
}
}
}
for (int i=start; i<start+counter; ++i) {
m_glyphs.removeAt(i);
}
m_rawString.remove(position,length);
return start;
}
bool TokenElement::setCursorTo(FormulaCursor& cursor, QPointF point) {
int i = 0;
cursor.setCurrentElement(this);
if (cursorOffset(endPosition())<point.x()) {
cursor.setPosition(endPosition());
return true;
}
//Find the letter we clicked on
for( i = 1; i < endPosition(); ++i ) {
if (point.x() < cursorOffset(i)) {
break;
}
}
//Find out, if we should place the cursor before or after the character
if ((point.x()-cursorOffset(i-1))<(cursorOffset(i)-point.x())) {
--i;
}
cursor.setPosition(i);
return true;
}
QLineF TokenElement::cursorLine(int position) const
{
// inside tokens let the token calculate the cursor x offset
qreal tmp = cursorOffset( position );
QPointF top = absoluteBoundingRect().topLeft() + QPointF( tmp, 0 );
QPointF bottom = top + QPointF( 0.0,height() );
return QLineF(top,bottom);
}
bool TokenElement::acceptCursor( const FormulaCursor& cursor )
{
Q_UNUSED( cursor )
return true;
}
bool TokenElement::moveCursor(FormulaCursor& newcursor, FormulaCursor& oldcursor) {
Q_UNUSED( oldcursor )
if ((newcursor.direction()==MoveUp) ||
(newcursor.direction()==MoveDown) ||
(newcursor.isHome() && newcursor.direction()==MoveLeft) ||
(newcursor.isEnd() && newcursor.direction()==MoveRight) ) {
return false;
}
switch( newcursor.direction() ) {
case MoveLeft:
newcursor+=-1;
break;
case MoveRight:
newcursor+=1;
break;
default:
break;
}
return true;
}
qreal TokenElement::cursorOffset( const int position) const
{
return m_offsets[position]+m_xoffset;
}
QFont TokenElement::font() const
{
return m_font;
}
void TokenElement::setText ( const QString& text )
{
removeText(0,m_rawString.length());
insertText(0,text);
}
const QString& TokenElement::text()
{
return m_rawString;
}
bool TokenElement::readMathMLContent( const KoXmlElement& element )
{
// iterate over all child elements ( possible embedded glyphs ) and put the text
// content in the m_rawString and mark glyph positions with
// QChar::ObjectReplacementCharacter
GlyphElement* tmpGlyph;
KoXmlNode node = element.firstChild();
while( !node.isNull() ) {
if( node.isElement() && node.toElement().tagName() == "mglyph" ) {
tmpGlyph = new GlyphElement( this );
m_rawString.append( QChar( QChar::ObjectReplacementCharacter ) );
tmpGlyph->readMathML( node.toElement() );
m_glyphs.append(tmpGlyph);
}
else if( node.isElement() )
return false;
/*
else if (node.isEntityReference()) {
Dictionary dict;
m_rawString.append( dict.mapEntity( node.nodeName() ) );
}
*/
else {
m_rawString.append( node.toText().data() );
}
node = node.nextSibling();
}
m_rawString = m_rawString.simplified();
return true;
}
void TokenElement::writeMathMLContent( KoXmlWriter* writer, const QString& ns ) const
{
// split the m_rawString into text content chunks that are divided by glyphs
// which are represented as ObjectReplacementCharacter and write each chunk
QStringList tmp = m_rawString.split( QChar( QChar::ObjectReplacementCharacter ) );
for ( int i = 0; i < tmp.count(); i++ ) {
if( m_rawString.startsWith( QChar( QChar::ObjectReplacementCharacter ) ) ) {
m_glyphs[ i ]->writeMathML( writer, ns );
if (i + 1 < tmp.count()) {
writer->addTextNode( tmp[ i ] );
}
}
else {
writer->addTextNode( tmp[ i ] );
if (i + 1 < tmp.count()) {
m_glyphs[ i ]->writeMathML( writer, ns );
}
}
}
}
const QString TokenElement::writeElementContent() const
{
return m_rawString;
}
| gpl-2.0 |
Digilent/u-boot-digilent | include/imx_sip.h | 376 | /* SPDX-License-Identifier: GPL-2.0+ */
/*
* Copyright 2017 NXP
*/
#ifndef _IMX_SIP_H__
#define _IMX_SIP_H_
#define IMX_SIP_GPC 0xC2000000
#define IMX_SIP_GPC_PM_DOMAIN 0x03
#define IMX_SIP_BUILDINFO 0xC2000003
#define IMX_SIP_BUILDINFO_GET_COMMITHASH 0x00
#define IMX_SIP_SRC 0xC2000005
#define IMX_SIP_SRC_M4_START 0x00
#define IMX_SIP_SRC_M4_STARTED 0x01
#endif
| gpl-2.0 |
snappermorgan/radaralley | wp-content/plugins/woocommerce-bookings/templates/emails/customer-booking-notification.php | 2299 | <?php
/**
* Customer booking notification
*/
if ( ! defined( 'ABSPATH' ) ) exit; // Exit if accessed directly ?>
<?php do_action( 'woocommerce_email_header', $email_heading ); ?>
<?php echo wpautop( wptexturize( $notification_message ) ); ?>
<table cellspacing="0" cellpadding="6" style="width: 100%; border: 1px solid #eee;" border="1" bordercolor="#eee">
<tbody>
<tr>
<th scope="row" style="text-align:left; border: 1px solid #eee;"><?php _e( 'Booked Product', 'woocommerce-bookings' ); ?></th>
<td style="text-align:left; border: 1px solid #eee;"><?php echo $booking->get_product()->get_title(); ?></td>
</tr>
<tr>
<th style="text-align:left; border: 1px solid #eee;" scope="row"><?php _e( 'Booking ID', 'woocommerce-bookings' ); ?></th>
<td style="text-align:left; border: 1px solid #eee;"><?php echo $booking->get_id(); ?></td>
</tr>
<?php if ( $booking->has_resources() && ( $resource = $booking->get_resource() ) ) : ?>
<tr>
<th style="text-align:left; border: 1px solid #eee;" scope="row"><?php _e( 'Booking Type', 'woocommerce-bookings' ); ?></th>
<td style="text-align:left; border: 1px solid #eee;"><?php echo $resource->post_title; ?></td>
</tr>
<?php endif; ?>
<tr>
<th style="text-align:left; border: 1px solid #eee;" scope="row"><?php _e( 'Booking Start Date', 'woocommerce-bookings' ); ?></th>
<td style="text-align:left; border: 1px solid #eee;"><?php echo $booking->get_start_date(); ?></td>
</tr>
<tr>
<th style="text-align:left; border: 1px solid #eee;" scope="row"><?php _e( 'Booking End Date', 'woocommerce-bookings' ); ?></th>
<td style="text-align:left; border: 1px solid #eee;"><?php echo $booking->get_end_date(); ?></td>
</tr>
<?php if ( $booking->has_persons() ) : ?>
<?php
foreach ( $booking->get_persons() as $id => $qty ) :
if ( 0 === $qty ) {
continue;
}
$person_type = ( 0 < $id ) ? get_the_title( $id ) : __( 'Person(s)', 'woocommerce-bookings' );
?>
<tr>
<th style="text-align:left; border: 1px solid #eee;" scope="row"><?php echo $person_type; ?></th>
<td style="text-align:left; border: 1px solid #eee;"><?php echo $qty; ?></td>
</tr>
<?php endforeach; ?>
<?php endif; ?>
</tbody>
</table>
<?php do_action( 'woocommerce_email_footer' ); ?> | gpl-2.0 |
dan82840/Netgear-RBR50 | git_home/linux.git/drivers/gpu/drm/ast/ast_mode.c | 31874 | /*
* Copyright 2012 Red Hat Inc.
* Parts based on xf86-video-ast
* Copyright (c) 2005 ASPEED Technology Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
*/
/*
* Authors: Dave Airlie <[email protected]>
*/
#include <linux/export.h>
#include <drm/drmP.h>
#include <drm/drm_crtc.h>
#include <drm/drm_crtc_helper.h>
#include "ast_drv.h"
#include "ast_tables.h"
static struct ast_i2c_chan *ast_i2c_create(struct drm_device *dev);
static void ast_i2c_destroy(struct ast_i2c_chan *i2c);
static int ast_cursor_set(struct drm_crtc *crtc,
struct drm_file *file_priv,
uint32_t handle,
uint32_t width,
uint32_t height);
static int ast_cursor_move(struct drm_crtc *crtc,
int x, int y);
static inline void ast_load_palette_index(struct ast_private *ast,
u8 index, u8 red, u8 green,
u8 blue)
{
ast_io_write8(ast, AST_IO_DAC_INDEX_WRITE, index);
ast_io_read8(ast, AST_IO_SEQ_PORT);
ast_io_write8(ast, AST_IO_DAC_DATA, red);
ast_io_read8(ast, AST_IO_SEQ_PORT);
ast_io_write8(ast, AST_IO_DAC_DATA, green);
ast_io_read8(ast, AST_IO_SEQ_PORT);
ast_io_write8(ast, AST_IO_DAC_DATA, blue);
ast_io_read8(ast, AST_IO_SEQ_PORT);
}
static void ast_crtc_load_lut(struct drm_crtc *crtc)
{
struct ast_private *ast = crtc->dev->dev_private;
struct ast_crtc *ast_crtc = to_ast_crtc(crtc);
int i;
if (!crtc->enabled)
return;
for (i = 0; i < 256; i++)
ast_load_palette_index(ast, i, ast_crtc->lut_r[i],
ast_crtc->lut_g[i], ast_crtc->lut_b[i]);
}
static bool ast_get_vbios_mode_info(struct drm_crtc *crtc, struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode,
struct ast_vbios_mode_info *vbios_mode)
{
struct ast_private *ast = crtc->dev->dev_private;
u32 refresh_rate_index = 0, mode_id, color_index, refresh_rate;
u32 hborder, vborder;
switch (crtc->fb->bits_per_pixel) {
case 8:
vbios_mode->std_table = &vbios_stdtable[VGAModeIndex];
color_index = VGAModeIndex - 1;
break;
case 16:
vbios_mode->std_table = &vbios_stdtable[HiCModeIndex];
color_index = HiCModeIndex;
break;
case 24:
case 32:
vbios_mode->std_table = &vbios_stdtable[TrueCModeIndex];
color_index = TrueCModeIndex;
break;
default:
return false;
}
switch (crtc->mode.crtc_hdisplay) {
case 640:
vbios_mode->enh_table = &res_640x480[refresh_rate_index];
break;
case 800:
vbios_mode->enh_table = &res_800x600[refresh_rate_index];
break;
case 1024:
vbios_mode->enh_table = &res_1024x768[refresh_rate_index];
break;
case 1280:
if (crtc->mode.crtc_vdisplay == 800)
vbios_mode->enh_table = &res_1280x800[refresh_rate_index];
else
vbios_mode->enh_table = &res_1280x1024[refresh_rate_index];
break;
case 1440:
vbios_mode->enh_table = &res_1440x900[refresh_rate_index];
break;
case 1600:
vbios_mode->enh_table = &res_1600x1200[refresh_rate_index];
break;
case 1680:
vbios_mode->enh_table = &res_1680x1050[refresh_rate_index];
break;
case 1920:
if (crtc->mode.crtc_vdisplay == 1080)
vbios_mode->enh_table = &res_1920x1080[refresh_rate_index];
else
vbios_mode->enh_table = &res_1920x1200[refresh_rate_index];
break;
default:
return false;
}
refresh_rate = drm_mode_vrefresh(mode);
while (vbios_mode->enh_table->refresh_rate < refresh_rate) {
vbios_mode->enh_table++;
if ((vbios_mode->enh_table->refresh_rate > refresh_rate) ||
(vbios_mode->enh_table->refresh_rate == 0xff)) {
vbios_mode->enh_table--;
break;
}
}
hborder = (vbios_mode->enh_table->flags & HBorder) ? 8 : 0;
vborder = (vbios_mode->enh_table->flags & VBorder) ? 8 : 0;
adjusted_mode->crtc_htotal = vbios_mode->enh_table->ht;
adjusted_mode->crtc_hblank_start = vbios_mode->enh_table->hde + hborder;
adjusted_mode->crtc_hblank_end = vbios_mode->enh_table->ht - hborder;
adjusted_mode->crtc_hsync_start = vbios_mode->enh_table->hde + hborder +
vbios_mode->enh_table->hfp;
adjusted_mode->crtc_hsync_end = (vbios_mode->enh_table->hde + hborder +
vbios_mode->enh_table->hfp +
vbios_mode->enh_table->hsync);
adjusted_mode->crtc_vtotal = vbios_mode->enh_table->vt;
adjusted_mode->crtc_vblank_start = vbios_mode->enh_table->vde + vborder;
adjusted_mode->crtc_vblank_end = vbios_mode->enh_table->vt - vborder;
adjusted_mode->crtc_vsync_start = vbios_mode->enh_table->vde + vborder +
vbios_mode->enh_table->vfp;
adjusted_mode->crtc_vsync_end = (vbios_mode->enh_table->vde + vborder +
vbios_mode->enh_table->vfp +
vbios_mode->enh_table->vsync);
refresh_rate_index = vbios_mode->enh_table->refresh_rate_index;
mode_id = vbios_mode->enh_table->mode_id;
if (ast->chip == AST1180) {
/* TODO 1180 */
} else {
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x8c, (u8)((color_index & 0xf) << 4));
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x8d, refresh_rate_index & 0xff);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x8e, mode_id & 0xff);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x91, 0xa8);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x92, crtc->fb->bits_per_pixel);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x93, adjusted_mode->clock / 1000);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x94, adjusted_mode->crtc_hdisplay);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x95, adjusted_mode->crtc_hdisplay >> 8);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x96, adjusted_mode->crtc_vdisplay);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x97, adjusted_mode->crtc_vdisplay >> 8);
}
return true;
}
static void ast_set_std_reg(struct drm_crtc *crtc, struct drm_display_mode *mode,
struct ast_vbios_mode_info *vbios_mode)
{
struct ast_private *ast = crtc->dev->dev_private;
struct ast_vbios_stdtable *stdtable;
u32 i;
u8 jreg;
stdtable = vbios_mode->std_table;
jreg = stdtable->misc;
ast_io_write8(ast, AST_IO_MISC_PORT_WRITE, jreg);
/* Set SEQ */
ast_set_index_reg(ast, AST_IO_SEQ_PORT, 0x00, 0x03);
for (i = 0; i < 4; i++) {
jreg = stdtable->seq[i];
if (!i)
jreg |= 0x20;
ast_set_index_reg(ast, AST_IO_SEQ_PORT, (i + 1) , jreg);
}
/* Set CRTC */
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x11, 0x7f, 0x00);
for (i = 0; i < 25; i++)
ast_set_index_reg(ast, AST_IO_CRTC_PORT, i, stdtable->crtc[i]);
/* set AR */
jreg = ast_io_read8(ast, AST_IO_INPUT_STATUS1_READ);
for (i = 0; i < 20; i++) {
jreg = stdtable->ar[i];
ast_io_write8(ast, AST_IO_AR_PORT_WRITE, (u8)i);
ast_io_write8(ast, AST_IO_AR_PORT_WRITE, jreg);
}
ast_io_write8(ast, AST_IO_AR_PORT_WRITE, 0x14);
ast_io_write8(ast, AST_IO_AR_PORT_WRITE, 0x00);
jreg = ast_io_read8(ast, AST_IO_INPUT_STATUS1_READ);
ast_io_write8(ast, AST_IO_AR_PORT_WRITE, 0x20);
/* Set GR */
for (i = 0; i < 9; i++)
ast_set_index_reg(ast, AST_IO_GR_PORT, i, stdtable->gr[i]);
}
static void ast_set_crtc_reg(struct drm_crtc *crtc, struct drm_display_mode *mode,
struct ast_vbios_mode_info *vbios_mode)
{
struct ast_private *ast = crtc->dev->dev_private;
u8 jreg05 = 0, jreg07 = 0, jreg09 = 0, jregAC = 0, jregAD = 0, jregAE = 0;
u16 temp;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x11, 0x7f, 0x00);
temp = (mode->crtc_htotal >> 3) - 5;
if (temp & 0x100)
jregAC |= 0x01; /* HT D[8] */
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x00, 0x00, temp);
temp = (mode->crtc_hdisplay >> 3) - 1;
if (temp & 0x100)
jregAC |= 0x04; /* HDE D[8] */
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x01, 0x00, temp);
temp = (mode->crtc_hblank_start >> 3) - 1;
if (temp & 0x100)
jregAC |= 0x10; /* HBS D[8] */
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x02, 0x00, temp);
temp = ((mode->crtc_hblank_end >> 3) - 1) & 0x7f;
if (temp & 0x20)
jreg05 |= 0x80; /* HBE D[5] */
if (temp & 0x40)
jregAD |= 0x01; /* HBE D[5] */
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x03, 0xE0, (temp & 0x1f));
temp = (mode->crtc_hsync_start >> 3) - 1;
if (temp & 0x100)
jregAC |= 0x40; /* HRS D[5] */
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x04, 0x00, temp);
temp = ((mode->crtc_hsync_end >> 3) - 1) & 0x3f;
if (temp & 0x20)
jregAD |= 0x04; /* HRE D[5] */
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x05, 0x60, (u8)((temp & 0x1f) | jreg05));
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xAC, 0x00, jregAC);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xAD, 0x00, jregAD);
/* vert timings */
temp = (mode->crtc_vtotal) - 2;
if (temp & 0x100)
jreg07 |= 0x01;
if (temp & 0x200)
jreg07 |= 0x20;
if (temp & 0x400)
jregAE |= 0x01;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x06, 0x00, temp);
temp = (mode->crtc_vsync_start) - 1;
if (temp & 0x100)
jreg07 |= 0x04;
if (temp & 0x200)
jreg07 |= 0x80;
if (temp & 0x400)
jregAE |= 0x08;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x10, 0x00, temp);
temp = (mode->crtc_vsync_end - 1) & 0x3f;
if (temp & 0x10)
jregAE |= 0x20;
if (temp & 0x20)
jregAE |= 0x40;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x11, 0x70, temp & 0xf);
temp = mode->crtc_vdisplay - 1;
if (temp & 0x100)
jreg07 |= 0x02;
if (temp & 0x200)
jreg07 |= 0x40;
if (temp & 0x400)
jregAE |= 0x02;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x12, 0x00, temp);
temp = mode->crtc_vblank_start - 1;
if (temp & 0x100)
jreg07 |= 0x08;
if (temp & 0x200)
jreg09 |= 0x20;
if (temp & 0x400)
jregAE |= 0x04;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x15, 0x00, temp);
temp = mode->crtc_vblank_end - 1;
if (temp & 0x100)
jregAE |= 0x10;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x16, 0x00, temp);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x07, 0x00, jreg07);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x09, 0xdf, jreg09);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xAE, 0x00, (jregAE | 0x80));
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0x11, 0x7f, 0x80);
}
static void ast_set_offset_reg(struct drm_crtc *crtc)
{
struct ast_private *ast = crtc->dev->dev_private;
u16 offset;
offset = crtc->fb->pitches[0] >> 3;
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x13, (offset & 0xff));
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xb0, (offset >> 8) & 0x3f);
}
static void ast_set_dclk_reg(struct drm_device *dev, struct drm_display_mode *mode,
struct ast_vbios_mode_info *vbios_mode)
{
struct ast_private *ast = dev->dev_private;
struct ast_vbios_dclk_info *clk_info;
clk_info = &dclk_table[vbios_mode->enh_table->dclk_index];
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xc0, 0x00, clk_info->param1);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xc1, 0x00, clk_info->param2);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xbb, 0x0f,
(clk_info->param3 & 0x80) | ((clk_info->param3 & 0x3) << 4));
}
static void ast_set_ext_reg(struct drm_crtc *crtc, struct drm_display_mode *mode,
struct ast_vbios_mode_info *vbios_mode)
{
struct ast_private *ast = crtc->dev->dev_private;
u8 jregA0 = 0, jregA3 = 0, jregA8 = 0;
switch (crtc->fb->bits_per_pixel) {
case 8:
jregA0 = 0x70;
jregA3 = 0x01;
jregA8 = 0x00;
break;
case 15:
case 16:
jregA0 = 0x70;
jregA3 = 0x04;
jregA8 = 0x02;
break;
case 32:
jregA0 = 0x70;
jregA3 = 0x08;
jregA8 = 0x02;
break;
}
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xa0, 0x8f, jregA0);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xa3, 0xf0, jregA3);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xa8, 0xfd, jregA8);
/* Set Threshold */
if (ast->chip == AST2300) {
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa7, 0x78);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa6, 0x60);
} else if (ast->chip == AST2100 ||
ast->chip == AST1100 ||
ast->chip == AST2200 ||
ast->chip == AST2150) {
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa7, 0x3f);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa6, 0x2f);
} else {
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa7, 0x2f);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa6, 0x1f);
}
}
static void ast_set_sync_reg(struct drm_device *dev, struct drm_display_mode *mode,
struct ast_vbios_mode_info *vbios_mode)
{
struct ast_private *ast = dev->dev_private;
u8 jreg;
jreg = ast_io_read8(ast, AST_IO_MISC_PORT_READ);
jreg |= (vbios_mode->enh_table->flags & SyncNN);
ast_io_write8(ast, AST_IO_MISC_PORT_WRITE, jreg);
}
static bool ast_set_dac_reg(struct drm_crtc *crtc, struct drm_display_mode *mode,
struct ast_vbios_mode_info *vbios_mode)
{
switch (crtc->fb->bits_per_pixel) {
case 8:
break;
default:
return false;
}
return true;
}
static void ast_set_start_address_crt1(struct drm_crtc *crtc, unsigned offset)
{
struct ast_private *ast = crtc->dev->dev_private;
u32 addr;
addr = offset >> 2;
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x0d, (u8)(addr & 0xff));
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0x0c, (u8)((addr >> 8) & 0xff));
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xaf, (u8)((addr >> 16) & 0xff));
}
static void ast_crtc_dpms(struct drm_crtc *crtc, int mode)
{
struct ast_private *ast = crtc->dev->dev_private;
if (ast->chip == AST1180)
return;
switch (mode) {
case DRM_MODE_DPMS_ON:
case DRM_MODE_DPMS_STANDBY:
case DRM_MODE_DPMS_SUSPEND:
ast_set_index_reg_mask(ast, AST_IO_SEQ_PORT, 0x1, 0xdf, 0);
ast_crtc_load_lut(crtc);
break;
case DRM_MODE_DPMS_OFF:
ast_set_index_reg_mask(ast, AST_IO_SEQ_PORT, 0x1, 0xdf, 0x20);
break;
}
}
static bool ast_crtc_mode_fixup(struct drm_crtc *crtc,
const struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
return true;
}
/* ast is different - we will force move buffers out of VRAM */
static int ast_crtc_do_set_base(struct drm_crtc *crtc,
struct drm_framebuffer *fb,
int x, int y, int atomic)
{
struct ast_private *ast = crtc->dev->dev_private;
struct drm_gem_object *obj;
struct ast_framebuffer *ast_fb;
struct ast_bo *bo;
int ret;
u64 gpu_addr;
/* push the previous fb to system ram */
if (!atomic && fb) {
ast_fb = to_ast_framebuffer(fb);
obj = ast_fb->obj;
bo = gem_to_ast_bo(obj);
ret = ast_bo_reserve(bo, false);
if (ret)
return ret;
ast_bo_push_sysram(bo);
ast_bo_unreserve(bo);
}
ast_fb = to_ast_framebuffer(crtc->fb);
obj = ast_fb->obj;
bo = gem_to_ast_bo(obj);
ret = ast_bo_reserve(bo, false);
if (ret)
return ret;
ret = ast_bo_pin(bo, TTM_PL_FLAG_VRAM, &gpu_addr);
if (ret) {
ast_bo_unreserve(bo);
return ret;
}
if (&ast->fbdev->afb == ast_fb) {
/* if pushing console in kmap it */
ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &bo->kmap);
if (ret)
DRM_ERROR("failed to kmap fbcon\n");
else
ast_fbdev_set_base(ast, gpu_addr);
}
ast_bo_unreserve(bo);
ast_set_start_address_crt1(crtc, (u32)gpu_addr);
return 0;
}
static int ast_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
struct drm_framebuffer *old_fb)
{
return ast_crtc_do_set_base(crtc, old_fb, x, y, 0);
}
static int ast_crtc_mode_set(struct drm_crtc *crtc,
struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode,
int x, int y,
struct drm_framebuffer *old_fb)
{
struct drm_device *dev = crtc->dev;
struct ast_private *ast = crtc->dev->dev_private;
struct ast_vbios_mode_info vbios_mode;
bool ret;
if (ast->chip == AST1180) {
DRM_ERROR("AST 1180 modesetting not supported\n");
return -EINVAL;
}
ret = ast_get_vbios_mode_info(crtc, mode, adjusted_mode, &vbios_mode);
if (ret == false)
return -EINVAL;
ast_open_key(ast);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xa1, 0xff, 0x04);
ast_set_std_reg(crtc, adjusted_mode, &vbios_mode);
ast_set_crtc_reg(crtc, adjusted_mode, &vbios_mode);
ast_set_offset_reg(crtc);
ast_set_dclk_reg(dev, adjusted_mode, &vbios_mode);
ast_set_ext_reg(crtc, adjusted_mode, &vbios_mode);
ast_set_sync_reg(dev, adjusted_mode, &vbios_mode);
ast_set_dac_reg(crtc, adjusted_mode, &vbios_mode);
ast_crtc_mode_set_base(crtc, x, y, old_fb);
return 0;
}
static void ast_crtc_disable(struct drm_crtc *crtc)
{
}
static void ast_crtc_prepare(struct drm_crtc *crtc)
{
}
static void ast_crtc_commit(struct drm_crtc *crtc)
{
struct ast_private *ast = crtc->dev->dev_private;
ast_set_index_reg_mask(ast, AST_IO_SEQ_PORT, 0x1, 0xdf, 0);
}
static const struct drm_crtc_helper_funcs ast_crtc_helper_funcs = {
.dpms = ast_crtc_dpms,
.mode_fixup = ast_crtc_mode_fixup,
.mode_set = ast_crtc_mode_set,
.mode_set_base = ast_crtc_mode_set_base,
.disable = ast_crtc_disable,
.load_lut = ast_crtc_load_lut,
.prepare = ast_crtc_prepare,
.commit = ast_crtc_commit,
};
static void ast_crtc_reset(struct drm_crtc *crtc)
{
}
static void ast_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green,
u16 *blue, uint32_t start, uint32_t size)
{
struct ast_crtc *ast_crtc = to_ast_crtc(crtc);
int end = (start + size > 256) ? 256 : start + size, i;
/* userspace palettes are always correct as is */
for (i = start; i < end; i++) {
ast_crtc->lut_r[i] = red[i] >> 8;
ast_crtc->lut_g[i] = green[i] >> 8;
ast_crtc->lut_b[i] = blue[i] >> 8;
}
ast_crtc_load_lut(crtc);
}
static void ast_crtc_destroy(struct drm_crtc *crtc)
{
drm_crtc_cleanup(crtc);
kfree(crtc);
}
static const struct drm_crtc_funcs ast_crtc_funcs = {
.cursor_set = ast_cursor_set,
.cursor_move = ast_cursor_move,
.reset = ast_crtc_reset,
.set_config = drm_crtc_helper_set_config,
.gamma_set = ast_crtc_gamma_set,
.destroy = ast_crtc_destroy,
};
static int ast_crtc_init(struct drm_device *dev)
{
struct ast_crtc *crtc;
int i;
crtc = kzalloc(sizeof(struct ast_crtc), GFP_KERNEL);
if (!crtc)
return -ENOMEM;
drm_crtc_init(dev, &crtc->base, &ast_crtc_funcs);
drm_mode_crtc_set_gamma_size(&crtc->base, 256);
drm_crtc_helper_add(&crtc->base, &ast_crtc_helper_funcs);
for (i = 0; i < 256; i++) {
crtc->lut_r[i] = i;
crtc->lut_g[i] = i;
crtc->lut_b[i] = i;
}
return 0;
}
static void ast_encoder_destroy(struct drm_encoder *encoder)
{
drm_encoder_cleanup(encoder);
kfree(encoder);
}
static struct drm_encoder *ast_best_single_encoder(struct drm_connector *connector)
{
int enc_id = connector->encoder_ids[0];
struct drm_mode_object *obj;
struct drm_encoder *encoder;
/* pick the encoder ids */
if (enc_id) {
obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
if (!obj)
return NULL;
encoder = obj_to_encoder(obj);
return encoder;
}
return NULL;
}
static const struct drm_encoder_funcs ast_enc_funcs = {
.destroy = ast_encoder_destroy,
};
static void ast_encoder_dpms(struct drm_encoder *encoder, int mode)
{
}
static bool ast_mode_fixup(struct drm_encoder *encoder,
const struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
return true;
}
static void ast_encoder_mode_set(struct drm_encoder *encoder,
struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
}
static void ast_encoder_prepare(struct drm_encoder *encoder)
{
}
static void ast_encoder_commit(struct drm_encoder *encoder)
{
}
static const struct drm_encoder_helper_funcs ast_enc_helper_funcs = {
.dpms = ast_encoder_dpms,
.mode_fixup = ast_mode_fixup,
.prepare = ast_encoder_prepare,
.commit = ast_encoder_commit,
.mode_set = ast_encoder_mode_set,
};
static int ast_encoder_init(struct drm_device *dev)
{
struct ast_encoder *ast_encoder;
ast_encoder = kzalloc(sizeof(struct ast_encoder), GFP_KERNEL);
if (!ast_encoder)
return -ENOMEM;
drm_encoder_init(dev, &ast_encoder->base, &ast_enc_funcs,
DRM_MODE_ENCODER_DAC);
drm_encoder_helper_add(&ast_encoder->base, &ast_enc_helper_funcs);
ast_encoder->base.possible_crtcs = 1;
return 0;
}
static int ast_get_modes(struct drm_connector *connector)
{
struct ast_connector *ast_connector = to_ast_connector(connector);
struct edid *edid;
int ret;
edid = drm_get_edid(connector, &ast_connector->i2c->adapter);
if (edid) {
drm_mode_connector_update_edid_property(&ast_connector->base, edid);
ret = drm_add_edid_modes(connector, edid);
kfree(edid);
return ret;
} else
drm_mode_connector_update_edid_property(&ast_connector->base, NULL);
return 0;
}
static int ast_mode_valid(struct drm_connector *connector,
struct drm_display_mode *mode)
{
return MODE_OK;
}
static void ast_connector_destroy(struct drm_connector *connector)
{
struct ast_connector *ast_connector = to_ast_connector(connector);
ast_i2c_destroy(ast_connector->i2c);
drm_sysfs_connector_remove(connector);
drm_connector_cleanup(connector);
kfree(connector);
}
static enum drm_connector_status
ast_connector_detect(struct drm_connector *connector, bool force)
{
return connector_status_connected;
}
static const struct drm_connector_helper_funcs ast_connector_helper_funcs = {
.mode_valid = ast_mode_valid,
.get_modes = ast_get_modes,
.best_encoder = ast_best_single_encoder,
};
static const struct drm_connector_funcs ast_connector_funcs = {
.dpms = drm_helper_connector_dpms,
.detect = ast_connector_detect,
.fill_modes = drm_helper_probe_single_connector_modes,
.destroy = ast_connector_destroy,
};
static int ast_connector_init(struct drm_device *dev)
{
struct ast_connector *ast_connector;
struct drm_connector *connector;
struct drm_encoder *encoder;
ast_connector = kzalloc(sizeof(struct ast_connector), GFP_KERNEL);
if (!ast_connector)
return -ENOMEM;
connector = &ast_connector->base;
drm_connector_init(dev, connector, &ast_connector_funcs, DRM_MODE_CONNECTOR_VGA);
drm_connector_helper_add(connector, &ast_connector_helper_funcs);
connector->interlace_allowed = 0;
connector->doublescan_allowed = 0;
drm_sysfs_connector_add(connector);
connector->polled = DRM_CONNECTOR_POLL_CONNECT;
encoder = list_first_entry(&dev->mode_config.encoder_list, struct drm_encoder, head);
drm_mode_connector_attach_encoder(connector, encoder);
ast_connector->i2c = ast_i2c_create(dev);
if (!ast_connector->i2c)
DRM_ERROR("failed to add ddc bus for connector\n");
return 0;
}
/* allocate cursor cache and pin at start of VRAM */
static int ast_cursor_init(struct drm_device *dev)
{
struct ast_private *ast = dev->dev_private;
int size;
int ret;
struct drm_gem_object *obj;
struct ast_bo *bo;
uint64_t gpu_addr;
size = (AST_HWC_SIZE + AST_HWC_SIGNATURE_SIZE) * AST_DEFAULT_HWC_NUM;
ret = ast_gem_create(dev, size, true, &obj);
if (ret)
return ret;
bo = gem_to_ast_bo(obj);
ret = ast_bo_reserve(bo, false);
if (unlikely(ret != 0))
goto fail;
ret = ast_bo_pin(bo, TTM_PL_FLAG_VRAM, &gpu_addr);
ast_bo_unreserve(bo);
if (ret)
goto fail;
/* kmap the object */
ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &ast->cache_kmap);
if (ret)
goto fail;
ast->cursor_cache = obj;
ast->cursor_cache_gpu_addr = gpu_addr;
DRM_DEBUG_KMS("pinned cursor cache at %llx\n", ast->cursor_cache_gpu_addr);
return 0;
fail:
return ret;
}
static void ast_cursor_fini(struct drm_device *dev)
{
struct ast_private *ast = dev->dev_private;
ttm_bo_kunmap(&ast->cache_kmap);
drm_gem_object_unreference_unlocked(ast->cursor_cache);
}
int ast_mode_init(struct drm_device *dev)
{
ast_cursor_init(dev);
ast_crtc_init(dev);
ast_encoder_init(dev);
ast_connector_init(dev);
return 0;
}
void ast_mode_fini(struct drm_device *dev)
{
ast_cursor_fini(dev);
}
static int get_clock(void *i2c_priv)
{
struct ast_i2c_chan *i2c = i2c_priv;
struct ast_private *ast = i2c->dev->dev_private;
uint32_t val;
val = ast_get_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xb7, 0x10) >> 4;
return val & 1 ? 1 : 0;
}
static int get_data(void *i2c_priv)
{
struct ast_i2c_chan *i2c = i2c_priv;
struct ast_private *ast = i2c->dev->dev_private;
uint32_t val;
val = ast_get_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xb7, 0x20) >> 5;
return val & 1 ? 1 : 0;
}
static void set_clock(void *i2c_priv, int clock)
{
struct ast_i2c_chan *i2c = i2c_priv;
struct ast_private *ast = i2c->dev->dev_private;
int i;
u8 ujcrb7, jtemp;
for (i = 0; i < 0x10000; i++) {
ujcrb7 = ((clock & 0x01) ? 0 : 1);
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xb7, 0xfe, ujcrb7);
jtemp = ast_get_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xb7, 0x01);
if (ujcrb7 == jtemp)
break;
}
}
static void set_data(void *i2c_priv, int data)
{
struct ast_i2c_chan *i2c = i2c_priv;
struct ast_private *ast = i2c->dev->dev_private;
int i;
u8 ujcrb7, jtemp;
for (i = 0; i < 0x10000; i++) {
ujcrb7 = ((data & 0x01) ? 0 : 1) << 2;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xb7, 0xfb, ujcrb7);
jtemp = ast_get_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xb7, 0x04);
if (ujcrb7 == jtemp)
break;
}
}
static struct ast_i2c_chan *ast_i2c_create(struct drm_device *dev)
{
struct ast_i2c_chan *i2c;
int ret;
i2c = kzalloc(sizeof(struct ast_i2c_chan), GFP_KERNEL);
if (!i2c)
return NULL;
i2c->adapter.owner = THIS_MODULE;
i2c->adapter.class = I2C_CLASS_DDC;
i2c->adapter.dev.parent = &dev->pdev->dev;
i2c->dev = dev;
i2c_set_adapdata(&i2c->adapter, i2c);
snprintf(i2c->adapter.name, sizeof(i2c->adapter.name),
"AST i2c bit bus");
i2c->adapter.algo_data = &i2c->bit;
i2c->bit.udelay = 20;
i2c->bit.timeout = 2;
i2c->bit.data = i2c;
i2c->bit.setsda = set_data;
i2c->bit.setscl = set_clock;
i2c->bit.getsda = get_data;
i2c->bit.getscl = get_clock;
ret = i2c_bit_add_bus(&i2c->adapter);
if (ret) {
DRM_ERROR("Failed to register bit i2c\n");
goto out_free;
}
return i2c;
out_free:
kfree(i2c);
return NULL;
}
static void ast_i2c_destroy(struct ast_i2c_chan *i2c)
{
if (!i2c)
return;
i2c_del_adapter(&i2c->adapter);
kfree(i2c);
}
static void ast_show_cursor(struct drm_crtc *crtc)
{
struct ast_private *ast = crtc->dev->dev_private;
u8 jreg;
jreg = 0x2;
/* enable ARGB cursor */
jreg |= 1;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xcb, 0xfc, jreg);
}
static void ast_hide_cursor(struct drm_crtc *crtc)
{
struct ast_private *ast = crtc->dev->dev_private;
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xcb, 0xfc, 0x00);
}
static u32 copy_cursor_image(u8 *src, u8 *dst, int width, int height)
{
union {
u32 ul;
u8 b[4];
} srcdata32[2], data32;
union {
u16 us;
u8 b[2];
} data16;
u32 csum = 0;
s32 alpha_dst_delta, last_alpha_dst_delta;
u8 *srcxor, *dstxor;
int i, j;
u32 per_pixel_copy, two_pixel_copy;
alpha_dst_delta = AST_MAX_HWC_WIDTH << 1;
last_alpha_dst_delta = alpha_dst_delta - (width << 1);
srcxor = src;
dstxor = (u8 *)dst + last_alpha_dst_delta + (AST_MAX_HWC_HEIGHT - height) * alpha_dst_delta;
per_pixel_copy = width & 1;
two_pixel_copy = width >> 1;
for (j = 0; j < height; j++) {
for (i = 0; i < two_pixel_copy; i++) {
srcdata32[0].ul = *((u32 *)srcxor) & 0xf0f0f0f0;
srcdata32[1].ul = *((u32 *)(srcxor + 4)) & 0xf0f0f0f0;
data32.b[0] = srcdata32[0].b[1] | (srcdata32[0].b[0] >> 4);
data32.b[1] = srcdata32[0].b[3] | (srcdata32[0].b[2] >> 4);
data32.b[2] = srcdata32[1].b[1] | (srcdata32[1].b[0] >> 4);
data32.b[3] = srcdata32[1].b[3] | (srcdata32[1].b[2] >> 4);
writel(data32.ul, dstxor);
csum += data32.ul;
dstxor += 4;
srcxor += 8;
}
for (i = 0; i < per_pixel_copy; i++) {
srcdata32[0].ul = *((u32 *)srcxor) & 0xf0f0f0f0;
data16.b[0] = srcdata32[0].b[1] | (srcdata32[0].b[0] >> 4);
data16.b[1] = srcdata32[0].b[3] | (srcdata32[0].b[2] >> 4);
writew(data16.us, dstxor);
csum += (u32)data16.us;
dstxor += 2;
srcxor += 4;
}
dstxor += last_alpha_dst_delta;
}
return csum;
}
static int ast_cursor_set(struct drm_crtc *crtc,
struct drm_file *file_priv,
uint32_t handle,
uint32_t width,
uint32_t height)
{
struct ast_private *ast = crtc->dev->dev_private;
struct ast_crtc *ast_crtc = to_ast_crtc(crtc);
struct drm_gem_object *obj;
struct ast_bo *bo;
uint64_t gpu_addr;
u32 csum;
int ret;
struct ttm_bo_kmap_obj uobj_map;
u8 *src, *dst;
bool src_isiomem, dst_isiomem;
if (!handle) {
ast_hide_cursor(crtc);
return 0;
}
if (width > AST_MAX_HWC_WIDTH || height > AST_MAX_HWC_HEIGHT)
return -EINVAL;
obj = drm_gem_object_lookup(crtc->dev, file_priv, handle);
if (!obj) {
DRM_ERROR("Cannot find cursor object %x for crtc\n", handle);
return -ENOENT;
}
bo = gem_to_ast_bo(obj);
ret = ast_bo_reserve(bo, false);
if (ret)
goto fail;
ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &uobj_map);
src = ttm_kmap_obj_virtual(&uobj_map, &src_isiomem);
dst = ttm_kmap_obj_virtual(&ast->cache_kmap, &dst_isiomem);
if (src_isiomem == true)
DRM_ERROR("src cursor bo should be in main memory\n");
if (dst_isiomem == false)
DRM_ERROR("dst bo should be in VRAM\n");
dst += (AST_HWC_SIZE + AST_HWC_SIGNATURE_SIZE)*ast->next_cursor;
/* do data transfer to cursor cache */
csum = copy_cursor_image(src, dst, width, height);
/* write checksum + signature */
ttm_bo_kunmap(&uobj_map);
ast_bo_unreserve(bo);
{
u8 *dst = (u8 *)ast->cache_kmap.virtual + (AST_HWC_SIZE + AST_HWC_SIGNATURE_SIZE)*ast->next_cursor + AST_HWC_SIZE;
writel(csum, dst);
writel(width, dst + AST_HWC_SIGNATURE_SizeX);
writel(height, dst + AST_HWC_SIGNATURE_SizeY);
writel(0, dst + AST_HWC_SIGNATURE_HOTSPOTX);
writel(0, dst + AST_HWC_SIGNATURE_HOTSPOTY);
/* set pattern offset */
gpu_addr = ast->cursor_cache_gpu_addr;
gpu_addr += (AST_HWC_SIZE + AST_HWC_SIGNATURE_SIZE)*ast->next_cursor;
gpu_addr >>= 3;
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc8, gpu_addr & 0xff);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc9, (gpu_addr >> 8) & 0xff);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xca, (gpu_addr >> 16) & 0xff);
}
ast_crtc->cursor_width = width;
ast_crtc->cursor_height = height;
ast_crtc->offset_x = AST_MAX_HWC_WIDTH - width;
ast_crtc->offset_y = AST_MAX_HWC_WIDTH - height;
ast->next_cursor = (ast->next_cursor + 1) % AST_DEFAULT_HWC_NUM;
ast_show_cursor(crtc);
drm_gem_object_unreference_unlocked(obj);
return 0;
fail:
drm_gem_object_unreference_unlocked(obj);
return ret;
}
static int ast_cursor_move(struct drm_crtc *crtc,
int x, int y)
{
struct ast_crtc *ast_crtc = to_ast_crtc(crtc);
struct ast_private *ast = crtc->dev->dev_private;
int x_offset, y_offset;
u8 *sig;
sig = (u8 *)ast->cache_kmap.virtual + (AST_HWC_SIZE + AST_HWC_SIGNATURE_SIZE)*ast->next_cursor + AST_HWC_SIZE;
writel(x, sig + AST_HWC_SIGNATURE_X);
writel(y, sig + AST_HWC_SIGNATURE_Y);
x_offset = ast_crtc->offset_x;
y_offset = ast_crtc->offset_y;
if (x < 0) {
x_offset = (-x) + ast_crtc->offset_x;
x = 0;
}
if (y < 0) {
y_offset = (-y) + ast_crtc->offset_y;
y = 0;
}
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc2, x_offset);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc3, y_offset);
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc4, (x & 0xff));
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc5, ((x >> 8) & 0x0f));
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc6, (y & 0xff));
ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc7, ((y >> 8) & 0x07));
/* dummy write to fire HWC */
ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xCB, 0xFF, 0x00);
return 0;
}
| gpl-2.0 |
lian-rr/Ecommerse-Drupal | vendor/drupal/console/src/Command/Generate/RouteSubscriberCommand.php | 4403 | <?php
/**
* @file
* Contains \Drupal\Console\Command\Generate\RouteSubscriber.
*/
namespace Drupal\Console\Command\Generate;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Drupal\Console\Command\Shared\ModuleTrait;
use Drupal\Console\Generator\RouteSubscriberGenerator;
use Drupal\Console\Command\Shared\ConfirmationTrait;
use Symfony\Component\Console\Command\Command;
use Drupal\Console\Core\Style\DrupalStyle;
use Drupal\Console\Extension\Manager;
use Drupal\Console\Core\Utils\ChainQueue;
use Drupal\Console\Core\Command\Shared\CommandTrait;
/**
* Class RouteSubscriberCommand
*
* @package Drupal\Console\Command\Generate
*/
class RouteSubscriberCommand extends Command
{
use ModuleTrait;
use ConfirmationTrait;
use CommandTrait;
/**
* @var Manager
*/
protected $extensionManager;
/**
* @var RouteSubscriberGenerator
*/
protected $generator;
/**
* @var ChainQueue
*/
protected $chainQueue;
/**
* RouteSubscriberCommand constructor.
*
* @param Manager $extensionManager
* @param RouteSubscriberGenerator $generator
* @param ChainQueue $chainQueue
*/
public function __construct(
Manager $extensionManager,
RouteSubscriberGenerator $generator,
ChainQueue $chainQueue
) {
$this->extensionManager = $extensionManager;
$this->generator = $generator;
$this->chainQueue = $chainQueue;
parent::__construct();
}
/**
* {@inheritdoc}
*/
protected function configure()
{
$this
->setName('generate:routesubscriber')
->setDescription($this->trans('commands.generate.routesubscriber.description'))
->setHelp($this->trans('commands.generate.routesubscriber.description'))
->addOption(
'module',
null,
InputOption::VALUE_REQUIRED,
$this->trans('commands.common.options.module')
)
->addOption(
'name',
null,
InputOption::VALUE_REQUIRED,
$this->trans('commands.generate.routesubscriber.options.name')
)
->addOption(
'class',
null,
InputOption::VALUE_REQUIRED,
$this->trans('commands.generate.routesubscriber.options.class')
);
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$output = new DrupalStyle($input, $output);
// @see use Drupal\Console\Command\Shared\ConfirmationTrait::confirmGeneration
if (!$this->confirmGeneration($output)) {
return 1;
}
$module = $input->getOption('module');
$name = $input->getOption('name');
$class = $input->getOption('class');
$this->generator->generate($module, $name, $class);
$this->chainQueue->addCommand('cache:rebuild', ['cache' => 'all']);
return 0;
}
/**
* {@inheritdoc}
*/
protected function interact(InputInterface $input, OutputInterface $output)
{
$io = new DrupalStyle($input, $output);
// --module option
$module = $input->getOption('module');
if (!$module) {
// @see Drupal\Console\Command\Shared\ModuleTrait::moduleQuestion
$module = $this->moduleQuestion($io);
$input->setOption('module', $module);
}
// --name option
$name = $input->getOption('name');
if (!$name) {
$name = $io->ask(
$this->trans('commands.generate.routesubscriber.questions.name'),
$module.'.route_subscriber'
);
$input->setOption('name', $name);
}
// --class option
$class = $input->getOption('class');
if (!$class) {
$class = $io->ask(
$this->trans('commands.generate.routesubscriber.questions.class'),
'RouteSubscriber'
);
$input->setOption('class', $class);
}
}
protected function createGenerator()
{
return new RouteSubscriberGenerator();
}
}
| gpl-2.0 |
uoaerg/linux-dccp | tools/testing/selftests/net/netdevice.sh | 4346 | #!/bin/sh
#
# This test is for checking network interface
# For the moment it tests only ethernet interface (but wifi could be easily added)
#
# We assume that all network driver are loaded
# if not they probably have failed earlier in the boot process and their logged error will be catched by another test
#
# this function will try to up the interface
# if already up, nothing done
# arg1: network interface name
kci_net_start()
{
netdev=$1
ip link show "$netdev" |grep -q UP
if [ $? -eq 0 ];then
echo "SKIP: $netdev: interface already up"
return 0
fi
ip link set "$netdev" up
if [ $? -ne 0 ];then
echo "FAIL: $netdev: Fail to up interface"
return 1
else
echo "PASS: $netdev: set interface up"
NETDEV_STARTED=1
fi
return 0
}
# this function will try to setup an IP and MAC address on a network interface
# Doing nothing if the interface was already up
# arg1: network interface name
kci_net_setup()
{
netdev=$1
# do nothing if the interface was already up
if [ $NETDEV_STARTED -eq 0 ];then
return 0
fi
MACADDR='02:03:04:05:06:07'
ip link set dev $netdev address "$MACADDR"
if [ $? -ne 0 ];then
echo "FAIL: $netdev: Cannot set MAC address"
else
ip link show $netdev |grep -q "$MACADDR"
if [ $? -eq 0 ];then
echo "PASS: $netdev: set MAC address"
else
echo "FAIL: $netdev: Cannot set MAC address"
fi
fi
#check that the interface did not already have an IP
ip address show "$netdev" |grep '^[[:space:]]*inet'
if [ $? -eq 0 ];then
echo "SKIP: $netdev: already have an IP"
return 0
fi
# TODO what ipaddr to set ? DHCP ?
echo "SKIP: $netdev: set IP address"
return 0
}
# test an ethtool command
# arg1: return code for not supported (see ethtool code source)
# arg2: summary of the command
# arg3: command to execute
kci_netdev_ethtool_test()
{
if [ $# -le 2 ];then
echo "SKIP: $netdev: ethtool: invalid number of arguments"
return 1
fi
$3 >/dev/null
ret=$?
if [ $ret -ne 0 ];then
if [ $ret -eq "$1" ];then
echo "SKIP: $netdev: ethtool $2 not supported"
else
echo "FAIL: $netdev: ethtool $2"
return 1
fi
else
echo "PASS: $netdev: ethtool $2"
fi
return 0
}
# test ethtool commands
# arg1: network interface name
kci_netdev_ethtool()
{
netdev=$1
#check presence of ethtool
ethtool --version 2>/dev/null >/dev/null
if [ $? -ne 0 ];then
echo "SKIP: ethtool not present"
return 1
fi
TMP_ETHTOOL_FEATURES="$(mktemp)"
if [ ! -e "$TMP_ETHTOOL_FEATURES" ];then
echo "SKIP: Cannot create a tmp file"
return 1
fi
ethtool -k "$netdev" > "$TMP_ETHTOOL_FEATURES"
if [ $? -ne 0 ];then
echo "FAIL: $netdev: ethtool list features"
rm "$TMP_ETHTOOL_FEATURES"
return 1
fi
echo "PASS: $netdev: ethtool list features"
#TODO for each non fixed features, try to turn them on/off
rm "$TMP_ETHTOOL_FEATURES"
kci_netdev_ethtool_test 74 'dump' "ethtool -d $netdev"
kci_netdev_ethtool_test 94 'stats' "ethtool -S $netdev"
return 0
}
# stop a netdev
# arg1: network interface name
kci_netdev_stop()
{
netdev=$1
if [ $NETDEV_STARTED -eq 0 ];then
echo "SKIP: $netdev: interface kept up"
return 0
fi
ip link set "$netdev" down
if [ $? -ne 0 ];then
echo "FAIL: $netdev: stop interface"
return 1
fi
echo "PASS: $netdev: stop interface"
return 0
}
# run all test on a netdev
# arg1: network interface name
kci_test_netdev()
{
NETDEV_STARTED=0
IFACE_TO_UPDOWN="$1"
IFACE_TO_TEST="$1"
#check for VLAN interface
MASTER_IFACE="$(echo $1 | cut -d@ -f2)"
if [ ! -z "$MASTER_IFACE" ];then
IFACE_TO_UPDOWN="$MASTER_IFACE"
IFACE_TO_TEST="$(echo $1 | cut -d@ -f1)"
fi
NETDEV_STARTED=0
kci_net_start "$IFACE_TO_UPDOWN"
kci_net_setup "$IFACE_TO_TEST"
kci_netdev_ethtool "$IFACE_TO_TEST"
kci_netdev_stop "$IFACE_TO_UPDOWN"
return 0
}
#check for needed privileges
if [ "$(id -u)" -ne 0 ];then
echo "SKIP: Need root privileges"
exit 0
fi
ip link show 2>/dev/null >/dev/null
if [ $? -ne 0 ];then
echo "SKIP: Could not run test without the ip tool"
exit 0
fi
TMP_LIST_NETDEV="$(mktemp)"
if [ ! -e "$TMP_LIST_NETDEV" ];then
echo "FAIL: Cannot create a tmp file"
exit 1
fi
ip link show |grep '^[0-9]' | grep -oE '[[:space:]].*eth[0-9]*:|[[:space:]].*enp[0-9]s[0-9]:' | cut -d\ -f2 | cut -d: -f1> "$TMP_LIST_NETDEV"
while read netdev
do
kci_test_netdev "$netdev"
done < "$TMP_LIST_NETDEV"
rm "$TMP_LIST_NETDEV"
exit 0
| gpl-2.0 |
anouschka42/starktheatreprod | sites/all/libraries/wkhtmltopdf-0.12.0/scripts/sourcefix.py | 4292 | #!/usr/bin/python
#
# Copyright 2010, 2011 wkhtmltopdf authors
#
# This file is part of wkhtmltopdf.
#
# wkhtmltopdf is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# wkhtmltopdf is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with wkhtmltopdf. If not, see <http:#www.gnu.org/licenses/>.
from sys import argv, exit
import re
from datetime import date
import os
import difflib
cdate = re.compile(r"Copyright ([0-9 ,]*) wkhtmltopdf authors")
ifdef = re.compile(r"^[\n\r \t]*#ifndef __(.*)__[\t ]*\n#define __(\1)__[\t ]*\n")
endif = re.compile(r"#endif.*[\r\n \t]*$")
ws = re.compile(r"[ \t]*[\r\n]")
branchspace = re.compile(r"([ \t\r\n])(for|if|while|switch|foreach)[\t \r\n]*\(")
hangelse = re.compile(r"}[\r\n\t ]*(else)")
braceup = re.compile(r"(\)|else)[\r\n\t ]*{")
include = re.compile(r"(#include (\"[^\"]*\"|<[^>]*>)\n)+")
def includesort(x):
return "\n".join(sorted(x.group(0)[:-1].split("\n"))+[""])
changes=False
progname="wkhtmltopdf"
for path in argv[1:]:
if path.split("/")[0] == "include": continue
try:
data = file(path).read()
except:
continue
mo = cdate.search(data)
years = set(mo.group(1).split(", ")) if mo else set()
years.add(str(date.today().year))
ext = path.rsplit(".",2)[-1]
header = ""
cc = "//"
if ext in ["hh","h","c","cc","cpp","inl", "inc"]:
header += """// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; eval: (progn (c-set-style "stroustrup") (c-set-offset 'innamespace 0)); -*-
// vi:set ts=4 sts=4 sw=4 noet :
//
"""
elif ext in ["sh"]:
header += "#!/bin/bash\n#\n"
cc = "#"
elif ext in ["py"]:
header += "#!/usr/bin/python\n#\n"
cc = "#"
elif ext in ["pro","pri"]:
cc = "#"
else:
continue
header += """// Copyright %(years)s %(name)s authors
//
// This file is part of %(name)s.
//
// %(name)s is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// %(name)s is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with %(name)s. If not, see <http://www.gnu.org/licenses/>.
"""%{"years": (", ".join(sorted(list(years)))),"name":progname}
if ext in ["c", "h", "inc"]:
header = "/*" + header[2:-1] + " */\n\n"
cc = " *"
hexp = re.compile(r"^/\*([^*]*(\*[^/]))*[^*]*\*/[ \t\n]*");
else:
#Strip away generated header
hexp = re.compile("^(%s[^\\n]*\\n)*"%(cc))
ndata = hexp.sub("", data,1)
ndata = ws.sub("\n", ndata)+"\n"
if ext in ["hh","h","inl"]:
s=0
e=-1
while ndata[s] in ['\r','\n',' ','\t']: s+=1
while ndata[e] in ['\r','\n',' ','\t']: e-=1
#Strip away generated ifdef
if ifdef.search(ndata):
ndata = endif.sub("",ifdef.sub("",ndata,1),1)
s=0
e=-1
while ndata[s] in ['\r','\n',' ','\t']: s+=1
while ndata[e] in ['\r','\n',' ','\t']: e-=1
ndata=ndata[s:e+1].replace(" ",'\t')
if ext in ["hh","h","c","cc","cpp","inl"]:
ndata = branchspace.sub(r"\1\2 (",ndata)
ndata = hangelse.sub("} else",ndata)
ndata = braceup.sub(r"\1 {",ndata)
ndata = include.sub(includesort, ndata)
if ext in ["hh","h","inl"]:
n = os.path.split(path)[-1].replace(".","_").replace(" ","_").upper()
ndata = """#ifndef __%s__
#define __%s__
%s
#endif %s__%s__%s"""%(n,n,ndata, "//" if ext != "h" else "/*", n, "" if ext != "h" else "*/")
ndata = header.replace("//",cc)+ndata+"\n"
if ndata != data:
for x in difflib.unified_diff(data.split("\n"),ndata.split("\n"), "a/"+path, "b/"+path):
print x
changes=True
file(path, "w").write(ndata)
if changes: exit(1)
| gpl-2.0 |
nmacd85/drupal-nicoledawn | vendor/symfony/http-kernel/DependencyInjection/FragmentRendererPass.php | 2526 | <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <[email protected]>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\HttpKernel\DependencyInjection;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\HttpKernel\Fragment\FragmentRendererInterface;
/**
* Adds services tagged kernel.fragment_renderer as HTTP content rendering strategies.
*
* @author Fabien Potencier <[email protected]>
*/
class FragmentRendererPass implements CompilerPassInterface
{
private $handlerService;
private $rendererTag;
/**
* @param string $handlerService Service name of the fragment handler in the container
* @param string $rendererTag Tag name used for fragments
*/
public function __construct($handlerService = 'fragment.handler', $rendererTag = 'kernel.fragment_renderer')
{
$this->handlerService = $handlerService;
$this->rendererTag = $rendererTag;
}
public function process(ContainerBuilder $container)
{
if (!$container->hasDefinition($this->handlerService)) {
return;
}
$definition = $container->getDefinition($this->handlerService);
$renderers = array();
foreach ($container->findTaggedServiceIds($this->rendererTag, true) as $id => $tags) {
$def = $container->getDefinition($id);
$class = $container->getParameterBag()->resolveValue($def->getClass());
if (!$r = $container->getReflectionClass($class)) {
throw new InvalidArgumentException(sprintf('Class "%s" used for service "%s" cannot be found.', $class, $id));
}
if (!$r->isSubclassOf(FragmentRendererInterface::class)) {
throw new InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, FragmentRendererInterface::class));
}
foreach ($tags as $tag) {
$renderers[$tag['alias']] = new Reference($id);
}
}
$definition->replaceArgument(0, ServiceLocatorTagPass::register($container, $renderers));
}
}
| gpl-2.0 |
tectronics/houdini-ocean-toolkit | src/3rdparty/src/fftw-3.2.2/dft/simd/codelets/n2sv_32.c | 50411 | /*
* Copyright (c) 2003, 2007-8 Matteo Frigo
* Copyright (c) 2003, 2007-8 Massachusetts Institute of Technology
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/* This file was automatically generated --- DO NOT EDIT */
/* Generated on Sun Jul 12 06:40:39 EDT 2009 */
#include "codelet-dft.h"
#ifdef HAVE_FMA
/* Generated by: ../../../genfft/gen_notw -fma -reorder-insns -schedule-for-pipeline -simd -compact -variables 4 -pipeline-latency 8 -n 32 -name n2sv_32 -with-ostride 1 -include n2s.h -store-multiple 4 */
/*
* This function contains 372 FP additions, 136 FP multiplications,
* (or, 236 additions, 0 multiplications, 136 fused multiply/add),
* 194 stack variables, 7 constants, and 144 memory accesses
*/
#include "n2s.h"
static void n2sv_32(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs)
{
DVK(KP980785280, +0.980785280403230449126182236134239036973933731);
DVK(KP198912367, +0.198912367379658006911597622644676228597850501);
DVK(KP831469612, +0.831469612302545237078788377617905756738560812);
DVK(KP668178637, +0.668178637919298919997757686523080761552472251);
DVK(KP923879532, +0.923879532511286756128183189396788286822416626);
DVK(KP707106781, +0.707106781186547524400844362104849039284835938);
DVK(KP414213562, +0.414213562373095048801688724209698078569671875);
INT i;
for (i = v; i > 0; i = i - (2 * VL), ri = ri + ((2 * VL) * ivs), ii = ii + ((2 * VL) * ivs), ro = ro + ((2 * VL) * ovs), io = io + ((2 * VL) * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {
V T61, T62, T63, T64, T65, T66, T67, T68, T69, T6a, T6b, T6c, T6d, T6e, T6f;
V T6g, T6h, T6i, T6j, T6k, T6l, T6m, T6n, T6o, T6p, T6q, T6r, T6s, T6t, T6u;
V T6v, T6w, T3g, T3f, T6x, T6y, T6z, T6A, T6B, T6C, T6D, T6E, T4p, T49, T4l;
V T4j, T6F, T6G, T6H, T6I, T6J, T6K, T6L, T6M, T3n, T3b, T3r, T3l, T3o, T3e;
V T4q, T4o, T4k, T4g, T3h, T3p;
{
V T2T, T3T, T4r, T7, T3t, T1z, T18, T4Z, Te, T50, T1f, T4s, T1G, T3U, T2W;
V T3u, Tm, T1n, T3X, T3y, T2Z, T1O, T53, T4w, Tt, T1u, T3W, T3B, T2Y, T1V;
V T52, T4z, T3O, T2t, T3L, T2K, TZ, T5F, T4R, T5k, T5j, T4W, T5I, T5X, T2E;
V T3M, T2N, T3P, T3H, T22, T3E, T2j, T4G, T5h, TK, T5A, T5D, T5W, T2d, T3F;
V T4L, T5g, T3I, T2m;
{
V T1L, T1j, T1k, T1l, T4v, T1K, T3w;
{
V T1, T2, T12, T13, T4, T5, T15, T16;
T1 = LD(&(ri[0]), ivs, &(ri[0]));
T2 = LD(&(ri[WS(is, 16)]), ivs, &(ri[0]));
T12 = LD(&(ii[0]), ivs, &(ii[0]));
T13 = LD(&(ii[WS(is, 16)]), ivs, &(ii[0]));
T4 = LD(&(ri[WS(is, 8)]), ivs, &(ri[0]));
T5 = LD(&(ri[WS(is, 24)]), ivs, &(ri[0]));
T15 = LD(&(ii[WS(is, 8)]), ivs, &(ii[0]));
T16 = LD(&(ii[WS(is, 24)]), ivs, &(ii[0]));
{
V Tb, T1A, Ta, T1B, T1b, Tc, T1c, T1d;
{
V T8, T1x, T3, T2R, T14, T2S, T6, T1y, T17, T9, T19, T1a;
T8 = LD(&(ri[WS(is, 4)]), ivs, &(ri[0]));
T1x = VSUB(T1, T2);
T3 = VADD(T1, T2);
T2R = VSUB(T12, T13);
T14 = VADD(T12, T13);
T2S = VSUB(T4, T5);
T6 = VADD(T4, T5);
T1y = VSUB(T15, T16);
T17 = VADD(T15, T16);
T9 = LD(&(ri[WS(is, 20)]), ivs, &(ri[0]));
T19 = LD(&(ii[WS(is, 4)]), ivs, &(ii[0]));
T1a = LD(&(ii[WS(is, 20)]), ivs, &(ii[0]));
Tb = LD(&(ri[WS(is, 28)]), ivs, &(ri[0]));
T2T = VSUB(T2R, T2S);
T3T = VADD(T2S, T2R);
T4r = VSUB(T3, T6);
T7 = VADD(T3, T6);
T3t = VSUB(T1x, T1y);
T1z = VADD(T1x, T1y);
T18 = VADD(T14, T17);
T4Z = VSUB(T14, T17);
T1A = VSUB(T8, T9);
Ta = VADD(T8, T9);
T1B = VSUB(T19, T1a);
T1b = VADD(T19, T1a);
Tc = LD(&(ri[WS(is, 12)]), ivs, &(ri[0]));
T1c = LD(&(ii[WS(is, 28)]), ivs, &(ii[0]));
T1d = LD(&(ii[WS(is, 12)]), ivs, &(ii[0]));
}
{
V Ti, T1I, T1J, Tl;
{
V T1h, T1C, T2U, T1D, Td, T1E, T1e, T1i, Tg, Th;
Tg = LD(&(ri[WS(is, 2)]), ivs, &(ri[0]));
Th = LD(&(ri[WS(is, 18)]), ivs, &(ri[0]));
T1h = LD(&(ii[WS(is, 2)]), ivs, &(ii[0]));
T1C = VADD(T1A, T1B);
T2U = VSUB(T1B, T1A);
T1D = VSUB(Tb, Tc);
Td = VADD(Tb, Tc);
T1E = VSUB(T1c, T1d);
T1e = VADD(T1c, T1d);
T1L = VSUB(Tg, Th);
Ti = VADD(Tg, Th);
T1i = LD(&(ii[WS(is, 18)]), ivs, &(ii[0]));
{
V T2V, T1F, Tj, Tk;
Tj = LD(&(ri[WS(is, 10)]), ivs, &(ri[0]));
Tk = LD(&(ri[WS(is, 26)]), ivs, &(ri[0]));
Te = VADD(Ta, Td);
T50 = VSUB(Td, Ta);
T2V = VADD(T1D, T1E);
T1F = VSUB(T1D, T1E);
T1f = VADD(T1b, T1e);
T4s = VSUB(T1b, T1e);
T1j = VADD(T1h, T1i);
T1I = VSUB(T1h, T1i);
T1J = VSUB(Tj, Tk);
Tl = VADD(Tj, Tk);
T1G = VADD(T1C, T1F);
T3U = VSUB(T1F, T1C);
T2W = VADD(T2U, T2V);
T3u = VSUB(T2U, T2V);
T1k = LD(&(ii[WS(is, 10)]), ivs, &(ii[0]));
T1l = LD(&(ii[WS(is, 26)]), ivs, &(ii[0]));
}
}
T4v = VSUB(Ti, Tl);
Tm = VADD(Ti, Tl);
T1K = VSUB(T1I, T1J);
T3w = VADD(T1J, T1I);
}
}
}
{
V T1r, T1S, T1q, T1s, T4x, T1R, T3z;
{
V Tp, T1P, T1Q, Ts;
{
V Tn, To, T1o, T1M, T1m, T1p;
Tn = LD(&(ri[WS(is, 30)]), ivs, &(ri[0]));
To = LD(&(ri[WS(is, 14)]), ivs, &(ri[0]));
T1o = LD(&(ii[WS(is, 30)]), ivs, &(ii[0]));
T1M = VSUB(T1k, T1l);
T1m = VADD(T1k, T1l);
T1p = LD(&(ii[WS(is, 14)]), ivs, &(ii[0]));
{
V Tq, Tr, T3x, T1N, T4u;
Tq = LD(&(ri[WS(is, 6)]), ivs, &(ri[0]));
Tr = LD(&(ri[WS(is, 22)]), ivs, &(ri[0]));
T1r = LD(&(ii[WS(is, 6)]), ivs, &(ii[0]));
T1S = VSUB(Tn, To);
Tp = VADD(Tn, To);
T3x = VSUB(T1L, T1M);
T1N = VADD(T1L, T1M);
T4u = VSUB(T1j, T1m);
T1n = VADD(T1j, T1m);
T1P = VSUB(T1o, T1p);
T1q = VADD(T1o, T1p);
T1Q = VSUB(Tq, Tr);
Ts = VADD(Tq, Tr);
T3X = VFNMS(LDK(KP414213562), T3w, T3x);
T3y = VFMA(LDK(KP414213562), T3x, T3w);
T2Z = VFMA(LDK(KP414213562), T1K, T1N);
T1O = VFNMS(LDK(KP414213562), T1N, T1K);
T53 = VADD(T4v, T4u);
T4w = VSUB(T4u, T4v);
T1s = LD(&(ii[WS(is, 22)]), ivs, &(ii[0]));
}
}
T4x = VSUB(Tp, Ts);
Tt = VADD(Tp, Ts);
T1R = VSUB(T1P, T1Q);
T3z = VADD(T1Q, T1P);
}
{
V T4S, T5G, T2y, T2L, T4V, T5H, T2D, T2M;
{
V T2G, TN, T4N, T2r, T2s, TQ, T2A, T4O, T2J, T2x, TU, T4T, T2w, T2z, TX;
V T2B, T2H, T2I, TR;
{
V TL, TM, T2p, T1T, T1t, T2q;
TL = LD(&(ri[WS(is, 31)]), ivs, &(ri[WS(is, 1)]));
TM = LD(&(ri[WS(is, 15)]), ivs, &(ri[WS(is, 1)]));
T2p = LD(&(ii[WS(is, 31)]), ivs, &(ii[WS(is, 1)]));
T1T = VSUB(T1r, T1s);
T1t = VADD(T1r, T1s);
T2q = LD(&(ii[WS(is, 15)]), ivs, &(ii[WS(is, 1)]));
{
V TO, TP, T3A, T1U, T4y;
TO = LD(&(ri[WS(is, 7)]), ivs, &(ri[WS(is, 1)]));
TP = LD(&(ri[WS(is, 23)]), ivs, &(ri[WS(is, 1)]));
T2H = LD(&(ii[WS(is, 7)]), ivs, &(ii[WS(is, 1)]));
T2G = VSUB(TL, TM);
TN = VADD(TL, TM);
T3A = VSUB(T1S, T1T);
T1U = VADD(T1S, T1T);
T4y = VSUB(T1q, T1t);
T1u = VADD(T1q, T1t);
T4N = VADD(T2p, T2q);
T2r = VSUB(T2p, T2q);
T2s = VSUB(TO, TP);
TQ = VADD(TO, TP);
T3W = VFMA(LDK(KP414213562), T3z, T3A);
T3B = VFNMS(LDK(KP414213562), T3A, T3z);
T2Y = VFNMS(LDK(KP414213562), T1R, T1U);
T1V = VFMA(LDK(KP414213562), T1U, T1R);
T52 = VSUB(T4x, T4y);
T4z = VADD(T4x, T4y);
T2I = LD(&(ii[WS(is, 23)]), ivs, &(ii[WS(is, 1)]));
}
}
{
V TS, TT, T2u, T2v, TV, TW;
TS = LD(&(ri[WS(is, 3)]), ivs, &(ri[WS(is, 1)]));
TT = LD(&(ri[WS(is, 19)]), ivs, &(ri[WS(is, 1)]));
T2u = LD(&(ii[WS(is, 3)]), ivs, &(ii[WS(is, 1)]));
T2v = LD(&(ii[WS(is, 19)]), ivs, &(ii[WS(is, 1)]));
TV = LD(&(ri[WS(is, 27)]), ivs, &(ri[WS(is, 1)]));
TW = LD(&(ri[WS(is, 11)]), ivs, &(ri[WS(is, 1)]));
T2A = LD(&(ii[WS(is, 27)]), ivs, &(ii[WS(is, 1)]));
T4O = VADD(T2H, T2I);
T2J = VSUB(T2H, T2I);
T2x = VSUB(TS, TT);
TU = VADD(TS, TT);
T4T = VADD(T2u, T2v);
T2w = VSUB(T2u, T2v);
T2z = VSUB(TV, TW);
TX = VADD(TV, TW);
T2B = LD(&(ii[WS(is, 11)]), ivs, &(ii[WS(is, 1)]));
}
T3O = VADD(T2s, T2r);
T2t = VSUB(T2r, T2s);
T3L = VSUB(T2G, T2J);
T2K = VADD(T2G, T2J);
T4S = VSUB(TN, TQ);
TR = VADD(TN, TQ);
{
V T4P, T4Q, TY, T4U, T2C;
T5G = VADD(T4N, T4O);
T4P = VSUB(T4N, T4O);
T4Q = VSUB(TX, TU);
TY = VADD(TU, TX);
T4U = VADD(T2A, T2B);
T2C = VSUB(T2A, T2B);
T2y = VSUB(T2w, T2x);
T2L = VADD(T2x, T2w);
TZ = VADD(TR, TY);
T5F = VSUB(TR, TY);
T4V = VSUB(T4T, T4U);
T5H = VADD(T4T, T4U);
T2D = VADD(T2z, T2C);
T2M = VSUB(T2z, T2C);
T4R = VSUB(T4P, T4Q);
T5k = VADD(T4Q, T4P);
}
}
{
V T2f, Ty, T23, T4C, T20, T21, TB, T4D, T2i, T26, TF, T24, TG, TH, T29;
V T2a;
{
V T1Y, T1Z, Tz, TA, T2g, T2h, Tw, Tx, TD, TE;
Tw = LD(&(ri[WS(is, 1)]), ivs, &(ri[WS(is, 1)]));
Tx = LD(&(ri[WS(is, 17)]), ivs, &(ri[WS(is, 1)]));
T5j = VADD(T4S, T4V);
T4W = VSUB(T4S, T4V);
T5I = VSUB(T5G, T5H);
T5X = VADD(T5G, T5H);
T2E = VADD(T2y, T2D);
T3M = VSUB(T2D, T2y);
T2N = VADD(T2L, T2M);
T3P = VSUB(T2L, T2M);
T2f = VSUB(Tw, Tx);
Ty = VADD(Tw, Tx);
T1Y = LD(&(ii[WS(is, 1)]), ivs, &(ii[WS(is, 1)]));
T1Z = LD(&(ii[WS(is, 17)]), ivs, &(ii[WS(is, 1)]));
Tz = LD(&(ri[WS(is, 9)]), ivs, &(ri[WS(is, 1)]));
TA = LD(&(ri[WS(is, 25)]), ivs, &(ri[WS(is, 1)]));
T2g = LD(&(ii[WS(is, 9)]), ivs, &(ii[WS(is, 1)]));
T2h = LD(&(ii[WS(is, 25)]), ivs, &(ii[WS(is, 1)]));
TD = LD(&(ri[WS(is, 5)]), ivs, &(ri[WS(is, 1)]));
TE = LD(&(ri[WS(is, 21)]), ivs, &(ri[WS(is, 1)]));
T23 = LD(&(ii[WS(is, 5)]), ivs, &(ii[WS(is, 1)]));
T4C = VADD(T1Y, T1Z);
T20 = VSUB(T1Y, T1Z);
T21 = VSUB(Tz, TA);
TB = VADD(Tz, TA);
T4D = VADD(T2g, T2h);
T2i = VSUB(T2g, T2h);
T26 = VSUB(TD, TE);
TF = VADD(TD, TE);
T24 = LD(&(ii[WS(is, 21)]), ivs, &(ii[WS(is, 1)]));
TG = LD(&(ri[WS(is, 29)]), ivs, &(ri[WS(is, 1)]));
TH = LD(&(ri[WS(is, 13)]), ivs, &(ri[WS(is, 1)]));
T29 = LD(&(ii[WS(is, 29)]), ivs, &(ii[WS(is, 1)]));
T2a = LD(&(ii[WS(is, 13)]), ivs, &(ii[WS(is, 1)]));
}
{
V T4I, T25, T28, TI, T4J, T2b, T4H, TC, T5B, T4E;
T3H = VADD(T21, T20);
T22 = VSUB(T20, T21);
T3E = VSUB(T2f, T2i);
T2j = VADD(T2f, T2i);
T4I = VADD(T23, T24);
T25 = VSUB(T23, T24);
T28 = VSUB(TG, TH);
TI = VADD(TG, TH);
T4J = VADD(T29, T2a);
T2b = VSUB(T29, T2a);
T4H = VSUB(Ty, TB);
TC = VADD(Ty, TB);
T5B = VADD(T4C, T4D);
T4E = VSUB(T4C, T4D);
{
V T27, T2k, TJ, T4F, T4K, T5C, T2c, T2l;
T27 = VSUB(T25, T26);
T2k = VADD(T26, T25);
TJ = VADD(TF, TI);
T4F = VSUB(TI, TF);
T4K = VSUB(T4I, T4J);
T5C = VADD(T4I, T4J);
T2c = VADD(T28, T2b);
T2l = VSUB(T28, T2b);
T4G = VSUB(T4E, T4F);
T5h = VADD(T4F, T4E);
TK = VADD(TC, TJ);
T5A = VSUB(TC, TJ);
T5D = VSUB(T5B, T5C);
T5W = VADD(T5B, T5C);
T2d = VADD(T27, T2c);
T3F = VSUB(T2c, T27);
T4L = VSUB(T4H, T4K);
T5g = VADD(T4H, T4K);
T3I = VSUB(T2k, T2l);
T2m = VADD(T2k, T2l);
}
}
}
}
}
}
{
V T1v, T1g, T5V, Tv, T60, T5Y, T11, T10;
{
V T5o, T5n, T5i, T5r, T5f, T5l, T5w, T5u;
{
V T5d, T4t, T4A, T4X, T58, T51, T4M, T59, T54, T5e, T5b, T4B;
T5d = VADD(T4r, T4s);
T4t = VSUB(T4r, T4s);
T4A = VSUB(T4w, T4z);
T5o = VADD(T4w, T4z);
T4X = VFNMS(LDK(KP414213562), T4W, T4R);
T58 = VFMA(LDK(KP414213562), T4R, T4W);
T5n = VADD(T50, T4Z);
T51 = VSUB(T4Z, T50);
T4M = VFMA(LDK(KP414213562), T4L, T4G);
T59 = VFNMS(LDK(KP414213562), T4G, T4L);
T54 = VSUB(T52, T53);
T5e = VADD(T53, T52);
T5b = VFNMS(LDK(KP707106781), T4A, T4t);
T4B = VFMA(LDK(KP707106781), T4A, T4t);
{
V T5s, T56, T4Y, T5c, T5a, T57, T55, T5t;
T5i = VFMA(LDK(KP414213562), T5h, T5g);
T5s = VFNMS(LDK(KP414213562), T5g, T5h);
T56 = VADD(T4M, T4X);
T4Y = VSUB(T4M, T4X);
T5c = VADD(T59, T58);
T5a = VSUB(T58, T59);
T57 = VFMA(LDK(KP707106781), T54, T51);
T55 = VFNMS(LDK(KP707106781), T54, T51);
T5r = VFNMS(LDK(KP707106781), T5e, T5d);
T5f = VFMA(LDK(KP707106781), T5e, T5d);
T5t = VFMA(LDK(KP414213562), T5j, T5k);
T5l = VFNMS(LDK(KP414213562), T5k, T5j);
T61 = VFMA(LDK(KP923879532), T4Y, T4B);
STM4(&(ro[6]), T61, ovs, &(ro[0]));
T62 = VFNMS(LDK(KP923879532), T4Y, T4B);
STM4(&(ro[22]), T62, ovs, &(ro[0]));
T63 = VFMA(LDK(KP923879532), T5c, T5b);
STM4(&(ro[30]), T63, ovs, &(ro[0]));
T64 = VFNMS(LDK(KP923879532), T5c, T5b);
STM4(&(ro[14]), T64, ovs, &(ro[0]));
T65 = VFMA(LDK(KP923879532), T5a, T57);
STM4(&(io[6]), T65, ovs, &(io[0]));
T66 = VFNMS(LDK(KP923879532), T5a, T57);
STM4(&(io[22]), T66, ovs, &(io[0]));
T67 = VFMA(LDK(KP923879532), T56, T55);
STM4(&(io[30]), T67, ovs, &(io[0]));
T68 = VFNMS(LDK(KP923879532), T56, T55);
STM4(&(io[14]), T68, ovs, &(io[0]));
T5w = VADD(T5s, T5t);
T5u = VSUB(T5s, T5t);
}
}
{
V Tf, T5P, T5z, T5S, T5U, T5O, T5K, T5L, T5M, Tu, T5T, T5N;
{
V T5E, T5Q, T5q, T5m, T5v, T5p, T5R, T5J, T5x, T5y;
Tf = VADD(T7, Te);
T5x = VSUB(T7, Te);
T5y = VSUB(T1n, T1u);
T1v = VADD(T1n, T1u);
T69 = VFMA(LDK(KP923879532), T5u, T5r);
STM4(&(ro[10]), T69, ovs, &(ro[0]));
T6a = VFNMS(LDK(KP923879532), T5u, T5r);
STM4(&(ro[26]), T6a, ovs, &(ro[0]));
T5E = VADD(T5A, T5D);
T5Q = VSUB(T5D, T5A);
T5q = VSUB(T5l, T5i);
T5m = VADD(T5i, T5l);
T5v = VFMA(LDK(KP707106781), T5o, T5n);
T5p = VFNMS(LDK(KP707106781), T5o, T5n);
T5P = VSUB(T5x, T5y);
T5z = VADD(T5x, T5y);
T5R = VADD(T5F, T5I);
T5J = VSUB(T5F, T5I);
T6b = VFMA(LDK(KP923879532), T5m, T5f);
STM4(&(ro[2]), T6b, ovs, &(ro[0]));
T6c = VFNMS(LDK(KP923879532), T5m, T5f);
STM4(&(ro[18]), T6c, ovs, &(ro[0]));
T6d = VFMA(LDK(KP923879532), T5w, T5v);
STM4(&(io[2]), T6d, ovs, &(io[0]));
T6e = VFNMS(LDK(KP923879532), T5w, T5v);
STM4(&(io[18]), T6e, ovs, &(io[0]));
T6f = VFMA(LDK(KP923879532), T5q, T5p);
STM4(&(io[10]), T6f, ovs, &(io[0]));
T6g = VFNMS(LDK(KP923879532), T5q, T5p);
STM4(&(io[26]), T6g, ovs, &(io[0]));
T5S = VSUB(T5Q, T5R);
T5U = VADD(T5Q, T5R);
T5O = VSUB(T5J, T5E);
T5K = VADD(T5E, T5J);
T1g = VADD(T18, T1f);
T5L = VSUB(T18, T1f);
T5M = VSUB(Tt, Tm);
Tu = VADD(Tm, Tt);
}
T6h = VFMA(LDK(KP707106781), T5S, T5P);
STM4(&(ro[12]), T6h, ovs, &(ro[0]));
T6i = VFNMS(LDK(KP707106781), T5S, T5P);
STM4(&(ro[28]), T6i, ovs, &(ro[0]));
T6j = VFMA(LDK(KP707106781), T5K, T5z);
STM4(&(ro[4]), T6j, ovs, &(ro[0]));
T6k = VFNMS(LDK(KP707106781), T5K, T5z);
STM4(&(ro[20]), T6k, ovs, &(ro[0]));
T5T = VADD(T5M, T5L);
T5N = VSUB(T5L, T5M);
T5V = VSUB(Tf, Tu);
Tv = VADD(Tf, Tu);
T6l = VFMA(LDK(KP707106781), T5U, T5T);
STM4(&(io[4]), T6l, ovs, &(io[0]));
T6m = VFNMS(LDK(KP707106781), T5U, T5T);
STM4(&(io[20]), T6m, ovs, &(io[0]));
T6n = VFMA(LDK(KP707106781), T5O, T5N);
STM4(&(io[12]), T6n, ovs, &(io[0]));
T6o = VFNMS(LDK(KP707106781), T5O, T5N);
STM4(&(io[28]), T6o, ovs, &(io[0]));
T60 = VADD(T5W, T5X);
T5Y = VSUB(T5W, T5X);
T11 = VSUB(TZ, TK);
T10 = VADD(TK, TZ);
}
}
{
V T39, T3k, T3j, T3a, T1X, T37, T33, T31, T3d, T3c, T47, T4i, T4h, T48, T4b;
V T4a, T4e, T3N, T41, T3D, T45, T3Z, T38, T36, T32, T2Q, T42, T3K, T3Q, T4d;
{
V T2e, T2n, T2F, T2O, T1w, T5Z;
{
V T1H, T1W, T2X, T30;
T39 = VFMA(LDK(KP707106781), T1G, T1z);
T1H = VFNMS(LDK(KP707106781), T1G, T1z);
T1W = VSUB(T1O, T1V);
T3k = VADD(T1O, T1V);
T3j = VFMA(LDK(KP707106781), T2W, T2T);
T2X = VFNMS(LDK(KP707106781), T2W, T2T);
T30 = VSUB(T2Y, T2Z);
T3a = VADD(T2Z, T2Y);
T6p = VSUB(T5V, T5Y);
STM4(&(ro[24]), T6p, ovs, &(ro[0]));
T6q = VADD(T5V, T5Y);
STM4(&(ro[8]), T6q, ovs, &(ro[0]));
T6r = VADD(Tv, T10);
STM4(&(ro[0]), T6r, ovs, &(ro[0]));
T6s = VSUB(Tv, T10);
STM4(&(ro[16]), T6s, ovs, &(ro[0]));
T1w = VSUB(T1g, T1v);
T5Z = VADD(T1g, T1v);
T1X = VFMA(LDK(KP923879532), T1W, T1H);
T37 = VFNMS(LDK(KP923879532), T1W, T1H);
T33 = VFMA(LDK(KP923879532), T30, T2X);
T31 = VFNMS(LDK(KP923879532), T30, T2X);
}
T3d = VFMA(LDK(KP707106781), T2d, T22);
T2e = VFNMS(LDK(KP707106781), T2d, T22);
T2n = VFNMS(LDK(KP707106781), T2m, T2j);
T3c = VFMA(LDK(KP707106781), T2m, T2j);
T6t = VADD(T5Z, T60);
STM4(&(io[0]), T6t, ovs, &(io[0]));
T6u = VSUB(T5Z, T60);
STM4(&(io[16]), T6u, ovs, &(io[0]));
T6v = VSUB(T1w, T11);
STM4(&(io[24]), T6v, ovs, &(io[0]));
T6w = VADD(T11, T1w);
STM4(&(io[8]), T6w, ovs, &(io[0]));
T3g = VFMA(LDK(KP707106781), T2E, T2t);
T2F = VFNMS(LDK(KP707106781), T2E, T2t);
T2O = VFNMS(LDK(KP707106781), T2N, T2K);
T3f = VFMA(LDK(KP707106781), T2N, T2K);
{
V T3v, T35, T2o, T3C, T3V, T3Y;
T47 = VFNMS(LDK(KP707106781), T3u, T3t);
T3v = VFMA(LDK(KP707106781), T3u, T3t);
T35 = VFNMS(LDK(KP668178637), T2e, T2n);
T2o = VFMA(LDK(KP668178637), T2n, T2e);
T3C = VSUB(T3y, T3B);
T4i = VADD(T3y, T3B);
T4h = VFNMS(LDK(KP707106781), T3U, T3T);
T3V = VFMA(LDK(KP707106781), T3U, T3T);
T3Y = VSUB(T3W, T3X);
T48 = VADD(T3X, T3W);
{
V T3G, T34, T2P, T3J;
T4b = VFMA(LDK(KP707106781), T3F, T3E);
T3G = VFNMS(LDK(KP707106781), T3F, T3E);
T34 = VFMA(LDK(KP668178637), T2F, T2O);
T2P = VFNMS(LDK(KP668178637), T2O, T2F);
T3J = VFNMS(LDK(KP707106781), T3I, T3H);
T4a = VFMA(LDK(KP707106781), T3I, T3H);
T4e = VFMA(LDK(KP707106781), T3M, T3L);
T3N = VFNMS(LDK(KP707106781), T3M, T3L);
T41 = VFNMS(LDK(KP923879532), T3C, T3v);
T3D = VFMA(LDK(KP923879532), T3C, T3v);
T45 = VFMA(LDK(KP923879532), T3Y, T3V);
T3Z = VFNMS(LDK(KP923879532), T3Y, T3V);
T38 = VADD(T35, T34);
T36 = VSUB(T34, T35);
T32 = VADD(T2o, T2P);
T2Q = VSUB(T2o, T2P);
T42 = VFNMS(LDK(KP668178637), T3G, T3J);
T3K = VFMA(LDK(KP668178637), T3J, T3G);
T3Q = VFNMS(LDK(KP707106781), T3P, T3O);
T4d = VFMA(LDK(KP707106781), T3P, T3O);
}
}
}
{
V T4n, T4c, T43, T3R, T4m, T4f;
T6x = VFMA(LDK(KP831469612), T38, T37);
STM4(&(ro[29]), T6x, ovs, &(ro[1]));
T6y = VFNMS(LDK(KP831469612), T38, T37);
STM4(&(ro[13]), T6y, ovs, &(ro[1]));
T6z = VFMA(LDK(KP831469612), T36, T33);
STM4(&(io[5]), T6z, ovs, &(io[1]));
T6A = VFNMS(LDK(KP831469612), T36, T33);
STM4(&(io[21]), T6A, ovs, &(io[1]));
T6B = VFMA(LDK(KP831469612), T32, T31);
STM4(&(io[29]), T6B, ovs, &(io[1]));
T6C = VFNMS(LDK(KP831469612), T32, T31);
STM4(&(io[13]), T6C, ovs, &(io[1]));
T6D = VFMA(LDK(KP831469612), T2Q, T1X);
STM4(&(ro[5]), T6D, ovs, &(ro[1]));
T6E = VFNMS(LDK(KP831469612), T2Q, T1X);
STM4(&(ro[21]), T6E, ovs, &(ro[1]));
T43 = VFMA(LDK(KP668178637), T3N, T3Q);
T3R = VFNMS(LDK(KP668178637), T3Q, T3N);
{
V T44, T46, T40, T3S;
T44 = VSUB(T42, T43);
T46 = VADD(T42, T43);
T40 = VSUB(T3R, T3K);
T3S = VADD(T3K, T3R);
T4p = VFMA(LDK(KP923879532), T48, T47);
T49 = VFNMS(LDK(KP923879532), T48, T47);
T4l = VFNMS(LDK(KP923879532), T4i, T4h);
T4j = VFMA(LDK(KP923879532), T4i, T4h);
T4n = VFNMS(LDK(KP198912367), T4a, T4b);
T4c = VFMA(LDK(KP198912367), T4b, T4a);
T6F = VFMA(LDK(KP831469612), T44, T41);
STM4(&(ro[11]), T6F, ovs, &(ro[1]));
T6G = VFNMS(LDK(KP831469612), T44, T41);
STM4(&(ro[27]), T6G, ovs, &(ro[1]));
T6H = VFMA(LDK(KP831469612), T46, T45);
STM4(&(io[3]), T6H, ovs, &(io[1]));
T6I = VFNMS(LDK(KP831469612), T46, T45);
STM4(&(io[19]), T6I, ovs, &(io[1]));
T6J = VFMA(LDK(KP831469612), T40, T3Z);
STM4(&(io[11]), T6J, ovs, &(io[1]));
T6K = VFNMS(LDK(KP831469612), T40, T3Z);
STM4(&(io[27]), T6K, ovs, &(io[1]));
T6L = VFMA(LDK(KP831469612), T3S, T3D);
STM4(&(ro[3]), T6L, ovs, &(ro[1]));
T6M = VFNMS(LDK(KP831469612), T3S, T3D);
STM4(&(ro[19]), T6M, ovs, &(ro[1]));
}
T4m = VFMA(LDK(KP198912367), T4d, T4e);
T4f = VFNMS(LDK(KP198912367), T4e, T4d);
T3n = VFNMS(LDK(KP923879532), T3a, T39);
T3b = VFMA(LDK(KP923879532), T3a, T39);
T3r = VFMA(LDK(KP923879532), T3k, T3j);
T3l = VFNMS(LDK(KP923879532), T3k, T3j);
T3o = VFNMS(LDK(KP198912367), T3c, T3d);
T3e = VFMA(LDK(KP198912367), T3d, T3c);
T4q = VADD(T4n, T4m);
T4o = VSUB(T4m, T4n);
T4k = VADD(T4c, T4f);
T4g = VSUB(T4c, T4f);
}
}
}
}
{
V T6N, T6O, T6P, T6Q;
T6N = VFMA(LDK(KP980785280), T4q, T4p);
STM4(&(ro[31]), T6N, ovs, &(ro[1]));
STN4(&(ro[28]), T6i, T6x, T63, T6N, ovs);
T6O = VFNMS(LDK(KP980785280), T4q, T4p);
STM4(&(ro[15]), T6O, ovs, &(ro[1]));
STN4(&(ro[12]), T6h, T6y, T64, T6O, ovs);
T6P = VFMA(LDK(KP980785280), T4o, T4l);
STM4(&(io[7]), T6P, ovs, &(io[1]));
STN4(&(io[4]), T6l, T6z, T65, T6P, ovs);
T6Q = VFNMS(LDK(KP980785280), T4o, T4l);
STM4(&(io[23]), T6Q, ovs, &(io[1]));
STN4(&(io[20]), T6m, T6A, T66, T6Q, ovs);
{
V T6R, T6S, T6T, T6U;
T6R = VFMA(LDK(KP980785280), T4k, T4j);
STM4(&(io[31]), T6R, ovs, &(io[1]));
STN4(&(io[28]), T6o, T6B, T67, T6R, ovs);
T6S = VFNMS(LDK(KP980785280), T4k, T4j);
STM4(&(io[15]), T6S, ovs, &(io[1]));
STN4(&(io[12]), T6n, T6C, T68, T6S, ovs);
T6T = VFMA(LDK(KP980785280), T4g, T49);
STM4(&(ro[7]), T6T, ovs, &(ro[1]));
STN4(&(ro[4]), T6j, T6D, T61, T6T, ovs);
T6U = VFNMS(LDK(KP980785280), T4g, T49);
STM4(&(ro[23]), T6U, ovs, &(ro[1]));
STN4(&(ro[20]), T6k, T6E, T62, T6U, ovs);
T3h = VFNMS(LDK(KP198912367), T3g, T3f);
T3p = VFMA(LDK(KP198912367), T3f, T3g);
}
}
{
V T3s, T3q, T3i, T3m;
T3s = VADD(T3o, T3p);
T3q = VSUB(T3o, T3p);
T3i = VADD(T3e, T3h);
T3m = VSUB(T3h, T3e);
{
V T6V, T6W, T6X, T6Y;
T6V = VFMA(LDK(KP980785280), T3q, T3n);
STM4(&(ro[9]), T6V, ovs, &(ro[1]));
STN4(&(ro[8]), T6q, T6V, T69, T6F, ovs);
T6W = VFNMS(LDK(KP980785280), T3q, T3n);
STM4(&(ro[25]), T6W, ovs, &(ro[1]));
STN4(&(ro[24]), T6p, T6W, T6a, T6G, ovs);
T6X = VFMA(LDK(KP980785280), T3s, T3r);
STM4(&(io[1]), T6X, ovs, &(io[1]));
STN4(&(io[0]), T6t, T6X, T6d, T6H, ovs);
T6Y = VFNMS(LDK(KP980785280), T3s, T3r);
STM4(&(io[17]), T6Y, ovs, &(io[1]));
STN4(&(io[16]), T6u, T6Y, T6e, T6I, ovs);
{
V T6Z, T70, T71, T72;
T6Z = VFMA(LDK(KP980785280), T3m, T3l);
STM4(&(io[9]), T6Z, ovs, &(io[1]));
STN4(&(io[8]), T6w, T6Z, T6f, T6J, ovs);
T70 = VFNMS(LDK(KP980785280), T3m, T3l);
STM4(&(io[25]), T70, ovs, &(io[1]));
STN4(&(io[24]), T6v, T70, T6g, T6K, ovs);
T71 = VFMA(LDK(KP980785280), T3i, T3b);
STM4(&(ro[1]), T71, ovs, &(ro[1]));
STN4(&(ro[0]), T6r, T71, T6b, T6L, ovs);
T72 = VFNMS(LDK(KP980785280), T3i, T3b);
STM4(&(ro[17]), T72, ovs, &(ro[1]));
STN4(&(ro[16]), T6s, T72, T6c, T6M, ovs);
}
}
}
}
}
static const kdft_desc desc = { 32, "n2sv_32", {236, 0, 136, 0}, &GENUS, 0, 1, 0, 0 };
void X(codelet_n2sv_32) (planner *p) {
X(kdft_register) (p, n2sv_32, &desc);
}
#else /* HAVE_FMA */
/* Generated by: ../../../genfft/gen_notw -simd -compact -variables 4 -pipeline-latency 8 -n 32 -name n2sv_32 -with-ostride 1 -include n2s.h -store-multiple 4 */
/*
* This function contains 372 FP additions, 84 FP multiplications,
* (or, 340 additions, 52 multiplications, 32 fused multiply/add),
* 130 stack variables, 7 constants, and 144 memory accesses
*/
#include "n2s.h"
static void n2sv_32(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs)
{
DVK(KP831469612, +0.831469612302545237078788377617905756738560812);
DVK(KP555570233, +0.555570233019602224742830813948532874374937191);
DVK(KP195090322, +0.195090322016128267848284868477022240927691618);
DVK(KP980785280, +0.980785280403230449126182236134239036973933731);
DVK(KP923879532, +0.923879532511286756128183189396788286822416626);
DVK(KP382683432, +0.382683432365089771728459984030398866761344562);
DVK(KP707106781, +0.707106781186547524400844362104849039284835938);
INT i;
for (i = v; i > 0; i = i - (2 * VL), ri = ri + ((2 * VL) * ivs), ii = ii + ((2 * VL) * ivs), ro = ro + ((2 * VL) * ovs), io = io + ((2 * VL) * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {
V T7, T4r, T4Z, T18, T1z, T3t, T3T, T2T, Te, T1f, T50, T4s, T2W, T3u, T1G;
V T3U, Tm, T1n, T1O, T2Z, T3y, T3X, T4w, T53, Tt, T1u, T1V, T2Y, T3B, T3W;
V T4z, T52, T2t, T3L, T3O, T2K, TR, TY, T5F, T5G, T5H, T5I, T4R, T5j, T2E;
V T3P, T4W, T5k, T2N, T3M, T22, T3E, T3H, T2j, TC, TJ, T5A, T5B, T5C, T5D;
V T4G, T5g, T2d, T3F, T4L, T5h, T2m, T3I;
{
V T3, T1x, T14, T2S, T6, T2R, T17, T1y;
{
V T1, T2, T12, T13;
T1 = LD(&(ri[0]), ivs, &(ri[0]));
T2 = LD(&(ri[WS(is, 16)]), ivs, &(ri[0]));
T3 = VADD(T1, T2);
T1x = VSUB(T1, T2);
T12 = LD(&(ii[0]), ivs, &(ii[0]));
T13 = LD(&(ii[WS(is, 16)]), ivs, &(ii[0]));
T14 = VADD(T12, T13);
T2S = VSUB(T12, T13);
}
{
V T4, T5, T15, T16;
T4 = LD(&(ri[WS(is, 8)]), ivs, &(ri[0]));
T5 = LD(&(ri[WS(is, 24)]), ivs, &(ri[0]));
T6 = VADD(T4, T5);
T2R = VSUB(T4, T5);
T15 = LD(&(ii[WS(is, 8)]), ivs, &(ii[0]));
T16 = LD(&(ii[WS(is, 24)]), ivs, &(ii[0]));
T17 = VADD(T15, T16);
T1y = VSUB(T15, T16);
}
T7 = VADD(T3, T6);
T4r = VSUB(T3, T6);
T4Z = VSUB(T14, T17);
T18 = VADD(T14, T17);
T1z = VSUB(T1x, T1y);
T3t = VADD(T1x, T1y);
T3T = VSUB(T2S, T2R);
T2T = VADD(T2R, T2S);
}
{
V Ta, T1B, T1b, T1A, Td, T1D, T1e, T1E;
{
V T8, T9, T19, T1a;
T8 = LD(&(ri[WS(is, 4)]), ivs, &(ri[0]));
T9 = LD(&(ri[WS(is, 20)]), ivs, &(ri[0]));
Ta = VADD(T8, T9);
T1B = VSUB(T8, T9);
T19 = LD(&(ii[WS(is, 4)]), ivs, &(ii[0]));
T1a = LD(&(ii[WS(is, 20)]), ivs, &(ii[0]));
T1b = VADD(T19, T1a);
T1A = VSUB(T19, T1a);
}
{
V Tb, Tc, T1c, T1d;
Tb = LD(&(ri[WS(is, 28)]), ivs, &(ri[0]));
Tc = LD(&(ri[WS(is, 12)]), ivs, &(ri[0]));
Td = VADD(Tb, Tc);
T1D = VSUB(Tb, Tc);
T1c = LD(&(ii[WS(is, 28)]), ivs, &(ii[0]));
T1d = LD(&(ii[WS(is, 12)]), ivs, &(ii[0]));
T1e = VADD(T1c, T1d);
T1E = VSUB(T1c, T1d);
}
Te = VADD(Ta, Td);
T1f = VADD(T1b, T1e);
T50 = VSUB(Td, Ta);
T4s = VSUB(T1b, T1e);
{
V T2U, T2V, T1C, T1F;
T2U = VSUB(T1D, T1E);
T2V = VADD(T1B, T1A);
T2W = VMUL(LDK(KP707106781), VSUB(T2U, T2V));
T3u = VMUL(LDK(KP707106781), VADD(T2V, T2U));
T1C = VSUB(T1A, T1B);
T1F = VADD(T1D, T1E);
T1G = VMUL(LDK(KP707106781), VSUB(T1C, T1F));
T3U = VMUL(LDK(KP707106781), VADD(T1C, T1F));
}
}
{
V Ti, T1L, T1j, T1J, Tl, T1I, T1m, T1M, T1K, T1N;
{
V Tg, Th, T1h, T1i;
Tg = LD(&(ri[WS(is, 2)]), ivs, &(ri[0]));
Th = LD(&(ri[WS(is, 18)]), ivs, &(ri[0]));
Ti = VADD(Tg, Th);
T1L = VSUB(Tg, Th);
T1h = LD(&(ii[WS(is, 2)]), ivs, &(ii[0]));
T1i = LD(&(ii[WS(is, 18)]), ivs, &(ii[0]));
T1j = VADD(T1h, T1i);
T1J = VSUB(T1h, T1i);
}
{
V Tj, Tk, T1k, T1l;
Tj = LD(&(ri[WS(is, 10)]), ivs, &(ri[0]));
Tk = LD(&(ri[WS(is, 26)]), ivs, &(ri[0]));
Tl = VADD(Tj, Tk);
T1I = VSUB(Tj, Tk);
T1k = LD(&(ii[WS(is, 10)]), ivs, &(ii[0]));
T1l = LD(&(ii[WS(is, 26)]), ivs, &(ii[0]));
T1m = VADD(T1k, T1l);
T1M = VSUB(T1k, T1l);
}
Tm = VADD(Ti, Tl);
T1n = VADD(T1j, T1m);
T1K = VADD(T1I, T1J);
T1N = VSUB(T1L, T1M);
T1O = VFNMS(LDK(KP923879532), T1N, VMUL(LDK(KP382683432), T1K));
T2Z = VFMA(LDK(KP923879532), T1K, VMUL(LDK(KP382683432), T1N));
{
V T3w, T3x, T4u, T4v;
T3w = VSUB(T1J, T1I);
T3x = VADD(T1L, T1M);
T3y = VFNMS(LDK(KP382683432), T3x, VMUL(LDK(KP923879532), T3w));
T3X = VFMA(LDK(KP382683432), T3w, VMUL(LDK(KP923879532), T3x));
T4u = VSUB(T1j, T1m);
T4v = VSUB(Ti, Tl);
T4w = VSUB(T4u, T4v);
T53 = VADD(T4v, T4u);
}
}
{
V Tp, T1S, T1q, T1Q, Ts, T1P, T1t, T1T, T1R, T1U;
{
V Tn, To, T1o, T1p;
Tn = LD(&(ri[WS(is, 30)]), ivs, &(ri[0]));
To = LD(&(ri[WS(is, 14)]), ivs, &(ri[0]));
Tp = VADD(Tn, To);
T1S = VSUB(Tn, To);
T1o = LD(&(ii[WS(is, 30)]), ivs, &(ii[0]));
T1p = LD(&(ii[WS(is, 14)]), ivs, &(ii[0]));
T1q = VADD(T1o, T1p);
T1Q = VSUB(T1o, T1p);
}
{
V Tq, Tr, T1r, T1s;
Tq = LD(&(ri[WS(is, 6)]), ivs, &(ri[0]));
Tr = LD(&(ri[WS(is, 22)]), ivs, &(ri[0]));
Ts = VADD(Tq, Tr);
T1P = VSUB(Tq, Tr);
T1r = LD(&(ii[WS(is, 6)]), ivs, &(ii[0]));
T1s = LD(&(ii[WS(is, 22)]), ivs, &(ii[0]));
T1t = VADD(T1r, T1s);
T1T = VSUB(T1r, T1s);
}
Tt = VADD(Tp, Ts);
T1u = VADD(T1q, T1t);
T1R = VADD(T1P, T1Q);
T1U = VSUB(T1S, T1T);
T1V = VFMA(LDK(KP382683432), T1R, VMUL(LDK(KP923879532), T1U));
T2Y = VFNMS(LDK(KP923879532), T1R, VMUL(LDK(KP382683432), T1U));
{
V T3z, T3A, T4x, T4y;
T3z = VSUB(T1Q, T1P);
T3A = VADD(T1S, T1T);
T3B = VFMA(LDK(KP923879532), T3z, VMUL(LDK(KP382683432), T3A));
T3W = VFNMS(LDK(KP382683432), T3z, VMUL(LDK(KP923879532), T3A));
T4x = VSUB(Tp, Ts);
T4y = VSUB(T1q, T1t);
T4z = VADD(T4x, T4y);
T52 = VSUB(T4x, T4y);
}
}
{
V TN, T2p, T2J, T4S, TQ, T2G, T2s, T4T, TU, T2x, T2w, T4O, TX, T2z, T2C;
V T4P;
{
V TL, TM, T2H, T2I;
TL = LD(&(ri[WS(is, 31)]), ivs, &(ri[WS(is, 1)]));
TM = LD(&(ri[WS(is, 15)]), ivs, &(ri[WS(is, 1)]));
TN = VADD(TL, TM);
T2p = VSUB(TL, TM);
T2H = LD(&(ii[WS(is, 31)]), ivs, &(ii[WS(is, 1)]));
T2I = LD(&(ii[WS(is, 15)]), ivs, &(ii[WS(is, 1)]));
T2J = VSUB(T2H, T2I);
T4S = VADD(T2H, T2I);
}
{
V TO, TP, T2q, T2r;
TO = LD(&(ri[WS(is, 7)]), ivs, &(ri[WS(is, 1)]));
TP = LD(&(ri[WS(is, 23)]), ivs, &(ri[WS(is, 1)]));
TQ = VADD(TO, TP);
T2G = VSUB(TO, TP);
T2q = LD(&(ii[WS(is, 7)]), ivs, &(ii[WS(is, 1)]));
T2r = LD(&(ii[WS(is, 23)]), ivs, &(ii[WS(is, 1)]));
T2s = VSUB(T2q, T2r);
T4T = VADD(T2q, T2r);
}
{
V TS, TT, T2u, T2v;
TS = LD(&(ri[WS(is, 3)]), ivs, &(ri[WS(is, 1)]));
TT = LD(&(ri[WS(is, 19)]), ivs, &(ri[WS(is, 1)]));
TU = VADD(TS, TT);
T2x = VSUB(TS, TT);
T2u = LD(&(ii[WS(is, 3)]), ivs, &(ii[WS(is, 1)]));
T2v = LD(&(ii[WS(is, 19)]), ivs, &(ii[WS(is, 1)]));
T2w = VSUB(T2u, T2v);
T4O = VADD(T2u, T2v);
}
{
V TV, TW, T2A, T2B;
TV = LD(&(ri[WS(is, 27)]), ivs, &(ri[WS(is, 1)]));
TW = LD(&(ri[WS(is, 11)]), ivs, &(ri[WS(is, 1)]));
TX = VADD(TV, TW);
T2z = VSUB(TV, TW);
T2A = LD(&(ii[WS(is, 27)]), ivs, &(ii[WS(is, 1)]));
T2B = LD(&(ii[WS(is, 11)]), ivs, &(ii[WS(is, 1)]));
T2C = VSUB(T2A, T2B);
T4P = VADD(T2A, T2B);
}
T2t = VSUB(T2p, T2s);
T3L = VADD(T2p, T2s);
T3O = VSUB(T2J, T2G);
T2K = VADD(T2G, T2J);
TR = VADD(TN, TQ);
TY = VADD(TU, TX);
T5F = VSUB(TR, TY);
{
V T4N, T4Q, T2y, T2D;
T5G = VADD(T4S, T4T);
T5H = VADD(T4O, T4P);
T5I = VSUB(T5G, T5H);
T4N = VSUB(TN, TQ);
T4Q = VSUB(T4O, T4P);
T4R = VSUB(T4N, T4Q);
T5j = VADD(T4N, T4Q);
T2y = VSUB(T2w, T2x);
T2D = VADD(T2z, T2C);
T2E = VMUL(LDK(KP707106781), VSUB(T2y, T2D));
T3P = VMUL(LDK(KP707106781), VADD(T2y, T2D));
{
V T4U, T4V, T2L, T2M;
T4U = VSUB(T4S, T4T);
T4V = VSUB(TX, TU);
T4W = VSUB(T4U, T4V);
T5k = VADD(T4V, T4U);
T2L = VSUB(T2z, T2C);
T2M = VADD(T2x, T2w);
T2N = VMUL(LDK(KP707106781), VSUB(T2L, T2M));
T3M = VMUL(LDK(KP707106781), VADD(T2M, T2L));
}
}
}
{
V Ty, T2f, T21, T4C, TB, T1Y, T2i, T4D, TF, T28, T2b, T4I, TI, T23, T26;
V T4J;
{
V Tw, Tx, T1Z, T20;
Tw = LD(&(ri[WS(is, 1)]), ivs, &(ri[WS(is, 1)]));
Tx = LD(&(ri[WS(is, 17)]), ivs, &(ri[WS(is, 1)]));
Ty = VADD(Tw, Tx);
T2f = VSUB(Tw, Tx);
T1Z = LD(&(ii[WS(is, 1)]), ivs, &(ii[WS(is, 1)]));
T20 = LD(&(ii[WS(is, 17)]), ivs, &(ii[WS(is, 1)]));
T21 = VSUB(T1Z, T20);
T4C = VADD(T1Z, T20);
}
{
V Tz, TA, T2g, T2h;
Tz = LD(&(ri[WS(is, 9)]), ivs, &(ri[WS(is, 1)]));
TA = LD(&(ri[WS(is, 25)]), ivs, &(ri[WS(is, 1)]));
TB = VADD(Tz, TA);
T1Y = VSUB(Tz, TA);
T2g = LD(&(ii[WS(is, 9)]), ivs, &(ii[WS(is, 1)]));
T2h = LD(&(ii[WS(is, 25)]), ivs, &(ii[WS(is, 1)]));
T2i = VSUB(T2g, T2h);
T4D = VADD(T2g, T2h);
}
{
V TD, TE, T29, T2a;
TD = LD(&(ri[WS(is, 5)]), ivs, &(ri[WS(is, 1)]));
TE = LD(&(ri[WS(is, 21)]), ivs, &(ri[WS(is, 1)]));
TF = VADD(TD, TE);
T28 = VSUB(TD, TE);
T29 = LD(&(ii[WS(is, 5)]), ivs, &(ii[WS(is, 1)]));
T2a = LD(&(ii[WS(is, 21)]), ivs, &(ii[WS(is, 1)]));
T2b = VSUB(T29, T2a);
T4I = VADD(T29, T2a);
}
{
V TG, TH, T24, T25;
TG = LD(&(ri[WS(is, 29)]), ivs, &(ri[WS(is, 1)]));
TH = LD(&(ri[WS(is, 13)]), ivs, &(ri[WS(is, 1)]));
TI = VADD(TG, TH);
T23 = VSUB(TG, TH);
T24 = LD(&(ii[WS(is, 29)]), ivs, &(ii[WS(is, 1)]));
T25 = LD(&(ii[WS(is, 13)]), ivs, &(ii[WS(is, 1)]));
T26 = VSUB(T24, T25);
T4J = VADD(T24, T25);
}
T22 = VADD(T1Y, T21);
T3E = VADD(T2f, T2i);
T3H = VSUB(T21, T1Y);
T2j = VSUB(T2f, T2i);
TC = VADD(Ty, TB);
TJ = VADD(TF, TI);
T5A = VSUB(TC, TJ);
{
V T4E, T4F, T27, T2c;
T5B = VADD(T4C, T4D);
T5C = VADD(T4I, T4J);
T5D = VSUB(T5B, T5C);
T4E = VSUB(T4C, T4D);
T4F = VSUB(TI, TF);
T4G = VSUB(T4E, T4F);
T5g = VADD(T4F, T4E);
T27 = VSUB(T23, T26);
T2c = VADD(T28, T2b);
T2d = VMUL(LDK(KP707106781), VSUB(T27, T2c));
T3F = VMUL(LDK(KP707106781), VADD(T2c, T27));
{
V T4H, T4K, T2k, T2l;
T4H = VSUB(Ty, TB);
T4K = VSUB(T4I, T4J);
T4L = VSUB(T4H, T4K);
T5h = VADD(T4H, T4K);
T2k = VSUB(T2b, T28);
T2l = VADD(T23, T26);
T2m = VMUL(LDK(KP707106781), VSUB(T2k, T2l));
T3I = VMUL(LDK(KP707106781), VADD(T2k, T2l));
}
}
}
{
V T61, T62, T63, T64, T65, T66, T67, T68, T69, T6a, T6b, T6c, T6d, T6e, T6f;
V T6g, T6h, T6i, T6j, T6k, T6l, T6m, T6n, T6o, T6p, T6q, T6r, T6s, T6t, T6u;
V T6v, T6w;
{
V T4B, T57, T5a, T5c, T4Y, T56, T55, T5b;
{
V T4t, T4A, T58, T59;
T4t = VSUB(T4r, T4s);
T4A = VMUL(LDK(KP707106781), VSUB(T4w, T4z));
T4B = VADD(T4t, T4A);
T57 = VSUB(T4t, T4A);
T58 = VFNMS(LDK(KP923879532), T4L, VMUL(LDK(KP382683432), T4G));
T59 = VFMA(LDK(KP382683432), T4W, VMUL(LDK(KP923879532), T4R));
T5a = VSUB(T58, T59);
T5c = VADD(T58, T59);
}
{
V T4M, T4X, T51, T54;
T4M = VFMA(LDK(KP923879532), T4G, VMUL(LDK(KP382683432), T4L));
T4X = VFNMS(LDK(KP923879532), T4W, VMUL(LDK(KP382683432), T4R));
T4Y = VADD(T4M, T4X);
T56 = VSUB(T4X, T4M);
T51 = VSUB(T4Z, T50);
T54 = VMUL(LDK(KP707106781), VSUB(T52, T53));
T55 = VSUB(T51, T54);
T5b = VADD(T51, T54);
}
T61 = VSUB(T4B, T4Y);
STM4(&(ro[22]), T61, ovs, &(ro[0]));
T62 = VSUB(T5b, T5c);
STM4(&(io[22]), T62, ovs, &(io[0]));
T63 = VADD(T4B, T4Y);
STM4(&(ro[6]), T63, ovs, &(ro[0]));
T64 = VADD(T5b, T5c);
STM4(&(io[6]), T64, ovs, &(io[0]));
T65 = VSUB(T55, T56);
STM4(&(io[30]), T65, ovs, &(io[0]));
T66 = VSUB(T57, T5a);
STM4(&(ro[30]), T66, ovs, &(ro[0]));
T67 = VADD(T55, T56);
STM4(&(io[14]), T67, ovs, &(io[0]));
T68 = VADD(T57, T5a);
STM4(&(ro[14]), T68, ovs, &(ro[0]));
}
{
V T5f, T5r, T5u, T5w, T5m, T5q, T5p, T5v;
{
V T5d, T5e, T5s, T5t;
T5d = VADD(T4r, T4s);
T5e = VMUL(LDK(KP707106781), VADD(T53, T52));
T5f = VADD(T5d, T5e);
T5r = VSUB(T5d, T5e);
T5s = VFNMS(LDK(KP382683432), T5h, VMUL(LDK(KP923879532), T5g));
T5t = VFMA(LDK(KP923879532), T5k, VMUL(LDK(KP382683432), T5j));
T5u = VSUB(T5s, T5t);
T5w = VADD(T5s, T5t);
}
{
V T5i, T5l, T5n, T5o;
T5i = VFMA(LDK(KP382683432), T5g, VMUL(LDK(KP923879532), T5h));
T5l = VFNMS(LDK(KP382683432), T5k, VMUL(LDK(KP923879532), T5j));
T5m = VADD(T5i, T5l);
T5q = VSUB(T5l, T5i);
T5n = VADD(T50, T4Z);
T5o = VMUL(LDK(KP707106781), VADD(T4w, T4z));
T5p = VSUB(T5n, T5o);
T5v = VADD(T5n, T5o);
}
T69 = VSUB(T5f, T5m);
STM4(&(ro[18]), T69, ovs, &(ro[0]));
T6a = VSUB(T5v, T5w);
STM4(&(io[18]), T6a, ovs, &(io[0]));
T6b = VADD(T5f, T5m);
STM4(&(ro[2]), T6b, ovs, &(ro[0]));
T6c = VADD(T5v, T5w);
STM4(&(io[2]), T6c, ovs, &(io[0]));
T6d = VSUB(T5p, T5q);
STM4(&(io[26]), T6d, ovs, &(io[0]));
T6e = VSUB(T5r, T5u);
STM4(&(ro[26]), T6e, ovs, &(ro[0]));
T6f = VADD(T5p, T5q);
STM4(&(io[10]), T6f, ovs, &(io[0]));
T6g = VADD(T5r, T5u);
STM4(&(ro[10]), T6g, ovs, &(ro[0]));
}
{
V T5z, T5P, T5S, T5U, T5K, T5O, T5N, T5T;
{
V T5x, T5y, T5Q, T5R;
T5x = VSUB(T7, Te);
T5y = VSUB(T1n, T1u);
T5z = VADD(T5x, T5y);
T5P = VSUB(T5x, T5y);
T5Q = VSUB(T5D, T5A);
T5R = VADD(T5F, T5I);
T5S = VMUL(LDK(KP707106781), VSUB(T5Q, T5R));
T5U = VMUL(LDK(KP707106781), VADD(T5Q, T5R));
}
{
V T5E, T5J, T5L, T5M;
T5E = VADD(T5A, T5D);
T5J = VSUB(T5F, T5I);
T5K = VMUL(LDK(KP707106781), VADD(T5E, T5J));
T5O = VMUL(LDK(KP707106781), VSUB(T5J, T5E));
T5L = VSUB(T18, T1f);
T5M = VSUB(Tt, Tm);
T5N = VSUB(T5L, T5M);
T5T = VADD(T5M, T5L);
}
T6h = VSUB(T5z, T5K);
STM4(&(ro[20]), T6h, ovs, &(ro[0]));
T6i = VSUB(T5T, T5U);
STM4(&(io[20]), T6i, ovs, &(io[0]));
T6j = VADD(T5z, T5K);
STM4(&(ro[4]), T6j, ovs, &(ro[0]));
T6k = VADD(T5T, T5U);
STM4(&(io[4]), T6k, ovs, &(io[0]));
T6l = VSUB(T5N, T5O);
STM4(&(io[28]), T6l, ovs, &(io[0]));
T6m = VSUB(T5P, T5S);
STM4(&(ro[28]), T6m, ovs, &(ro[0]));
T6n = VADD(T5N, T5O);
STM4(&(io[12]), T6n, ovs, &(io[0]));
T6o = VADD(T5P, T5S);
STM4(&(ro[12]), T6o, ovs, &(ro[0]));
}
{
V Tv, T5V, T5Y, T60, T10, T11, T1w, T5Z;
{
V Tf, Tu, T5W, T5X;
Tf = VADD(T7, Te);
Tu = VADD(Tm, Tt);
Tv = VADD(Tf, Tu);
T5V = VSUB(Tf, Tu);
T5W = VADD(T5B, T5C);
T5X = VADD(T5G, T5H);
T5Y = VSUB(T5W, T5X);
T60 = VADD(T5W, T5X);
}
{
V TK, TZ, T1g, T1v;
TK = VADD(TC, TJ);
TZ = VADD(TR, TY);
T10 = VADD(TK, TZ);
T11 = VSUB(TZ, TK);
T1g = VADD(T18, T1f);
T1v = VADD(T1n, T1u);
T1w = VSUB(T1g, T1v);
T5Z = VADD(T1g, T1v);
}
T6p = VSUB(Tv, T10);
STM4(&(ro[16]), T6p, ovs, &(ro[0]));
T6q = VSUB(T5Z, T60);
STM4(&(io[16]), T6q, ovs, &(io[0]));
T6r = VADD(Tv, T10);
STM4(&(ro[0]), T6r, ovs, &(ro[0]));
T6s = VADD(T5Z, T60);
STM4(&(io[0]), T6s, ovs, &(io[0]));
T6t = VADD(T11, T1w);
STM4(&(io[8]), T6t, ovs, &(io[0]));
T6u = VADD(T5V, T5Y);
STM4(&(ro[8]), T6u, ovs, &(ro[0]));
T6v = VSUB(T1w, T11);
STM4(&(io[24]), T6v, ovs, &(io[0]));
T6w = VSUB(T5V, T5Y);
STM4(&(ro[24]), T6w, ovs, &(ro[0]));
}
{
V T6x, T6y, T6z, T6A, T6B, T6C, T6D, T6E;
{
V T1X, T33, T31, T37, T2o, T34, T2P, T35;
{
V T1H, T1W, T2X, T30;
T1H = VSUB(T1z, T1G);
T1W = VSUB(T1O, T1V);
T1X = VADD(T1H, T1W);
T33 = VSUB(T1H, T1W);
T2X = VSUB(T2T, T2W);
T30 = VSUB(T2Y, T2Z);
T31 = VSUB(T2X, T30);
T37 = VADD(T2X, T30);
}
{
V T2e, T2n, T2F, T2O;
T2e = VSUB(T22, T2d);
T2n = VSUB(T2j, T2m);
T2o = VFMA(LDK(KP980785280), T2e, VMUL(LDK(KP195090322), T2n));
T34 = VFNMS(LDK(KP980785280), T2n, VMUL(LDK(KP195090322), T2e));
T2F = VSUB(T2t, T2E);
T2O = VSUB(T2K, T2N);
T2P = VFNMS(LDK(KP980785280), T2O, VMUL(LDK(KP195090322), T2F));
T35 = VFMA(LDK(KP195090322), T2O, VMUL(LDK(KP980785280), T2F));
}
{
V T2Q, T38, T32, T36;
T2Q = VADD(T2o, T2P);
T6x = VSUB(T1X, T2Q);
STM4(&(ro[23]), T6x, ovs, &(ro[1]));
T6y = VADD(T1X, T2Q);
STM4(&(ro[7]), T6y, ovs, &(ro[1]));
T38 = VADD(T34, T35);
T6z = VSUB(T37, T38);
STM4(&(io[23]), T6z, ovs, &(io[1]));
T6A = VADD(T37, T38);
STM4(&(io[7]), T6A, ovs, &(io[1]));
T32 = VSUB(T2P, T2o);
T6B = VSUB(T31, T32);
STM4(&(io[31]), T6B, ovs, &(io[1]));
T6C = VADD(T31, T32);
STM4(&(io[15]), T6C, ovs, &(io[1]));
T36 = VSUB(T34, T35);
T6D = VSUB(T33, T36);
STM4(&(ro[31]), T6D, ovs, &(ro[1]));
T6E = VADD(T33, T36);
STM4(&(ro[15]), T6E, ovs, &(ro[1]));
}
}
{
V T3D, T41, T3Z, T45, T3K, T42, T3R, T43;
{
V T3v, T3C, T3V, T3Y;
T3v = VSUB(T3t, T3u);
T3C = VSUB(T3y, T3B);
T3D = VADD(T3v, T3C);
T41 = VSUB(T3v, T3C);
T3V = VSUB(T3T, T3U);
T3Y = VSUB(T3W, T3X);
T3Z = VSUB(T3V, T3Y);
T45 = VADD(T3V, T3Y);
}
{
V T3G, T3J, T3N, T3Q;
T3G = VSUB(T3E, T3F);
T3J = VSUB(T3H, T3I);
T3K = VFMA(LDK(KP555570233), T3G, VMUL(LDK(KP831469612), T3J));
T42 = VFNMS(LDK(KP831469612), T3G, VMUL(LDK(KP555570233), T3J));
T3N = VSUB(T3L, T3M);
T3Q = VSUB(T3O, T3P);
T3R = VFNMS(LDK(KP831469612), T3Q, VMUL(LDK(KP555570233), T3N));
T43 = VFMA(LDK(KP831469612), T3N, VMUL(LDK(KP555570233), T3Q));
}
{
V T3S, T6F, T6G, T46, T6H, T6I;
T3S = VADD(T3K, T3R);
T6F = VSUB(T3D, T3S);
STM4(&(ro[21]), T6F, ovs, &(ro[1]));
STN4(&(ro[20]), T6h, T6F, T61, T6x, ovs);
T6G = VADD(T3D, T3S);
STM4(&(ro[5]), T6G, ovs, &(ro[1]));
STN4(&(ro[4]), T6j, T6G, T63, T6y, ovs);
T46 = VADD(T42, T43);
T6H = VSUB(T45, T46);
STM4(&(io[21]), T6H, ovs, &(io[1]));
STN4(&(io[20]), T6i, T6H, T62, T6z, ovs);
T6I = VADD(T45, T46);
STM4(&(io[5]), T6I, ovs, &(io[1]));
STN4(&(io[4]), T6k, T6I, T64, T6A, ovs);
}
{
V T40, T6J, T6K, T44, T6L, T6M;
T40 = VSUB(T3R, T3K);
T6J = VSUB(T3Z, T40);
STM4(&(io[29]), T6J, ovs, &(io[1]));
STN4(&(io[28]), T6l, T6J, T65, T6B, ovs);
T6K = VADD(T3Z, T40);
STM4(&(io[13]), T6K, ovs, &(io[1]));
STN4(&(io[12]), T6n, T6K, T67, T6C, ovs);
T44 = VSUB(T42, T43);
T6L = VSUB(T41, T44);
STM4(&(ro[29]), T6L, ovs, &(ro[1]));
STN4(&(ro[28]), T6m, T6L, T66, T6D, ovs);
T6M = VADD(T41, T44);
STM4(&(ro[13]), T6M, ovs, &(ro[1]));
STN4(&(ro[12]), T6o, T6M, T68, T6E, ovs);
}
}
}
{
V T6N, T6O, T6P, T6Q, T6R, T6S, T6T, T6U;
{
V T49, T4l, T4j, T4p, T4c, T4m, T4f, T4n;
{
V T47, T48, T4h, T4i;
T47 = VADD(T3t, T3u);
T48 = VADD(T3X, T3W);
T49 = VADD(T47, T48);
T4l = VSUB(T47, T48);
T4h = VADD(T3T, T3U);
T4i = VADD(T3y, T3B);
T4j = VSUB(T4h, T4i);
T4p = VADD(T4h, T4i);
}
{
V T4a, T4b, T4d, T4e;
T4a = VADD(T3E, T3F);
T4b = VADD(T3H, T3I);
T4c = VFMA(LDK(KP980785280), T4a, VMUL(LDK(KP195090322), T4b));
T4m = VFNMS(LDK(KP195090322), T4a, VMUL(LDK(KP980785280), T4b));
T4d = VADD(T3L, T3M);
T4e = VADD(T3O, T3P);
T4f = VFNMS(LDK(KP195090322), T4e, VMUL(LDK(KP980785280), T4d));
T4n = VFMA(LDK(KP195090322), T4d, VMUL(LDK(KP980785280), T4e));
}
{
V T4g, T4q, T4k, T4o;
T4g = VADD(T4c, T4f);
T6N = VSUB(T49, T4g);
STM4(&(ro[17]), T6N, ovs, &(ro[1]));
T6O = VADD(T49, T4g);
STM4(&(ro[1]), T6O, ovs, &(ro[1]));
T4q = VADD(T4m, T4n);
T6P = VSUB(T4p, T4q);
STM4(&(io[17]), T6P, ovs, &(io[1]));
T6Q = VADD(T4p, T4q);
STM4(&(io[1]), T6Q, ovs, &(io[1]));
T4k = VSUB(T4f, T4c);
T6R = VSUB(T4j, T4k);
STM4(&(io[25]), T6R, ovs, &(io[1]));
T6S = VADD(T4j, T4k);
STM4(&(io[9]), T6S, ovs, &(io[1]));
T4o = VSUB(T4m, T4n);
T6T = VSUB(T4l, T4o);
STM4(&(ro[25]), T6T, ovs, &(ro[1]));
T6U = VADD(T4l, T4o);
STM4(&(ro[9]), T6U, ovs, &(ro[1]));
}
}
{
V T3b, T3n, T3l, T3r, T3e, T3o, T3h, T3p;
{
V T39, T3a, T3j, T3k;
T39 = VADD(T1z, T1G);
T3a = VADD(T2Z, T2Y);
T3b = VADD(T39, T3a);
T3n = VSUB(T39, T3a);
T3j = VADD(T2T, T2W);
T3k = VADD(T1O, T1V);
T3l = VSUB(T3j, T3k);
T3r = VADD(T3j, T3k);
}
{
V T3c, T3d, T3f, T3g;
T3c = VADD(T22, T2d);
T3d = VADD(T2j, T2m);
T3e = VFMA(LDK(KP555570233), T3c, VMUL(LDK(KP831469612), T3d));
T3o = VFNMS(LDK(KP555570233), T3d, VMUL(LDK(KP831469612), T3c));
T3f = VADD(T2t, T2E);
T3g = VADD(T2K, T2N);
T3h = VFNMS(LDK(KP555570233), T3g, VMUL(LDK(KP831469612), T3f));
T3p = VFMA(LDK(KP831469612), T3g, VMUL(LDK(KP555570233), T3f));
}
{
V T3i, T6V, T6W, T3s, T6X, T6Y;
T3i = VADD(T3e, T3h);
T6V = VSUB(T3b, T3i);
STM4(&(ro[19]), T6V, ovs, &(ro[1]));
STN4(&(ro[16]), T6p, T6N, T69, T6V, ovs);
T6W = VADD(T3b, T3i);
STM4(&(ro[3]), T6W, ovs, &(ro[1]));
STN4(&(ro[0]), T6r, T6O, T6b, T6W, ovs);
T3s = VADD(T3o, T3p);
T6X = VSUB(T3r, T3s);
STM4(&(io[19]), T6X, ovs, &(io[1]));
STN4(&(io[16]), T6q, T6P, T6a, T6X, ovs);
T6Y = VADD(T3r, T3s);
STM4(&(io[3]), T6Y, ovs, &(io[1]));
STN4(&(io[0]), T6s, T6Q, T6c, T6Y, ovs);
}
{
V T3m, T6Z, T70, T3q, T71, T72;
T3m = VSUB(T3h, T3e);
T6Z = VSUB(T3l, T3m);
STM4(&(io[27]), T6Z, ovs, &(io[1]));
STN4(&(io[24]), T6v, T6R, T6d, T6Z, ovs);
T70 = VADD(T3l, T3m);
STM4(&(io[11]), T70, ovs, &(io[1]));
STN4(&(io[8]), T6t, T6S, T6f, T70, ovs);
T3q = VSUB(T3o, T3p);
T71 = VSUB(T3n, T3q);
STM4(&(ro[27]), T71, ovs, &(ro[1]));
STN4(&(ro[24]), T6w, T6T, T6e, T71, ovs);
T72 = VADD(T3n, T3q);
STM4(&(ro[11]), T72, ovs, &(ro[1]));
STN4(&(ro[8]), T6u, T6U, T6g, T72, ovs);
}
}
}
}
}
}
static const kdft_desc desc = { 32, "n2sv_32", {340, 52, 32, 0}, &GENUS, 0, 1, 0, 0 };
void X(codelet_n2sv_32) (planner *p) {
X(kdft_register) (p, n2sv_32, &desc);
}
#endif /* HAVE_FMA */
| gpl-2.0 |
choushane/MaRa-a1a0a5aNaL | package/beceemcscm/Makefile | 1653 | #
# Copyright (C) 2006 OpenWrt.org
#
# This is free software, licensed under the GNU General Public License v2.
# See /LICENSE for more information.
#
include $(TOPDIR)/rules.mk
PKG_NAME:=CSCM
PKG_VERSION:=v1.1.6.0_source
PKG_RELEASE:=1
PKG_SOURCE:=$(PKG_NAME)_$(PKG_VERSION).tar.bz2
PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_NAME)
include $(INCLUDE_DIR)/package.mk
define Package/CSCM
SECTION:=net
CATEGORY:=Network
DEPENDS:=+libopenssl +beceemwimax
TITLE:=Beceem CSCM crypto application
URL:=http://pptpclient.sourceforge.net/
endef
define Package/CSCM/description
Beceem WiMAX USB dangle driver
endef
EZP_CFLAGS+= -I$(TOPDIR)/package/ezp-nvram/src -I$(TOPDIR)/package/ezp-nvram/include
PLATFORM:=pc_linux
CM_DIR:=$(PKG_BUILD_DIR)
TARGET_BIN_DIR:=$(CM_DIR)/bin_$(PLATFORM)/bin
TARGET_OBJ_DIR:=$(CM_DIR)/bin_$(PLATFORM)/obj
DEBUG:=1
CROSS_COMPILE:=$(TARGET_CROSS)
CROSS_TOOLCHAIN_DIR:=$(TOOLCHAIN_DIR)
CFLAGS+=" $(TARGET_CFLAGS) $(EZP_CFLAGS) -fPIC "
LDFLAGS+=" -L$(PKG_BUILD_DIR)/wpa_supplicant/ "
define Build/Compile
$(call Build/Compile/Default, \
CROSS_COMPILE=$(CROSS_COMPILE) CROSS_TOOLCHAIN_DIR=$(CROSS_TOOLCHAIN_DIR) \
PLATFORM=$(PLATFORM) CM_DIR=$(CM_DIR) TARGET_BIN_DIR=$(TARGET_BIN_DIR) TARGET_OBJ_DIR=$(TARGET_OBJ_DIR) DEBUG=$(DEBUG) \
)
endef
define Package/CSCM/install
$(INSTALL_DIR) $(1)/usr/bin
$(INSTALL_DIR) $(1)/usr/lib
$(INSTALL_BIN) $(PKG_BUILD_DIR)/wpa_supplicant/libeap_supplicant.so $(1)/usr/lib/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/BeceemEAPSupplicant/BeceemEngine/libengine_beceem.so $(1)/usr/lib/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/bin_pc_linux/bin/* $(1)/usr/bin/
endef
$(eval $(call BuildPackage,CSCM))
| gpl-2.0 |
ruslan2k/database-editor | public_html/vendors/fatfree/lib/api/functions_a.html | 2697 | <!-- HTML header for doxygen 1.8.5-->
<!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">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.7"/>
<title>Fat-Free Framework: Class Members</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
<tbody>
<tr style="height: 56px;">
<td style="padding-left: 0.5em;">
<div id="projectname">Fat-Free Framework
 <span id="projectnumber">3.3.0</span>
 <span class="menu"><a href="index.html">Overview</a> <a href="annotated.html">Class List</a> <a href="hierarchy.html">Hierarchy</a></span>
</div>
</td>
</tr>
</tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.8.7 -->
</div><!-- top -->
<div class="contents">
<div class="textblock">Here is a list of all documented class members with links to the class documentation for each member:</div>
<h3><a class="anchor" id="index_a"></a>- a -</h3><ul>
<li>acceptable()
: <a class="el" href="classWeb.html#a49406ad63450dc1cb5bb23ff3547c39f">Web</a>
</li>
<li>aftererase()
: <a class="el" href="classDB_1_1Cursor.html#a14ab0b84738dc86db5676343c82b5242">DB\Cursor</a>
</li>
<li>afterinsert()
: <a class="el" href="classDB_1_1Cursor.html#a0c89cfe8faf7b55122ada1a4f9d1e9ca">DB\Cursor</a>
</li>
<li>afterupdate()
: <a class="el" href="classDB_1_1Cursor.html#a943a1cacfc57b79bc24bdda194525b21">DB\Cursor</a>
</li>
<li>agent()
: <a class="el" href="classDB_1_1Jig_1_1Session.html#a1fc39525e3544bb447ca1a6548caea4f">DB\Jig\Session</a>
, <a class="el" href="classDB_1_1Mongo_1_1Session.html#a05560509593dcd8b74e261728ffa6cb5">DB\Mongo\Session</a>
, <a class="el" href="classDB_1_1SQL_1_1Session.html#ad95549104177547e8b141e70cc86275a">DB\SQL\Session</a>
, <a class="el" href="classSession.html#ac6807a612c0fc952cb52fbb80eb488f0">Session</a>
</li>
<li>attach()
: <a class="el" href="classSMTP.html#aaceffc74173cd705596cf0f8068132df">SMTP</a>
</li>
<li>auth()
: <a class="el" href="classWeb_1_1OpenID.html#aaecc8347b4526e4e5c09ce4043d4cb3b">Web\OpenID</a>
</li>
<li>autoload()
: <a class="el" href="classBase.html#aacc3665d0616d46b64f63d12220bacfd">Base</a>
</li>
</ul>
</div><!-- contents -->
| gpl-2.0 |
shichao-an/linux-2.6.11.12 | drivers/acpi/dispatcher/dsutils.c | 19371 | /*******************************************************************************
*
* Module Name: dsutils - Dispatcher utilities
*
******************************************************************************/
/*
* Copyright (C) 2000 - 2005, R. Byron Moore
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#include <acpi/acparser.h>
#include <acpi/amlcode.h>
#include <acpi/acdispat.h>
#include <acpi/acinterp.h>
#include <acpi/acnamesp.h>
#include <acpi/acdebug.h>
#define _COMPONENT ACPI_DISPATCHER
ACPI_MODULE_NAME ("dsutils")
#ifndef ACPI_NO_METHOD_EXECUTION
/*******************************************************************************
*
* FUNCTION: acpi_ds_is_result_used
*
* PARAMETERS: Op - Current Op
* walk_state - Current State
*
* RETURN: TRUE if result is used, FALSE otherwise
*
* DESCRIPTION: Check if a result object will be used by the parent
*
******************************************************************************/
u8
acpi_ds_is_result_used (
union acpi_parse_object *op,
struct acpi_walk_state *walk_state)
{
const struct acpi_opcode_info *parent_info;
ACPI_FUNCTION_TRACE_PTR ("ds_is_result_used", op);
/* Must have both an Op and a Result Object */
if (!op) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Op\n"));
return_VALUE (TRUE);
}
/*
* If there is no parent, or the parent is a scope_op, we are executing
* at the method level. An executing method typically has no parent,
* since each method is parsed separately. A method invoked externally
* via execute_control_method has a scope_op as the parent.
*/
if ((!op->common.parent) ||
(op->common.parent->common.aml_opcode == AML_SCOPE_OP)) {
/*
* If this is the last statement in the method, we know it is not a
* Return() operator (would not come here.) The following code is the
* optional support for a so-called "implicit return". Some AML code
* assumes that the last value of the method is "implicitly" returned
* to the caller. Just save the last result as the return value.
* NOTE: this is optional because the ASL language does not actually
* support this behavior.
*/
if ((acpi_gbl_enable_interpreter_slack) &&
(walk_state->parser_state.aml >= walk_state->parser_state.aml_end)) {
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"Result of [%s] will be implicitly returned\n",
acpi_ps_get_opcode_name (op->common.aml_opcode)));
/* Use the top of the result stack as the implicit return value */
walk_state->return_desc = walk_state->results->results.obj_desc[0];
return_VALUE (TRUE);
}
/* No parent, the return value cannot possibly be used */
return_VALUE (FALSE);
}
/* Get info on the parent. The root_op is AML_SCOPE */
parent_info = acpi_ps_get_opcode_info (op->common.parent->common.aml_opcode);
if (parent_info->class == AML_CLASS_UNKNOWN) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown parent opcode. Op=%p\n", op));
return_VALUE (FALSE);
}
/*
* Decide what to do with the result based on the parent. If
* the parent opcode will not use the result, delete the object.
* Otherwise leave it as is, it will be deleted when it is used
* as an operand later.
*/
switch (parent_info->class) {
case AML_CLASS_CONTROL:
switch (op->common.parent->common.aml_opcode) {
case AML_RETURN_OP:
/* Never delete the return value associated with a return opcode */
goto result_used;
case AML_IF_OP:
case AML_WHILE_OP:
/*
* If we are executing the predicate AND this is the predicate op,
* we will use the return value
*/
if ((walk_state->control_state->common.state == ACPI_CONTROL_PREDICATE_EXECUTING) &&
(walk_state->control_state->control.predicate_op == op)) {
goto result_used;
}
break;
default:
/* Ignore other control opcodes */
break;
}
/* The general control opcode returns no result */
goto result_not_used;
case AML_CLASS_CREATE:
/*
* These opcodes allow term_arg(s) as operands and therefore
* the operands can be method calls. The result is used.
*/
goto result_used;
case AML_CLASS_NAMED_OBJECT:
if ((op->common.parent->common.aml_opcode == AML_REGION_OP) ||
(op->common.parent->common.aml_opcode == AML_DATA_REGION_OP) ||
(op->common.parent->common.aml_opcode == AML_PACKAGE_OP) ||
(op->common.parent->common.aml_opcode == AML_VAR_PACKAGE_OP) ||
(op->common.parent->common.aml_opcode == AML_BUFFER_OP) ||
(op->common.parent->common.aml_opcode == AML_INT_EVAL_SUBTREE_OP)) {
/*
* These opcodes allow term_arg(s) as operands and therefore
* the operands can be method calls. The result is used.
*/
goto result_used;
}
goto result_not_used;
default:
/*
* In all other cases. the parent will actually use the return
* object, so keep it.
*/
goto result_used;
}
result_used:
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Result of [%s] used by Parent [%s] Op=%p\n",
acpi_ps_get_opcode_name (op->common.aml_opcode),
acpi_ps_get_opcode_name (op->common.parent->common.aml_opcode), op));
return_VALUE (TRUE);
result_not_used:
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Result of [%s] not used by Parent [%s] Op=%p\n",
acpi_ps_get_opcode_name (op->common.aml_opcode),
acpi_ps_get_opcode_name (op->common.parent->common.aml_opcode), op));
return_VALUE (FALSE);
}
/*******************************************************************************
*
* FUNCTION: acpi_ds_delete_result_if_not_used
*
* PARAMETERS: Op - Current parse Op
* result_obj - Result of the operation
* walk_state - Current state
*
* RETURN: Status
*
* DESCRIPTION: Used after interpretation of an opcode. If there is an internal
* result descriptor, check if the parent opcode will actually use
* this result. If not, delete the result now so that it will
* not become orphaned.
*
******************************************************************************/
void
acpi_ds_delete_result_if_not_used (
union acpi_parse_object *op,
union acpi_operand_object *result_obj,
struct acpi_walk_state *walk_state)
{
union acpi_operand_object *obj_desc;
acpi_status status;
ACPI_FUNCTION_TRACE_PTR ("ds_delete_result_if_not_used", result_obj);
if (!op) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Op\n"));
return_VOID;
}
if (!result_obj) {
return_VOID;
}
if (!acpi_ds_is_result_used (op, walk_state)) {
/*
* Must pop the result stack (obj_desc should be equal to result_obj)
*/
status = acpi_ds_result_pop (&obj_desc, walk_state);
if (ACPI_SUCCESS (status)) {
acpi_ut_remove_reference (result_obj);
}
}
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ds_resolve_operands
*
* PARAMETERS: walk_state - Current walk state with operands on stack
*
* RETURN: Status
*
* DESCRIPTION: Resolve all operands to their values. Used to prepare
* arguments to a control method invocation (a call from one
* method to another.)
*
******************************************************************************/
acpi_status
acpi_ds_resolve_operands (
struct acpi_walk_state *walk_state)
{
u32 i;
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE_PTR ("ds_resolve_operands", walk_state);
/*
* Attempt to resolve each of the valid operands
* Method arguments are passed by reference, not by value. This means
* that the actual objects are passed, not copies of the objects.
*/
for (i = 0; i < walk_state->num_operands; i++) {
status = acpi_ex_resolve_to_value (&walk_state->operands[i], walk_state);
if (ACPI_FAILURE (status)) {
break;
}
}
return_ACPI_STATUS (status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ds_clear_operands
*
* PARAMETERS: walk_state - Current walk state with operands on stack
*
* RETURN: None
*
* DESCRIPTION: Clear all operands on the current walk state operand stack.
*
******************************************************************************/
void
acpi_ds_clear_operands (
struct acpi_walk_state *walk_state)
{
u32 i;
ACPI_FUNCTION_TRACE_PTR ("ds_clear_operands", walk_state);
/*
* Remove a reference on each operand on the stack
*/
for (i = 0; i < walk_state->num_operands; i++) {
/*
* Remove a reference to all operands, including both
* "Arguments" and "Targets".
*/
acpi_ut_remove_reference (walk_state->operands[i]);
walk_state->operands[i] = NULL;
}
walk_state->num_operands = 0;
return_VOID;
}
#endif
/*******************************************************************************
*
* FUNCTION: acpi_ds_create_operand
*
* PARAMETERS: walk_state - Current walk state
* Arg - Parse object for the argument
* arg_index - Which argument (zero based)
*
* RETURN: Status
*
* DESCRIPTION: Translate a parse tree object that is an argument to an AML
* opcode to the equivalent interpreter object. This may include
* looking up a name or entering a new name into the internal
* namespace.
*
******************************************************************************/
acpi_status
acpi_ds_create_operand (
struct acpi_walk_state *walk_state,
union acpi_parse_object *arg,
u32 arg_index)
{
acpi_status status = AE_OK;
char *name_string;
u32 name_length;
union acpi_operand_object *obj_desc;
union acpi_parse_object *parent_op;
u16 opcode;
acpi_interpreter_mode interpreter_mode;
const struct acpi_opcode_info *op_info;
ACPI_FUNCTION_TRACE_PTR ("ds_create_operand", arg);
/* A valid name must be looked up in the namespace */
if ((arg->common.aml_opcode == AML_INT_NAMEPATH_OP) &&
(arg->common.value.string)) {
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n", arg));
/* Get the entire name string from the AML stream */
status = acpi_ex_get_name_string (ACPI_TYPE_ANY, arg->common.value.buffer,
&name_string, &name_length);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
}
/*
* All prefixes have been handled, and the name is
* in name_string
*/
/*
* Special handling for buffer_field declarations. This is a deferred
* opcode that unfortunately defines the field name as the last
* parameter instead of the first. We get here when we are performing
* the deferred execution, so the actual name of the field is already
* in the namespace. We don't want to attempt to look it up again
* because we may be executing in a different scope than where the
* actual opcode exists.
*/
if ((walk_state->deferred_node) &&
(walk_state->deferred_node->type == ACPI_TYPE_BUFFER_FIELD) &&
(arg_index != 0)) {
obj_desc = ACPI_CAST_PTR (union acpi_operand_object, walk_state->deferred_node);
status = AE_OK;
}
else /* All other opcodes */ {
/*
* Differentiate between a namespace "create" operation
* versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
* IMODE_EXECUTE) in order to support the creation of
* namespace objects during the execution of control methods.
*/
parent_op = arg->common.parent;
op_info = acpi_ps_get_opcode_info (parent_op->common.aml_opcode);
if ((op_info->flags & AML_NSNODE) &&
(parent_op->common.aml_opcode != AML_INT_METHODCALL_OP) &&
(parent_op->common.aml_opcode != AML_REGION_OP) &&
(parent_op->common.aml_opcode != AML_INT_NAMEPATH_OP)) {
/* Enter name into namespace if not found */
interpreter_mode = ACPI_IMODE_LOAD_PASS2;
}
else {
/* Return a failure if name not found */
interpreter_mode = ACPI_IMODE_EXECUTE;
}
status = acpi_ns_lookup (walk_state->scope_info, name_string,
ACPI_TYPE_ANY, interpreter_mode,
ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
walk_state,
ACPI_CAST_INDIRECT_PTR (struct acpi_namespace_node, &obj_desc));
/*
* The only case where we pass through (ignore) a NOT_FOUND
* error is for the cond_ref_of opcode.
*/
if (status == AE_NOT_FOUND) {
if (parent_op->common.aml_opcode == AML_COND_REF_OF_OP) {
/*
* For the Conditional Reference op, it's OK if
* the name is not found; We just need a way to
* indicate this to the interpreter, set the
* object to the root
*/
obj_desc = ACPI_CAST_PTR (union acpi_operand_object, acpi_gbl_root_node);
status = AE_OK;
}
else {
/*
* We just plain didn't find it -- which is a
* very serious error at this point
*/
status = AE_AML_NAME_NOT_FOUND;
}
}
if (ACPI_FAILURE (status)) {
ACPI_REPORT_NSERROR (name_string, status);
}
}
/* Free the namestring created above */
ACPI_MEM_FREE (name_string);
/* Check status from the lookup */
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
}
/* Put the resulting object onto the current object stack */
status = acpi_ds_obj_stack_push (obj_desc, walk_state);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
}
ACPI_DEBUGGER_EXEC (acpi_db_display_argument_object (obj_desc, walk_state));
}
else {
/* Check for null name case */
if (arg->common.aml_opcode == AML_INT_NAMEPATH_OP) {
/*
* If the name is null, this means that this is an
* optional result parameter that was not specified
* in the original ASL. Create a Zero Constant for a
* placeholder. (Store to a constant is a Noop.)
*/
opcode = AML_ZERO_OP; /* Has no arguments! */
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Null namepath: Arg=%p\n", arg));
}
else {
opcode = arg->common.aml_opcode;
}
/* Get the object type of the argument */
op_info = acpi_ps_get_opcode_info (opcode);
if (op_info->object_type == ACPI_TYPE_INVALID) {
return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
}
if (op_info->flags & AML_HAS_RETVAL) {
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"Argument previously created, already stacked \n"));
ACPI_DEBUGGER_EXEC (acpi_db_display_argument_object (
walk_state->operands [walk_state->num_operands - 1], walk_state));
/*
* Use value that was already previously returned
* by the evaluation of this argument
*/
status = acpi_ds_result_pop_from_bottom (&obj_desc, walk_state);
if (ACPI_FAILURE (status)) {
/*
* Only error is underflow, and this indicates
* a missing or null operand!
*/
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Missing or null operand, %s\n",
acpi_format_exception (status)));
return_ACPI_STATUS (status);
}
}
else {
/* Create an ACPI_INTERNAL_OBJECT for the argument */
obj_desc = acpi_ut_create_internal_object (op_info->object_type);
if (!obj_desc) {
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Initialize the new object */
status = acpi_ds_init_object_from_op (walk_state, arg,
opcode, &obj_desc);
if (ACPI_FAILURE (status)) {
acpi_ut_delete_object_desc (obj_desc);
return_ACPI_STATUS (status);
}
}
/* Put the operand object on the object stack */
status = acpi_ds_obj_stack_push (obj_desc, walk_state);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
}
ACPI_DEBUGGER_EXEC (acpi_db_display_argument_object (obj_desc, walk_state));
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_ds_create_operands
*
* PARAMETERS: first_arg - First argument of a parser argument tree
*
* RETURN: Status
*
* DESCRIPTION: Convert an operator's arguments from a parse tree format to
* namespace objects and place those argument object on the object
* stack in preparation for evaluation by the interpreter.
*
******************************************************************************/
acpi_status
acpi_ds_create_operands (
struct acpi_walk_state *walk_state,
union acpi_parse_object *first_arg)
{
acpi_status status = AE_OK;
union acpi_parse_object *arg;
u32 arg_count = 0;
ACPI_FUNCTION_TRACE_PTR ("ds_create_operands", first_arg);
/* For all arguments in the list... */
arg = first_arg;
while (arg) {
status = acpi_ds_create_operand (walk_state, arg, arg_count);
if (ACPI_FAILURE (status)) {
goto cleanup;
}
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Arg #%d (%p) done, Arg1=%p\n",
arg_count, arg, first_arg));
/* Move on to next argument, if any */
arg = arg->common.next;
arg_count++;
}
return_ACPI_STATUS (status);
cleanup:
/*
* We must undo everything done above; meaning that we must
* pop everything off of the operand stack and delete those
* objects
*/
(void) acpi_ds_obj_stack_pop_and_delete (arg_count, walk_state);
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "While creating Arg %d - %s\n",
(arg_count + 1), acpi_format_exception (status)));
return_ACPI_STATUS (status);
}
| gpl-2.0 |
johnparker007/mame | src/devices/cpu/tms32082/mp_ops.cpp | 40621 | // license:BSD-3-Clause
// copyright-holders:Ville Linde
// TMS320C82 Master Processor core execution
#include "emu.h"
#include "tms32082.h"
#define OP_LINK() ((m_ir >> 27) & 0x1f)
#define OP_RD() ((m_ir >> 27) & 0x1f)
#define OP_RS() ((m_ir >> 22) & 0x1f)
#define OP_BASE() ((m_ir >> 22) & 0x1f)
#define OP_SIMM15() ((m_ir & 0x4000) ? (0xffffe000 | (m_ir & 0x7fff)) : (m_ir & 0x7fff))
#define OP_UIMM15() (m_ir & 0x7fff)
#define OP_BITNUM() ((m_ir >> 27) & 0x1f)
#define OP_ROTATE() (m_ir & 0x1f)
#define OP_ENDMASK() ((m_ir >> 5) & 0x1f)
#define OP_SRC1() (m_ir & 0x1f)
#define OP_PD() ((m_ir >> 9) & 0x3)
#define OP_P1() ((m_ir >> 5) & 0x3)
#define OP_P2() ((m_ir >> 7) & 0x3)
#define OP_ACC() ((m_ir >> 15) & 0x2) | ((m_ir >> 11) & 1)
#define ROTATE_L(x, r) ((x << r) | (x >> (32-r)))
#define ROTATE_R(x, r) ((x >> r) | (x << (32-r)))
#define CMP_OVERFLOW32(r, s, d) ((((d) ^ (s)) & ((d) ^ (r)) & 0x80000000) ? 1 : 0)
#define CMP_OVERFLOW16(r, s, d) ((((d) ^ (s)) & ((d) ^ (r)) & 0x8000) ? 1 : 0)
#define CMP_OVERFLOW8(r, s, d) ((((d) ^ (s)) & ((d) ^ (r)) & 0x80) ? 1 : 0)
#define CARRY32(x) (((x) & (((uint64_t)1) << 32)) ? 1 : 0)
#define CARRY16(x) (((x) & 0x10000) ? 1 : 0)
#define CARRY8(x) (((x) & 0x100) ? 1 : 0)
#define SIGN32(x) (((x) & 0x80000000) ? 1 : 0)
#define SIGN16(x) (((x) & 0x8000) ? 1 : 0)
#define SIGN8(x) (((x) & 0x80) ? 1 : 0)
#define SIGN_EXTEND(x, r) ((x) | (((x) & (0x80000000 >> r)) ? ((int32_t)(0x80000000) >> r) : 0))
bool tms32082_mp_device::test_condition(int condition, uint32_t value)
{
switch (condition)
{
case 0x00: return false; // never, byte
case 0x01: return (int8_t)(value) > 0; // greater than zero, byte
case 0x02: return (int8_t)(value) == 0; // equals zero, byte
case 0x03: return (int8_t)(value) >= 0; // greater than or equal to zero, byte
case 0x04: return (int8_t)(value) < 0; // less than zero, byte
case 0x05: return (int8_t)(value) != 0; // not equal to zero, byte
case 0x06: return (int8_t)(value) <= 0; // less than or equal to zero, byte
case 0x07: return true; // always, byte
case 0x08: return false; // never, word
case 0x09: return (int16_t)(value) > 0; // greater than zero, word
case 0x0a: return (int16_t)(value) == 0; // equals zero, word
case 0x0b: return (int16_t)(value) >= 0; // greater than or equal to zero, word
case 0x0c: return (int16_t)(value) < 0; // less than zero, word
case 0x0d: return (int16_t)(value) != 0; // not equal to zero, word
case 0x0e: return (int16_t)(value) <= 0; // less than or equal to zero, word
case 0x0f: return true; // always, word
case 0x10: return false; // never, dword
case 0x11: return (int32_t)(value) > 0; // greater than zero, dword
case 0x12: return (int32_t)(value) == 0; // equals zero, dword
case 0x13: return (int32_t)(value) >= 0; // greater than or equal to zero, dword
case 0x14: return (int32_t)(value) < 0; // less than zero, dword
case 0x15: return (int32_t)(value) != 0; // not equal to zero, dword
case 0x16: return (int32_t)(value) <= 0; // less than or equal to zero, dword
case 0x17: return true; // always, dword
default: return false; // reserved
}
}
uint32_t tms32082_mp_device::calculate_cmp(uint32_t src1, uint32_t src2)
{
uint16_t src1_16 = (uint16_t)(src1);
uint8_t src1_8 = (uint8_t)(src1);
uint16_t src2_16 = (uint16_t)(src2);
uint8_t src2_8 = (uint8_t)(src2);
uint64_t res32 = (uint64_t)src1 - (uint64_t)src2;
int z32 = (res32 == 0) ? 1 : 0;
int n32 = SIGN32(res32);
int v32 = CMP_OVERFLOW32(res32, src2, src1);
int c32 = CARRY32(res32);
uint32_t res16 = (uint32_t)src1_16 - (uint32_t)src2_16;
int z16 = (res16 == 0) ? 1 : 0;
int n16 = SIGN16(res16);
int v16 = CMP_OVERFLOW16(res16, src2_16, src1_16);
int c16 = CARRY16(res16);
uint16_t res8 = (uint16_t)src1_8 - (uint16_t)src2_8;
int z8 = (res8 == 0) ? 1 : 0;
int n8 = SIGN8(res8);
int v8 = CMP_OVERFLOW8(res8, src2_8, src1_8);
int c8 = CARRY8(res8);
uint32_t flags = 0;
// 32-bits (bits 20-29)
flags |= ((~c32) & 1) << 29; // higher than or same (C)
flags |= ((c32) & 1) << 28; // lower than (~C)
flags |= ((c32|z32) & 1) << 27; // lower than or same (~C|Z)
flags |= ((~c32&~z32) & 1) << 26; // higher than (C&~Z)
flags |= (((n32&v32)|(~n32&~v32)) & 1) << 25; // greater than or equal (N&V)|(~N&~V)
flags |= (((n32&~v32)|(~n32&v32)) & 1) << 24; // less than (N&~V)|(~N&V)
flags |= (((n32&~v32)|(~n32&v32)|(z32)) & 1) << 23; // less than or equal (N&~V)|(~N&V)|Z
flags |= (((n32&v32&~z32)|(~n32&~v32&~z32)) & 1) << 22; // greater than (N&V&~Z)|(~N&~V&~Z)
flags |= ((~z32) & 1) << 21; // not equal (~Z)
flags |= ((z32) & 1) << 20; // equal (Z)
// 16-bits (bits 10-19)
flags |= ((~c16) & 1) << 19; // higher than or same (C)
flags |= ((c16) & 1) << 18; // lower than (~C)
flags |= ((c16|z16) & 1) << 17; // lower than or same (~C|Z)
flags |= ((~c16&~z16) & 1) << 16; // higher than (C&~Z)
flags |= (((n16&v16)|(~n16&~v16)) & 1) << 15; // greater than or equal (N&V)|(~N&~V)
flags |= (((n16&~v16)|(~n16&v16)) & 1) << 14; // less than (N&~V)|(~N&V)
flags |= (((n16&~v16)|(~n16&v16)|(z16)) & 1) << 13; // less than or equal (N&~V)|(~N&V)|Z
flags |= (((n16&v16&~z16)|(~n16&~v16&~z16)) & 1) << 12; // greater than (N&V&~Z)|(~N&~V&~Z)
flags |= ((~z16) & 1) << 11; // not equal (~Z)
flags |= ((z16) & 1) << 10; // equal (Z)
// 8-bits (bits 0-9)
flags |= ((~c8) & 1) << 9; // higher than or same (C)
flags |= ((c8) & 1) << 8; // lower than (~C)
flags |= ((c8|z8) & 1) << 7; // lower than or same (~C|Z)
flags |= ((~c8&~z8) & 1) << 6; // higher than (C&~Z)
flags |= (((n8&v8)|(~n8&~v8)) & 1) << 5; // greater than or equal (N&V)|(~N&~V)
flags |= (((n8&~v8)|(~n8&v8)) & 1) << 4; // less than (N&~V)|(~N&V)
flags |= (((n8&~v8)|(~n8&v8)|(z8)) & 1) << 3; // less than or equal (N&~V)|(~N&V)|Z
flags |= (((n8&v8&~z8)|(~n8&~v8&~z8)) & 1) << 2; // greater than (N&V&~Z)|(~N&~V&~Z)
flags |= ((~z8) & 1) << 1; // not equal (~Z)
flags |= ((z8) & 1) << 0; // equal (Z)
return flags;
}
void tms32082_mp_device::vector_loadstore()
{
int rd = OP_RD();
int vector_ls_bits = (((m_ir >> 9) & 0x3) << 1) | ((m_ir >> 6) & 1);
switch (vector_ls_bits)
{
case 0x01: // vst.s
{
m_program.write_dword(m_outp, m_reg[rd]);
m_outp += 4;
break;
}
case 0x03: // vst.d
{
uint64_t data = m_fpair[rd >> 1];
m_program.write_qword(m_outp, data);
m_outp += 8;
break;
}
case 0x04: // vld0.s
{
m_reg[rd] = m_program.read_dword(m_in0p);
m_in0p += 4;
break;
}
case 0x05: // vld1.s
{
m_reg[rd] = m_program.read_dword(m_in1p);
m_in1p += 4;
break;
}
case 0x06: // vld0.d
{
m_fpair[rd >> 1] = m_program.read_qword(m_in0p);
m_in0p += 8;
break;
}
case 0x07: // vld1.d
{
m_fpair[rd >> 1] = m_program.read_qword(m_in1p);
m_in1p += 8;
break;
}
default:
fatalerror("vector_loadstore(): ls bits = %02X\n", vector_ls_bits);
}
}
void tms32082_mp_device::execute_short_imm()
{
switch ((m_ir >> 15) & 0x7f)
{
case 0x02: // cmnd
{
uint32_t data = OP_UIMM15();
processor_command(data);
break;
}
case 0x04: // rdcr
{
int rd = OP_RD();
uint32_t imm = OP_UIMM15();
uint32_t r = read_creg(imm);
if (rd)
m_reg[rd] = r;
break;
}
case 0x05: // swcr
{
int rd = OP_RD();
int rs = OP_RS();
uint32_t imm = OP_UIMM15();
uint32_t r = read_creg(imm);
if (rd)
m_reg[rd] = r;
write_creg(imm, m_reg[rs]);
break;
}
case 0x06: // brcr
{
int cr = OP_UIMM15();
if (cr == 0x0001)
{
// ignore jump to EIP because of how we emulate the pipeline
}
else
{
uint32_t data = read_creg(cr);
m_fetchpc = data & ~3;
m_ie = (m_ie & ~1) | (data & 1); // global interrupt mask from creg
// TODO: user/supervisor latch from creg
}
break;
}
case 0x08: // shift.dz
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = OP_ROTATE();
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = SHIFT_MASK[end ? end : 32];
if (inv) endmask = ~endmask;
uint32_t compmask = endmask; // shiftmask == 0xffffffff
uint32_t res;
if (r) // right
{
res = ROTATE_R(source, rot) & compmask;
}
else // left
{
res = ROTATE_L(source, rot) & compmask;
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x0a: // shift.ds
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = OP_ROTATE();
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = SHIFT_MASK[end ? end : 32];
if (inv) endmask = ~endmask;
uint32_t compmask = endmask; // shiftmask == 0xffffffff
uint32_t res;
if (r) // right
{
res = ROTATE_R(source, rot) & compmask;
res = SIGN_EXTEND(res, rot);
}
else // left
{
res = ROTATE_L(source, rot) & compmask;
// sign extend makes no sense to left..
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x0b: // shift.ez
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = OP_ROTATE();
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = SHIFT_MASK[end ? end : 32];
if (inv) endmask = ~endmask;
int shift = r ? 32-rot : rot;
uint32_t shiftmask = SHIFT_MASK[shift ? shift : 32];
uint32_t compmask = endmask & shiftmask;
uint32_t res;
if (r) // right
{
res = ROTATE_R(source, rot) & compmask;
}
else // left
{
res = ROTATE_L(source, rot) & compmask;
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x0c: // shift.em
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = OP_ROTATE();
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = SHIFT_MASK[end ? end : 32];
if (inv) endmask = ~endmask;
uint32_t shiftmask = SHIFT_MASK[r ? 32-rot : rot];
uint32_t compmask = endmask & shiftmask;
uint32_t res;
if (r) // right
{
res = (ROTATE_R(source, rot) & compmask) | (m_reg[rd] & ~compmask);
}
else // left
{
res = (ROTATE_L(source, rot) & compmask) | (m_reg[rd] & ~compmask);
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x0d: // shift.es
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = OP_ROTATE();
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = SHIFT_MASK[end ? end : 32];
if (inv) endmask = ~endmask;
int shift = r ? 32-rot : rot;
uint32_t shiftmask = SHIFT_MASK[shift ? shift : 32];
uint32_t compmask = endmask & shiftmask;
uint32_t res;
if (r) // right
{
res = ROTATE_R(source, rot) & compmask;
res = SIGN_EXTEND(res, rot);
}
else // left
{
res = ROTATE_L(source, rot) & compmask;
// sign extend makes no sense to left..
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x0e: // shift.iz
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = OP_ROTATE();
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = SHIFT_MASK[end ? end : 32];
if (inv) endmask = ~endmask;
uint32_t shiftmask = SHIFT_MASK[r ? 32-rot : rot];
uint32_t compmask = endmask & ~shiftmask;
uint32_t res;
if (r) // right
{
res = ROTATE_R(source, rot) & compmask;
}
else // left
{
res = ROTATE_L(source, rot) & compmask;
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x0f: // shift.im
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = OP_ROTATE();
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = SHIFT_MASK[end ? end : 32];
if (inv) endmask = ~endmask;
uint32_t shiftmask = SHIFT_MASK[r ? 32-rot : rot];
uint32_t compmask = endmask & ~shiftmask;
uint32_t res;
if (r) // right
{
res = (ROTATE_R(source, rot) & compmask) | (m_reg[rd] & ~compmask);
}
else // left
{
res = (ROTATE_L(source, rot) & compmask) | (m_reg[rd] & ~compmask);
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x11: // and
{
int rd = OP_RD();
int rs = OP_RS();
uint32_t imm = OP_UIMM15();
if (rd)
m_reg[rd] = m_reg[rs] & imm;
break;
}
case 0x12: // and.tf
{
int rd = OP_RD();
int rs = OP_RS();
uint32_t imm = OP_UIMM15();
if (rd)
m_reg[rd] = ~m_reg[rs] & imm;
break;
}
case 0x14: // and.ft
{
int rd = OP_RD();
int rs = OP_RS();
uint32_t imm = OP_UIMM15();
if (rd)
m_reg[rd] = m_reg[rs] & ~imm;
break;
}
case 0x17: // or
{
int rd = OP_RD();
int rs = OP_RS();
uint32_t imm = OP_UIMM15();
if (rd)
m_reg[rd] = m_reg[rs] | imm;
break;
}
case 0x1d: // or.ft
{
int rd = OP_RD();
int rs = OP_RS();
uint32_t imm = OP_UIMM15();
if (rd)
m_reg[rd] = m_reg[rs] | ~imm;
break;
}
case 0x24:
case 0x20: // ld.b
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
uint32_t data = (uint8_t)m_program.read_byte(address);
if (data & 0x80) data |= 0xffffff00;
if (rd)
m_reg[rd] = data;
if (m && base)
m_reg[base] = address;
break;
}
case 0x25:
case 0x21: // ld.h
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
uint32_t data = (uint16_t)m_program.read_word(address);
if (data & 0x8000) data |= 0xffff0000;
if (rd)
m_reg[rd] = data;
if (m && base)
m_reg[base] = address;
break;
}
case 0x26:
case 0x22: // ld
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
uint32_t data = m_program.read_dword(address);
if (rd)
m_reg[rd] = data;
if (m && base)
m_reg[base] = address;
break;
}
case 0x27:
case 0x23: // ld.d
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
uint32_t data1 = m_program.read_dword(address);
uint32_t data2 = m_program.read_dword(address+4);
if (rd)
{
m_reg[(rd & ~1)+1] = data1;
m_reg[(rd & ~1)] = data2;
}
if (m && base)
m_reg[base] = address;
break;
}
case 0x28:
case 0x2c: // ld.ub
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
uint32_t data = (uint8_t)(m_program.read_byte(address));
if (rd)
m_reg[rd] = data;
if (m && base)
m_reg[base] = address;
break;
}
case 0x2d:
case 0x29: // ld.uh
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
uint32_t data = (uint16_t)(m_program.read_word(address));
if (rd)
m_reg[rd] = data;
if (m && base)
m_reg[base] = address;
break;
}
case 0x34:
case 0x30: // st.b
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
m_program.write_byte(address, (uint8_t)(m_reg[rd]));
if (m && base)
m_reg[base] = address;
break;
}
case 0x35:
case 0x31: // st.h
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
m_program.write_word(address, (uint16_t)(m_reg[rd]));
if (m && base)
m_reg[base] = address;
break;
}
case 0x36:
case 0x32: // st
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
m_program.write_dword(address, m_reg[rd]);
if (m && base)
m_reg[base] = address;
break;
}
case 0x37:
case 0x33: // st.d
{
int rd = OP_RD();
int base = OP_BASE();
int m = m_ir & (1 << 17);
int32_t offset = OP_SIMM15();
uint32_t address = m_reg[base] + offset;
m_program.write_dword(address+0, m_reg[(rd & ~1) + 1]);
m_program.write_dword(address+4, m_reg[rd & ~1]);
if (m && base)
m_reg[base] = address;
break;
}
case 0x45: // jsr.a
{
int link = OP_LINK();
int base = OP_BASE();
int32_t offset = OP_SIMM15();
if (link)
m_reg[link] = m_fetchpc;
m_fetchpc = m_reg[base] + offset;
break;
}
case 0x48: // bbz
{
int bitnum = OP_BITNUM() ^ 0x1f;
int32_t offset = OP_SIMM15();
int rs = OP_RS();
if ((m_reg[rs] & (1 << bitnum)) == 0)
{
uint32_t address = m_pc + (offset * 4);
m_pc = m_fetchpc;
delay_slot();
m_fetchpc = address;
}
break;
}
case 0x49: // bbz.a
{
int bitnum = OP_BITNUM() ^ 0x1f;
int32_t offset = OP_SIMM15();
int rs = OP_RS();
if ((m_reg[rs] & (1 << bitnum)) == 0)
{
m_fetchpc = m_pc + (offset * 4);
}
break;
}
case 0x4a: // bbo
{
int bitnum = OP_BITNUM() ^ 0x1f;
int32_t offset = OP_SIMM15();
int rs = OP_RS();
if ((m_reg[rs] & (1 << bitnum)) != 0)
{
uint32_t address = m_pc + (offset * 4);
m_pc = m_fetchpc;
delay_slot();
m_fetchpc = address;
}
break;
}
case 0x4b: // bbo.a
{
int bitnum = OP_BITNUM() ^ 0x1f;
int32_t offset = OP_SIMM15();
int rs = OP_RS();
if ((m_reg[rs] & (1 << bitnum)) != 0)
{
m_fetchpc = m_pc + (offset * 4);
}
break;
}
case 0x4c: // bcnd
{
int32_t offset = OP_SIMM15();
int code = OP_RD();
int rs = OP_RS();
if (test_condition(code, m_reg[rs]))
{
uint32_t address = m_pc + (offset * 4);
m_pc = m_fetchpc;
delay_slot();
m_fetchpc = address;
}
break;
}
case 0x4d: // bcnd.a
{
int32_t offset = OP_SIMM15();
int code = OP_RD();
int rs = OP_RS();
if (test_condition(code, m_reg[rs]))
{
m_fetchpc = m_pc + (offset * 4);
}
break;
}
case 0x50: // cmp
{
uint32_t src1 = OP_SIMM15();
uint32_t src2 = m_reg[OP_RS()];
int rd = OP_RD();
if (rd)
m_reg[rd] = calculate_cmp(src1, src2);
break;
}
case 0x58: // add
{
int32_t imm = OP_SIMM15();
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = m_reg[rs] + imm;
// TODO: integer overflow exception
break;
}
case 0x59: // addu
{
int32_t imm = OP_SIMM15();
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = m_reg[rs] + imm;
break;
}
case 0x5a: // sub
{
int32_t imm = OP_SIMM15();
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = imm - m_reg[rs];
// TODO: integer overflow exception
break;
}
case 0x5b: // subu
{
int32_t imm = OP_SIMM15();
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = imm - m_reg[rs];
break;
}
default:
fatalerror("execute_short_imm(): %08X: opcode %08X (%02X)", m_pc, m_ir, (m_ir >> 15) & 0x7f);
}
}
void tms32082_mp_device::execute_reg_long_imm()
{
uint32_t imm32 = 0;
int has_imm = (m_ir & (1 << 12));
if (has_imm)
imm32 = fetch();
switch ((m_ir >> 12) & 0xff)
{
case 0x04: // cmnd
{
uint32_t data = has_imm ? imm32 : m_reg[OP_SRC1()];
processor_command(data);
break;
}
case 0x16: // shift.ez
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = m_reg[OP_ROTATE()];
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = end ? SHIFT_MASK[end ? end : 32] : m_reg[OP_ROTATE()+1];
if (inv) endmask = ~endmask;
int shift = r ? 32-rot : rot;
uint32_t shiftmask = SHIFT_MASK[shift ? shift : 32];
uint32_t compmask = endmask & shiftmask;
uint32_t res;
if (r) // right
{
res = ROTATE_R(source, rot) & compmask;
}
else // left
{
res = ROTATE_L(source, rot) & compmask;
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x1a: // shift.es
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = m_reg[OP_ROTATE()];
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = end ? SHIFT_MASK[end ? end : 32] : m_reg[OP_ROTATE()+1];
if (inv) endmask = ~endmask;
int shift = r ? 32-rot : rot;
uint32_t shiftmask = SHIFT_MASK[shift ? shift : 32];
uint32_t compmask = endmask & shiftmask;
uint32_t res;
if (r) // right
{
res = ROTATE_R(source, rot) & compmask;
res = SIGN_EXTEND(res, rot);
}
else // left
{
res = ROTATE_L(source, rot) & compmask;
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x1c: // shift.iz
{
int r = (m_ir & (1 << 10));
int inv = (m_ir & (1 << 11));
int rot = m_reg[OP_ROTATE()];
int end = OP_ENDMASK();
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
uint32_t endmask = end ? SHIFT_MASK[end ? end : 32] : m_reg[OP_ROTATE()+1];
if (inv) endmask = ~endmask;
int shift = r ? 32-rot : rot;
uint32_t shiftmask = SHIFT_MASK[shift ? shift : 32];
uint32_t compmask = endmask & ~shiftmask;
uint32_t res;
if (r) // right
{
res = ROTATE_R(source, rot) & compmask;
}
else // left
{
res = ROTATE_L(source, rot) & compmask;
}
if (rd)
m_reg[rd] = res;
break;
}
case 0x22:
case 0x23: // and
{
int rd = OP_RD();
int rs = OP_RS();
uint32_t src1 = has_imm ? imm32 : m_reg[OP_SRC1()];
if (rd)
m_reg[rd] = src1 & m_reg[rs];
break;
}
case 0x24:
case 0x25: // and.tf
{
int rd = OP_RD();
int rs = OP_RS();
uint32_t src1 = has_imm ? imm32 : m_reg[OP_SRC1()];
if (rd)
m_reg[rd] = src1 & ~(m_reg[rs]);
break;
}
case 0x2c:
case 0x2d: // xor
{
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = m_reg[rs] ^ (has_imm ? imm32 : m_reg[OP_SRC1()]);
break;
}
case 0x2e:
case 0x2f: // or
{
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = m_reg[rs] | (has_imm ? imm32 : m_reg[OP_SRC1()]);
break;
}
case 0x3a:
case 0x3b: // or.ft
{
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = m_reg[rs] | ~(has_imm ? imm32 : m_reg[OP_SRC1()]);
break;
}
case 0x40:
case 0x41:
case 0x48:
case 0x49: // ld.b
{
int m = m_ir & (1 << 15);
int base = OP_BASE();
int rd = OP_RD();
uint32_t address = m_reg[base] + (has_imm ? imm32 : m_reg[OP_SRC1()]);
uint32_t r = m_program.read_byte(address);
if (r & 0x80) r |= 0xffffff00;
if (rd)
m_reg[rd] = r;
if (m && base)
m_reg[base] = address;
break;
}
case 0x42:
case 0x4a:
case 0x43:
case 0x4b: // ld.h
{
int shift = (m_ir & (1 << 11)) ? 1 : 0;
int m = m_ir & (1 << 15);
int base = OP_BASE();
int rd = OP_RD();
uint32_t address = m_reg[base] + ((has_imm ? imm32 : m_reg[OP_SRC1()]) << shift);
uint32_t r = m_program.read_word(address);
if (r & 0x8000) r |= 0xffff0000;
if (rd)
m_reg[rd] = r;
if (m && base)
m_reg[base] = address;
break;
}
case 0x4c:
case 0x44:
case 0x4d:
case 0x45: // ld
{
int shift = (m_ir & (1 << 11)) ? 2 : 0;
int m = m_ir & (1 << 15);
int base = OP_BASE();
int rd = OP_RD();
uint32_t address = m_reg[base] + ((has_imm ? imm32 : m_reg[OP_SRC1()]) << shift);
uint32_t r = m_program.read_dword(address);
if (rd)
m_reg[rd] = r;
if (m && base)
m_reg[base] = address;
break;
}
case 0x4e:
case 0x4f:
case 0x46:
case 0x47: // ld.d
{
int shift = (m_ir & (1 << 11)) ? 3 : 0;
int m = m_ir & (1 << 15);
int base = OP_BASE();
int rd = OP_RD();
uint32_t address = m_reg[base] + ((has_imm ? imm32 : m_reg[OP_SRC1()]) << shift);
uint64_t r = m_program.read_qword(address);
if (rd)
m_fpair[rd >> 1] = r;
if (m && base)
m_reg[base] = address;
break;
}
case 0x58:
case 0x59:
case 0x50:
case 0x51: // ld.ub
{
int m = m_ir & (1 << 15);
int base = OP_BASE();
int rd = OP_RD();
uint32_t address = m_reg[base] + (has_imm ? imm32 : m_reg[OP_SRC1()]);
uint32_t r = (uint8_t)(m_program.read_byte(address));
if (rd)
m_reg[rd] = r;
if (m && base)
m_reg[base] = address;
break;
}
case 0x5a:
case 0x5b:
case 0x52:
case 0x53: // ld.uh
{
int shift = (m_ir & (1 << 11)) ? 1 : 0;
int m = m_ir & (1 << 15);
int base = OP_BASE();
int rd = OP_RD();
uint32_t address = m_reg[base] + ((has_imm ? imm32 : m_reg[OP_SRC1()]) << shift);
uint32_t r = (uint16_t)(m_program.read_word(address));
if (rd)
m_reg[rd] = r;
if (m && base)
m_reg[base] = address;
break;
}
case 0x60:
case 0x61:
case 0x68:
case 0x69: // st.b
{
int m = m_ir & (1 << 15);
int base = OP_BASE();
uint32_t address = m_reg[base] + (has_imm ? imm32 : m_reg[OP_SRC1()]);
m_program.write_byte(address, (uint8_t)(m_reg[OP_RD()]));
if (m && base)
m_reg[base] = address;
break;
}
case 0x62:
case 0x63:
case 0x6a:
case 0x6b: // st.h
{
int shift = (m_ir & (1 << 11)) ? 1 : 0;
int m = m_ir & (1 << 15);
int base = OP_BASE();
uint32_t address = m_reg[base] + ((has_imm ? imm32 : m_reg[OP_SRC1()]) << shift);
m_program.write_word(address, (uint16_t)(m_reg[OP_RD()]));
if (m && base)
m_reg[base] = address;
break;
}
case 0x6c:
case 0x6d:
case 0x64:
case 0x65: // st
{
int shift = (m_ir & (1 << 11)) ? 2 : 0;
int m = m_ir & (1 << 15);
int base = OP_BASE();
uint32_t address = m_reg[base] + ((has_imm ? imm32 : m_reg[OP_SRC1()]) << shift);
m_program.write_dword(address, m_reg[OP_RD()]);
if (m && base)
m_reg[base] = address;
break;
}
case 0x88:
case 0x89: // jsr
{
int link = OP_LINK();
int base = OP_BASE();
if (link)
m_reg[link] = m_fetchpc + 4;
uint32_t address = m_reg[base] + (has_imm ? imm32 : m_reg[OP_SRC1()]);
m_pc = m_fetchpc;
delay_slot();
m_fetchpc = address;
break;
}
case 0x8a:
case 0x8b: // jsr.a
{
int link = OP_LINK();
int base = OP_BASE();
if (link)
m_reg[link] = m_fetchpc;
m_fetchpc = m_reg[base] + (has_imm ? imm32 : m_reg[OP_SRC1()]);
break;
}
case 0xa0:
case 0xa1: // cmp
{
int rd = OP_RD();
uint32_t src1 = has_imm ? imm32 : m_reg[OP_SRC1()];
uint32_t src2 = m_reg[OP_RS()];
if (rd)
m_reg[rd] = calculate_cmp(src1, src2);
break;
}
case 0xb2:
case 0xb3: // addu
{
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = m_reg[rs] + (has_imm ? imm32 : m_reg[OP_SRC1()]);
break;
}
case 0xb4:
case 0xb5: // sub
{
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = (has_imm ? imm32 : m_reg[OP_SRC1()]) - m_reg[rs];
// TODO: overflow interrupt
break;
}
case 0xb6:
case 0xb7: // subu
{
int rd = OP_RD();
int rs = OP_RS();
if (rd)
m_reg[rd] = (has_imm ? imm32 : m_reg[OP_SRC1()]) - m_reg[rs];
break;
}
case 0xc4:
case 0xd4:
case 0xc5:
case 0xd5: // vmpy
{
int p1 = m_ir & (1 << 5);
int pd = m_ir & (1 << 7);
int ls_bit1 = m_ir & (1 << 10);
int ls_bit2 = m_ir & (1 << 6);
int rd = OP_RS();
int src1 OP_SRC1();
double source = has_imm ? (double)u2f(imm32) : (p1 ? u2d(m_fpair[src1 >> 1]) : (double)u2f(m_reg[src1]));
if (rd)
{
if (pd)
{
double res = source * u2d(m_fpair[rd >> 1]);
m_fpair[rd >> 1] = d2u(res);
}
else
{
float res = (float)(source) * u2f(m_reg[rd]);
m_reg[rd] = f2u(res);
}
}
// parallel load/store op
if (!(ls_bit1 == 0 && ls_bit2 == 0))
{
vector_loadstore();
}
break;
}
case 0xc8:
case 0xd8:
case 0xc9:
case 0xd9: // vrnd
{
int acc = OP_ACC();
int p1 = m_ir & (1 << 5);
int pd = (m_ir >> 7) & 3;
int ls_bit1 = m_ir & (1 << 10);
int ls_bit2 = m_ir & (1 << 6);
int rd = OP_RS();
int rs1 = OP_SRC1();
double source = has_imm ? (double)u2f(imm32) : (p1 ? u2d(m_fpair[rs1 >> 1]) : (double)u2f(m_reg[rs1]));
if (rd)
{
// destination register
switch (pd)
{
case 0:
m_reg[rd] = f2u((float)source);
break;
case 1:
m_fpair[rd >> 1] = d2u(source);
break;
case 2:
m_reg[rd] = (int32_t)(source);
break;
case 3:
m_reg[rd] = (uint32_t)(source);
break;
}
}
else
{
// destination accumulator
if (pd != 1)
fatalerror("vrnd pd = %d at %08X\n", pd, m_pc);
m_facc[acc] = source;
}
// parallel load/store op
if (!(ls_bit1 == 0 && ls_bit2 == 0))
{
vector_loadstore();
}
break;
}
case 0xcc:
case 0xdc:
case 0xcd:
case 0xdd: // vmac
{
int acc = OP_ACC();
int z = m_ir & (1 << 8);
int pd = m_ir & (1 << 9);
int ls_bit1 = m_ir & (1 << 10);
int ls_bit2 = m_ir & (1 << 6);
int rd = OP_RD();
float src1 = u2f(m_reg[OP_SRC1()]);
float src2 = u2f(m_reg[OP_RS()]);
float res = (src1 * src2) + (z ? 0.0f : m_facc[acc]);
// parallel load/store op
if (!(ls_bit1 == 0 && ls_bit2 == 0))
{
vector_loadstore();
// if the opcode has load/store, dest is always accumulator
m_facc[acc] = (double)res;
}
else
{
if (rd)
{
if (pd)
m_fpair[rd >> 1] = d2u(res);
else
m_reg[rd] = f2u((float)res);
}
else
{
// write to accumulator
m_facc[acc] = (double)res;
}
}
break;
}
case 0xce:
case 0xde:
case 0xcf:
case 0xdf: // vmsc
{
int acc = OP_ACC();
int z = m_ir & (1 << 8);
int pd = m_ir & (1 << 9);
int ls_bit1 = m_ir & (1 << 10);
int ls_bit2 = m_ir & (1 << 6);
int rd = OP_RD();
float src1 = u2f(m_reg[OP_SRC1()]);
float src2 = u2f(m_reg[OP_RS()]);
float res = (z ? 0.0f : m_facc[acc]) - (src1 * src2);
// parallel load/store op
if (!(ls_bit1 == 0 && ls_bit2 == 0))
{
vector_loadstore();
// if the opcode has load/store, dest is always accumulator
m_facc[acc] = (double)res;
}
else
{
if (rd)
{
if (pd)
m_fpair[rd >> 1] = d2u(res);
else
m_reg[rd] = f2u((float)res);
}
else
{
// write to accumulator
m_facc[acc] = (double)res;
}
}
break;
}
case 0xe0:
case 0xe1: // fadd
{
int rd = OP_RD();
int rs = OP_RS();
int src1 = OP_SRC1();
int precision = (m_ir >> 5) & 0x3f;
if (rd) // only calculate if destination register is valid
{
switch (precision)
{
case 0x00: // SP - SP -> SP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
float s2 = u2f(m_reg[rs]);
m_reg[rd] = f2u(s1 + s2);
break;
}
case 0x10: // SP - SP -> DP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
float s2 = u2f(m_reg[rs]);
uint64_t res = d2u((double)(s1 + s2));
m_fpair[rd >> 1] = res;
break;
}
case 0x14: // SP - DP -> DP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
double s2 = u2d(m_fpair[rs >> 1]);
uint64_t res = d2u((double) s1 + s2);
m_fpair[rd >> 1] = res;
break;
}
case 0x11: // DP - SP -> DP
{
double s1 = u2d(m_fpair[src1 >> 1]);
float s2 = u2f(m_reg[rs]);
uint64_t res = d2u(s1 + (double) s2);
m_fpair[rd >> 1] = res;
break;
}
case 0x15: // DP - DP -> DP
{
double s1 = u2d(m_fpair[src1 >> 1]);
double s2 = u2d(m_fpair[rs >> 1]);
uint64_t res = d2u((double)(s1 + s2));
m_fpair[rd >> 1] = res;
break;
}
default:
fatalerror("fadd: invalid precision combination %02X\n", precision);
}
}
break;
}
case 0xe2:
case 0xe3: // fsub
{
int rd = OP_RD();
int rs = OP_RS();
int src1 = OP_SRC1();
int precision = (m_ir >> 5) & 0x3f;
if (rd) // only calculate if destination register is valid
{
switch (precision)
{
case 0x00: // SP - SP -> SP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
float s2 = u2f(m_reg[rs]);
m_reg[rd] = f2u(s1 - s2);
break;
}
case 0x10: // SP - SP -> DP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
float s2 = u2f(m_reg[rs]);
uint64_t res = d2u((double)(s1 - s2));
m_fpair[rd >> 1] = res;
break;
}
case 0x14: // SP - DP -> DP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
double s2 = u2d(m_fpair[rs >> 1]);
uint64_t res = d2u((double) s1 - s2);
m_fpair[rd >> 1] = res;
break;
}
case 0x11: // DP - SP -> DP
{
double s1 = u2d(m_fpair[src1 >> 1]);
float s2 = u2f(m_reg[rs]);
uint64_t res = d2u(s1 - (double) s2);
m_fpair[rd >> 1] = res;
break;
}
case 0x15: // DP - DP -> DP
{
double s1 = u2d(m_fpair[src1 >> 1]);
double s2 = u2d(m_fpair[rs >> 1]);
uint64_t res = d2u((double)(s1 - s2));
m_fpair[rd >> 1] = res;
break;
}
default:
fatalerror("fsub: invalid precision combination %02X\n", precision);
}
}
break;
}
case 0xe4:
case 0xe5: // fmpy
{
int rd = OP_RD();
int rs = OP_RS();
int src1 = OP_SRC1();
int precision = (m_ir >> 5) & 0x3f;
if (rd) // only calculate if destination register is valid
{
switch (precision)
{
case 0x00: // SP x SP -> SP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
float s2 = u2f(m_reg[rs]);
m_reg[rd] = f2u(s1 * s2);
break;
}
case 0x10: // SP x SP -> DP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
float s2 = u2f(m_reg[rs]);
uint64_t res = d2u((double)(s1 * s2));
m_fpair[rd >> 1] = res;
break;
}
case 0x14: // SP x DP -> DP
{
float s1 = u2f(has_imm ? imm32 : m_reg[src1]);
double s2 = u2d(m_fpair[rs >> 1]);
uint64_t res = d2u((double)s1 * s2);
m_fpair[rd >> 1] = res;
break;
}
case 0x11: // DP x SP -> DP
{
double s1 = u2d(m_fpair[src1 >> 1]);
float s2 = u2f(m_reg[rs]);
uint64_t res = d2u(s1 * (double) s2);
m_fpair[rd >> 1] = res;
break;
}
case 0x15: // DP x DP -> DP
{
double s1 = u2d(m_fpair[src1 >> 1]);
double s2 = u2d(m_fpair[rs >> 1]);
uint64_t res = d2u(s1 * s2);
m_fpair[rd >> 1] = res;
break;
}
case 0x2a: // I x I -> I
{
m_reg[rd] = (int32_t)(m_reg[rs]) * (int32_t)(has_imm ? imm32 : m_reg[OP_SRC1()]);
break;
}
case 0x3f: // U x U -> U
{
m_reg[rd] = (uint32_t)(m_reg[rs]) * (uint32_t)(has_imm ? imm32 : m_reg[OP_SRC1()]);
break;
}
default:
fatalerror("fmpy: invalid precision combination %02X\n", precision);
}
}
break;
}
case 0xe6:
case 0xe7: // fdiv
{
int rd = OP_RD();
int p1 = m_ir & (1 << 5);
int p2 = m_ir & (1 << 7);
int pd = m_ir & (1 << 9);
int rs1 = OP_SRC1();
int rs2 = OP_RS();
if (rd)
{
double src1 = has_imm ? (double)u2f(imm32) : (p1 ? u2d(m_fpair[rs1 >> 1]) : (double)u2f(m_reg[rs1]));
double src2 = p2 ? u2d(m_fpair[rs2 >> 1]) : (double)u2f(m_reg[rs2]);
double res;
if (src2 != 0.0)
res = src1 / src2;
else
res = 0.0f;
if (pd)
m_fpair[rd >> 1] = d2u(res);
else
m_reg[rd] = f2u((float)res);
}
break;
}
case 0xe8:
case 0xe9: // frnd
{
//int mode = (m_ir >> 7) & 3;
int p1 = (m_ir >> 5) & 3;
int pd = (m_ir >> 9) & 3;
int src1 = OP_SRC1();
int rd = OP_RD();
double s = 0.0;
switch (p1)
{
case 0:
s = has_imm ? (double)(u2f(imm32)) : (double)u2f(m_reg[src1]);
break;
case 1:
s = u2d(m_fpair[src1 >> 1]);
break;
case 2:
s = has_imm ? (double)((int32_t)(imm32)) : (double)(int32_t)(m_reg[src1]);
break;
case 3:
s = has_imm ? (double)((uint32_t)(imm32)) : (double)(uint32_t)(m_reg[src1]);
break;
}
// TODO: round
if (rd)
{
switch (pd)
{
case 0:
m_reg[rd] = f2u((float)(s));
break;
case 1:
m_fpair[rd >> 1] = d2u(s);
break;
case 2:
m_reg[rd] = (int32_t)(s);
break;
case 3:
m_reg[rd] = (uint32_t)(s);
break;
}
}
break;
}
case 0xea:
case 0xeb: // fcmp
{
int rd = OP_RD();
int p1 = m_ir & (1 << 5);
int p2 = m_ir & (1 << 7);
int rs1 = OP_SRC1();
int rs2 = OP_RS();
double src1 = has_imm ? (double)(u2f(imm32)) : (p1 ? u2d(m_fpair[rs1 >> 1]) : (double)u2f(m_reg[rs1]));
double src2 = p2 ? u2d(m_fpair[rs2 >> 1]) : (double)u2f(m_reg[rs2]);
if (rd)
{
uint32_t flags = 0;
flags |= (src1 == src2) ? (1 << 20) : 0;
flags |= (src1 != src2) ? (1 << 21) : 0;
flags |= (src1 > src2) ? (1 << 22) : 0;
flags |= (src1 <= src2) ? (1 << 23) : 0;
flags |= (src1 < src2) ? (1 << 24) : 0;
flags |= (src1 >= src2) ? (1 << 25) : 0;
flags |= (src1 < 0 || src1 > src2) ? (1 << 26) : 0;
flags |= (src1 > 0 && src1 < src2) ? (1 << 27) : 0;
flags |= (src1 >= 0 && src1 <= src2) ? (1 << 28) : 0;
flags |= (src1 <= 0 || src1 >= src2) ? (1 << 29) : 0;
// TODO: src1 or src2 unordered
// TODO: src1 and src2 ordered
m_reg[rd] = flags;
}
break;
}
case 0xee:
case 0xef: // fsqrt
{
int rd = OP_RD();
int src1 = OP_SRC1();
int p1 = m_ir & (1 << 5);
int pd = m_ir & (1 << 9);
double source = has_imm ? (double)u2f(imm32) : (p1 ? u2d(m_fpair[src1 >> 1]) : (double)u2f(m_reg[src1]));
if (rd)
{
double res;
if (source >= 0.0f)
res = sqrt(source);
else
res = 0.0;
if (pd)
m_fpair[rd >> 1] = d2u(res);
else
m_reg[rd] = f2u((float)res);
}
break;
}
case 0xf2: // rmo
{
uint32_t source = m_reg[OP_RS()];
int rd = OP_RD();
int bit = 32;
for (int i=0; i < 32; i++)
{
if (source & (1 << (31-i)))
{
bit = i;
break;
}
}
if (rd)
m_reg[rd] = bit;
break;
}
default:
fatalerror("execute_reg_long_imm(): %08X: opcode %08X (%02X)", m_pc, m_ir, (m_ir >> 12) & 0xff);
}
}
void tms32082_mp_device::execute()
{
switch ((m_ir >> 20) & 3)
{
case 0:
case 1:
case 2:
execute_short_imm();
break;
case 3:
execute_reg_long_imm();
break;
}
}
| gpl-2.0 |
RaymanFX/kernel_samsung_lt03wifi | arch/arm/mach-exynos/board-klimt-gpio.c | 31408 | /* linux/arch/arm/mach-exynos/board-klimt-gpio.c
*
* Copyright (c) 2013 Samsung Electronics Co., Ltd.
* http://www.samsung.com
*
* 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.
*/
#include <linux/gpio.h>
#include <plat/gpio-cfg.h>
#include <asm/system_info.h>
#ifdef CONFIG_SEC_GPIO_DVS
#include <linux/secgpio_dvs.h>
#endif
#define GPIO_LV_L 0 /* GPIO level low */
#define GPIO_LV_H 1 /* GPIO level high */
#define GPIO_LV_N 2 /* GPIO level none */
/*
======================================================
klimt revision history from system_rev
======================================================
*/
struct gpio_init_data {
u32 num;
u32 cfg;
u32 val;
u32 pud;
};
struct gpio_sleep_data {
u32 num;
u32 cfg;
u32 pud;
};
struct sleep_gpio_tables {
struct gpio_sleep_data *table;
u32 arr_size;
};
#define MAX_BOARD_REV 0xf
static struct sleep_gpio_tables klimt_sleep_gpio_tables[MAX_BOARD_REV];
static int nr_klimt_sleep_gpio_table;
/* init gpio table for KLIMT project */
static struct gpio_init_data __initdata init_gpio_table[] = {
/* GPA 0 */
{ EXYNOS5420_GPA0(0), S3C_GPIO_SFN(2), GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* BT_UART_RXD */
{ EXYNOS5420_GPA0(2), S3C_GPIO_SFN(2), GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* BT_UART_CTS */
/* GPA 1 */
{ EXYNOS5420_GPA1(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* SENSOR_I2C_SDA */
{ EXYNOS5420_GPA1(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* SENSOR_I2C_SCL */
/* GPA 2 */
#if !defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPA2(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* GRIP_SDA */
{ EXYNOS5420_GPA2(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* GRIP_SCL */
#endif
/* GPB 0 */
/* GPB 1 */
/* GPB 2 */
/* GPB 3 */
{ EXYNOS5420_GPB3(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* TSP_SDA_1.8V */
{ EXYNOS5420_GPB3(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* TSP_SDA_1.8V */
{ EXYNOS5420_GPB3(4), S3C_GPIO_OUTPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* MEM_LDO_SCL */
{ EXYNOS5420_GPB3(5), S3C_GPIO_OUTPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* MEM_LDO_SDA */
/* GPC 1 */
{ EXYNOS5420_GPC1(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* WLAN_SDIO_CLK */
{ EXYNOS5420_GPC1(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* WLAN_SDIO_CMD */
{ EXYNOS5420_GPC1(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* WLAN_SDIO_D(0) */
{ EXYNOS5420_GPC1(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* WLAN_SDIO_D(1) */
{ EXYNOS5420_GPC1(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* WLAN_SDIO_D(2) */
{ EXYNOS5420_GPC1(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* WLAN_SDIO_D(3) */
{ EXYNOS5420_GPC1(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPC 2 */
{ EXYNOS5420_GPC2(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPC 3 */
/* GPC 4 */
{ EXYNOS5420_GPC4(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPC4(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPD 1 */
{ EXYNOS5420_GPD1(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPD1(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(PDA_ACTIVE) */
#endif
/* GPE 0 */
/* GPE 1 */
{ EXYNOS5420_GPE1(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPE1(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPF 0 */
/* GPF 1 */
{ EXYNOS5420_GPF1(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPF1(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPF1(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPF1(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPG 0 */
{ EXYNOS5420_GPG0(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* TP4011 */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPG0(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(CP_CMU_RST) */
#endif
/* GPG 1 */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPG1(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(IPC_SLAVE_WAKEUP) */
{ EXYNOS5420_GPG1(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(SUSPEND_REQUEST_HSIC) */
{ EXYNOS5420_GPG1(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(CP_ON) */
#endif
{ EXYNOS5420_GPG1(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPG1(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(AP_DUMP_INT) */
{ EXYNOS5420_GPG1(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(ACTIVE_STATE_HSIC) */
#endif
/* GPG 2 */
{ EXYNOS5420_GPG2(0), S3C_GPIO_OUTPUT, GPIO_LV_H, S3C_GPIO_PULL_NONE }, /* GPIO_M_RST_N */
/* GPH 0 */
/* GPJ 4 */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPJ4(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(RESET_REQ_N) */
#endif
/* GPX 0 */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPX0(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(GRIP_DET_AP) */
#endif
{ EXYNOS5420_GPX0(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* GPIO_ACC_INT2 */
{ EXYNOS5420_GPX0(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPX 1 */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPX1(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(IPC_HOST_WAKEUP) */
#endif
{ EXYNOS5420_GPX1(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* GPIO_ACC_INT1 */
{ EXYNOS5420_GPX1(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* FUEL_ALERT */
/* GPX 2 */
{ EXYNOS5420_GPX2(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* WLAN_HOST_WAKE */
{ EXYNOS5420_GPX2(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* GPIO_CODEC_IRQ_N */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPX2(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(CP_DUMP_INT) */
{ EXYNOS5420_GPX2(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC(HSPA_ACTIVE) */
#endif
/* GPX 3 */
{ EXYNOS5420_GPX3(0), S3C_GPIO_SFN(0xF), GPIO_LV_N, S3C_GPIO_PULL_UP }, /* AP_PMIC_IRQ */
{ EXYNOS5420_GPX3(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPX3(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPX3(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_NONE }, /* GPIO_GYRO_DRDY */
/* GPY 0 */
{ EXYNOS5420_GPY0(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY0(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY0(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY0(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY0(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY0(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPY 1 */
{ EXYNOS5420_GPY1(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY1(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY1(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY1(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPY 2 */
{ EXYNOS5420_GPY2(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY2(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY2(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY2(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY2(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPY 3 */
{ EXYNOS5420_GPY3(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY3(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY3(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY3(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY3(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPY 4 */
{ EXYNOS5420_GPY4(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY4(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY4(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY4(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY4(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY4(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY4(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY4(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPY 5 */
{ EXYNOS5420_GPY5(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY5(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY5(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY5(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY5(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY5(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY5(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY5(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPY 6 */
{ EXYNOS5420_GPY6(0), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY6(1), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY6(2), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY6(3), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY6(4), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY6(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY6(6), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
{ EXYNOS5420_GPY6(7), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* NC */
/* GPY 7 */
{ EXYNOS5420_GPY7(5), S3C_GPIO_INPUT, GPIO_LV_N, S3C_GPIO_PULL_DOWN }, /* TP4010 */
};
/* Sleep GPIO table for old HW revisions */
static struct gpio_sleep_data sleep_gpio_table_rev00[] = {
};
/* Latest : Rev0.9(3G) Rev0.6(WIFI) */
static struct gpio_sleep_data sleep_gpio_table_latest[] = {
/* GPA 0 */
{ EXYNOS5420_GPA0(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* BT_UART_RXD */
{ EXYNOS5420_GPA0(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UP_ENABLE }, /* BT_UART_TXD */
{ EXYNOS5420_GPA0(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* BT_UART_CTS */
{ EXYNOS5420_GPA0(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UP_ENABLE }, /* BT_UART_RTS */
{ EXYNOS5420_GPA0(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UP_ENABLE }, /* GPS_UART_RXD */
{ EXYNOS5420_GPA0(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UP_ENABLE }, /* GPS_UART_TXD */
{ EXYNOS5420_GPA0(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* GPS_UART_CTS */
{ EXYNOS5420_GPA0(7), S5P_GPIO_PD_OUTPUT1, S5P_GPIO_PD_UPDOWN_DISABLE },/* GPS_UART_RTS */
/* GPA 1 */
{ EXYNOS5420_GPA1(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* AP_RXD */
{ EXYNOS5420_GPA1(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* AP_TXD */
{ EXYNOS5420_GPA1(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* SENSOR_I2C_SDA */
{ EXYNOS5420_GPA1(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* SENSOR_I2C_SCL */
{ EXYNOS5420_GPA1(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPA1(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPA 2 */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPA2(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPA2(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#else
{ EXYNOS5420_GPA2(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* GRIP_SDA */
{ EXYNOS5420_GPA2(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* GRIP_SCL */
#endif
{ EXYNOS5420_GPA2(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPA2(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPA2(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPA2(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPA2(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPA2(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPB 0 */
{ EXYNOS5420_GPB0(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPB0(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPB0(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPB0(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* FUEL_SDA_1.8V */
{ EXYNOS5420_GPB0(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* FUEL_SCL_1.8V */
/* GPB 1 */
{ EXYNOS5420_GPB1(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* FPGA_SPI_SI */
{ EXYNOS5420_GPB1(1), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },/* CODEC_SPI_SCK */
{ EXYNOS5420_GPB1(2), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },/* CODEC_SPI_SS_N */
{ EXYNOS5420_GPB1(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* CODEC_SPI_MISO */
{ EXYNOS5420_GPB1(4), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },/* CODEC_SPI_MOSI */
/* GPB 2 */
{ EXYNOS5420_GPB2(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPB2(1), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* VIBTONE_PWM */
{ EXYNOS5420_GPB2(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* AP_PMIC_SDA */
{ EXYNOS5420_GPB2(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* AP_PMIC_SCL */
/* GPB 3 */
{ EXYNOS5420_GPB3(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TSP_SDA_1.8V */
{ EXYNOS5420_GPB3(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TSP_SCL_1.8V */
{ EXYNOS5420_GPB3(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPB3(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPB3(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* MEM_LDO_SDA */
{ EXYNOS5420_GPB3(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* MEM_LDO_SCL */
{ EXYNOS5420_GPB3(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* IF_PMIC_SDA */
{ EXYNOS5420_GPB3(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* IF_PMIC_SCL */
/* GPB 4 */
{ EXYNOS5420_GPB4(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* MHL_SDA_1.8V */
{ EXYNOS5420_GPB4(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* MHL_SCL_1.8V */
/* GPC 0 */
{ EXYNOS5420_GPC0(0), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* SDC1_CLK */
{ EXYNOS5420_GPC0(1), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* SDC1_CMD */
{ EXYNOS5420_GPC0(2), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* eMMC_EN */
{ EXYNOS5420_GPC0(3), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* NAND_D(0) */
{ EXYNOS5420_GPC0(4), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* NAND_D(1) */
{ EXYNOS5420_GPC0(5), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* NAND_D(2) */
{ EXYNOS5420_GPC0(6), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* NAND_D(3) */
{ EXYNOS5420_GPC0(7), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* EMMC_RCLK */
/* GPC 1 */
{ EXYNOS5420_GPC1(0), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },/* WLAN_SDIO_CLK */
{ EXYNOS5420_GPC1(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* WLAN_SDIO_CMD */
{ EXYNOS5420_GPC1(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* GPS_EN */
{ EXYNOS5420_GPC1(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* WLAN_SDIO_D(0) */
{ EXYNOS5420_GPC1(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* WLAN_SDIO_D(1) */
{ EXYNOS5420_GPC1(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* WLAN_SDIO_D(2) */
{ EXYNOS5420_GPC1(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* WLAN_SDIO_D(3) */
{ EXYNOS5420_GPC1(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPC 2 */
{ EXYNOS5420_GPC2(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* T_FLASH_CLK */
{ EXYNOS5420_GPC2(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* T_FLASH_CMD */
{ EXYNOS5420_GPC2(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPC2(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* T_FLASH_D(0) */
{ EXYNOS5420_GPC2(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* T_FLASH_D(1) */
{ EXYNOS5420_GPC2(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* T_FLASH_D(2) */
{ EXYNOS5420_GPC2(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* T_FLASH_D(3) */
/* GPC 3 */
{ EXYNOS5420_GPC3(0), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* NAND_D(4) */
{ EXYNOS5420_GPC3(1), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* NAND_D(5) */
{ EXYNOS5420_GPC3(2), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* NAND_D(6) */
{ EXYNOS5420_GPC3(3), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* NAND_D(7) */
/* GPC 4 */
{ EXYNOS5420_GPC4(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPC4(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPD 1 */
{ EXYNOS5420_GPD1(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPD1(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#if defined(CONFIG_KLIMT_WIFI)
{ EXYNOS5420_GPD1(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#else
{ EXYNOS5420_GPD1(2), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* PDA_ACTIVE */
#endif
{ EXYNOS5420_GPD1(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPD1(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TOUCH_SDA */
{ EXYNOS5420_GPD1(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TOUCH_SCL */
{ EXYNOS5420_GPD1(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPD1(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TE */
{ EXYNOS5420_GPE0(0), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CAM_FLASH_EN */
{ EXYNOS5420_GPE0(1), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CAM_FLASH_SET */
{ EXYNOS5420_GPE0(2), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CAM_VT_STBY */
{ EXYNOS5420_GPE0(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPE0(4), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CAM_VT_nRST */
{ EXYNOS5420_GPE0(5), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CAM_RESET */
{ EXYNOS5420_GPE0(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPE0(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPE 1 */
{ EXYNOS5420_GPE1(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPE1(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPF 0 */
{ EXYNOS5420_GPF0(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* 8M_CAM_SDA_1.8V */
{ EXYNOS5420_GPF0(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* 8M_CAM_SCL_1.8V */
{ EXYNOS5420_GPF0(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* 8M_AF_SDA_1.8V */
{ EXYNOS5420_GPF0(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* 8M_AF_SCL_1.8V */
{ EXYNOS5420_GPF0(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* VT_CAM_SDA_1.8V */
{ EXYNOS5420_GPF0(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* VT_CAM_SCL_1.8V */
/* GPF 1 */
{ EXYNOS5420_GPF1(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPF1(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPF1(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPF1(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPF1(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPF1(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPF1(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPF1(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPG 0 */
{ EXYNOS5420_GPG0(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TP4011 */
{ EXYNOS5420_GPG0(1), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CODEC_LDO_EN */
{ EXYNOS5420_GPG0(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CDONE */
{ EXYNOS5420_GPG0(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* MHL_INT */
#if defined(CONFIG_KLIMT_3G) || defined(CONFIG_KLIMT_LTE)
{ EXYNOS5420_GPG0(4), S5P_GPIO_PD_OUTPUT1, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CP_PMU_RST */
#else
{ EXYNOS5420_GPG0(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#endif
{ EXYNOS5420_GPG0(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* MOTOR_EN */
{ EXYNOS5420_GPG0(6), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CODEC_RESET */
{ EXYNOS5420_GPG0(7), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* BT_EN */
/* GPG 1 */
#if defined(CONFIG_KLIMT_3G) || defined(CONFIG_KLIMT_LTE)
{ EXYNOS5420_GPG1(0), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE },/* IPC_SLAVE_WAKEUP */
#else
{ EXYNOS5420_GPG1(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#endif
{ EXYNOS5420_GPG1(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPG1(2), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_DOWN_ENABLE },/* LCD_EN */
#if defined(CONFIG_KLIMT_3G) || defined(CONFIG_KLIMT_LTE)
{ EXYNOS5420_GPG1(3), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* SUSPEND_REQUEST_HSIC */
{ EXYNOS5420_GPG1(4), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CP_ON */
#else
{ EXYNOS5420_GPG1(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPG1(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#endif
{ EXYNOS5420_GPG1(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#if defined(CONFIG_KLIMT_3G) || defined(CONFIG_KLIMT_LTE)
{ EXYNOS5420_GPG1(6), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE },/* AP_DUMP_INT */
{ EXYNOS5420_GPG1(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* ACTIVE_STATE_HSIC */
#else
{ EXYNOS5420_GPG1(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPG1(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#endif
/* GPG 2 */
{ EXYNOS5420_GPG2(0), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* M_RST_N */
{ EXYNOS5420_GPG2(1), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CORE_MODE */
/* GPH 0 */
{ EXYNOS5420_GPH0(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* HW_REV0 */
{ EXYNOS5420_GPH0(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* HW_REV1 */
{ EXYNOS5420_GPH0(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* HW_REV2 */
{ EXYNOS5420_GPH0(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* HW_REV3 */
{ EXYNOS5420_GPH0(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_UPDOWN_DISABLE }, /* FPGA_SPI_CLK */
{ EXYNOS5420_GPH0(5), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CAM_MCLK */
{ EXYNOS5420_GPH0(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* FPGA_SPI_EN */
{ EXYNOS5420_GPH0(7), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* VTCAM_MCLK */
/* GPJ 4 */
{ EXYNOS5420_GPJ4(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TE */
#if defined(CONFIG_KLIMT_3G) || defined(CONFIG_KLIMT_LTE)
{ EXYNOS5420_GPJ4(1), S5P_GPIO_PD_OUTPUT1, S5P_GPIO_PD_UPDOWN_DISABLE }, /* RESET_REQ_N */
#else
{ EXYNOS5420_GPJ4(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
#endif
{ EXYNOS5420_GPJ4(2), S5P_GPIO_PD_OUTPUT1, S5P_GPIO_PD_UPDOWN_DISABLE }, /* CRESET_B */
{ EXYNOS5420_GPJ4(3), S5P_GPIO_PD_OUTPUT1, S5P_GPIO_PD_UPDOWN_DISABLE }, /* MHL_RST */
/* GPX 3 */
{ EXYNOS5420_GPX3(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TCON_INTR */
{ EXYNOS5420_GPX3(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TCON_RDY */
/* GPY 0 */
{ EXYNOS5420_GPY0(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY0(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY0(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY0(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY0(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY0(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPY 1 */
{ EXYNOS5420_GPY1(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY1(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY1(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY1(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPY 2 */
{ EXYNOS5420_GPY2(0), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* TF_EN */
{ EXYNOS5420_GPY2(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY2(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY2(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY2(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY2(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPY 3 */
{ EXYNOS5420_GPY3(0), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* MMC01_EN */
{ EXYNOS5420_GPY3(1), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* MMC2_EN */
{ EXYNOS5420_GPY3(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* MIPI_1.8V_EN */
{ EXYNOS5420_GPY3(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY3(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY3(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY3(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY3(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPY 4 */
{ EXYNOS5420_GPY4(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY4(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY4(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY4(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY4(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY4(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY4(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY4(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPY 5 */
{ EXYNOS5420_GPY5(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY5(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY5(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY5(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY5(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY5(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY5(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY5(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPY 6 */
{ EXYNOS5420_GPY6(0), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY6(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY6(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY6(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY6(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY6(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY6(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY6(7), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
/* GPY 7 */
{ EXYNOS5420_GPY7(0), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE }, /* 2M_A2.8V_EN */
{ EXYNOS5420_GPY7(1), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* IRDA_IRQ */
{ EXYNOS5420_GPY7(2), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* VT_CAM_ID */
{ EXYNOS5420_GPY7(3), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* TA_INT */
{ EXYNOS5420_GPY7(4), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY7(5), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY7(6), S5P_GPIO_PD_INPUT, S5P_GPIO_PD_DOWN_ENABLE }, /* NC */
{ EXYNOS5420_GPY7(7), S5P_GPIO_PD_PREV_STATE, S5P_GPIO_PD_UPDOWN_DISABLE }, /* WLAN_EN */
/* GPX0 - GPX3 is alive part */
#if 0
/*
* Accessing GPZ ports will crash when MAU power domain and clock are
* disabled
*/
{ EXYNOS5420_GPZ(0), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },
{ EXYNOS5420_GPZ(1), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },
{ EXYNOS5420_GPZ(2), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },
{ EXYNOS5420_GPZ(3), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },
{ EXYNOS5420_GPZ(4), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },
{ EXYNOS5420_GPZ(5), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },
{ EXYNOS5420_GPZ(6), S5P_GPIO_PD_OUTPUT0, S5P_GPIO_PD_UPDOWN_DISABLE },
#endif
};
/* This funtion will be init breakpoint for GPIO verification */
void gpio_init_done(void)
{
pr_info("%s\n", __func__);
#ifdef CONFIG_SEC_GPIO_DVS
/************************ Caution !!! ****************************/
/* This function must be located in appropriate INIT position
* in accordance with the specification of each BB vendor.
*/
/************************ Caution !!! ****************************/
gpio_dvs_check_initgpio();
#endif
}
static void __init config_init_gpio(void)
{
u32 i;
for (i = 0; i < ARRAY_SIZE(init_gpio_table); i++) {
u32 gpio = init_gpio_table[i].num;
s3c_gpio_setpull(gpio, init_gpio_table[i].pud);
s3c_gpio_cfgpin(gpio, init_gpio_table[i].cfg);
if (init_gpio_table[i].cfg == S3C_GPIO_OUTPUT)
gpio_set_value(gpio, init_gpio_table[i].val);
}
gpio_init_done();
}
static void config_sleep_gpio(struct gpio_sleep_data *table, u32 arr_size)
{
u32 i;
for (i = 0; i < arr_size; i++) {
s5p_gpio_set_pd_pull(table[i].num, table[i].pud);
s5p_gpio_set_pd_cfg(table[i].num, table[i].cfg);
}
}
static void config_sleep_gpio_tables(void)
{
int i;
for (i = nr_klimt_sleep_gpio_table - 1; i >= 0; i--)
config_sleep_gpio(klimt_sleep_gpio_tables[i].table,
klimt_sleep_gpio_tables[i].arr_size);
}
void __init board_klimt_gpio_init(void)
{
int i = 0;
if (system_rev > MAX_BOARD_REV)
panic("Invalid Board Revision: %d", system_rev);
/* initialize init gpios */
config_init_gpio();
/* set function for sleep gpio config */
switch (system_rev) {
case 0:
klimt_sleep_gpio_tables[i].table = sleep_gpio_table_rev00;
klimt_sleep_gpio_tables[i].arr_size =
ARRAY_SIZE(sleep_gpio_table_rev00);
i++;
/* Fall through */
default:
klimt_sleep_gpio_tables[i].table = sleep_gpio_table_latest;
klimt_sleep_gpio_tables[i].arr_size =
ARRAY_SIZE(sleep_gpio_table_latest);
i++;
break;
}
nr_klimt_sleep_gpio_table = i;
exynos_config_sleep_gpio = config_sleep_gpio_tables;
}
| gpl-2.0 |
embecosm/avr32-gcc | gcc/testsuite/gcc.target/arm/neon/vuzpQf32.c | 630 | /* Test the `vuzpQf32' ARM Neon intrinsic. */
/* This file was autogenerated by neon-testgen. */
/* { dg-do assemble } */
/* { dg-require-effective-target arm_neon_ok } */
/* { dg-options "-save-temps -O0 -mfpu=neon -mfloat-abi=softfp" } */
#include "arm_neon.h"
void test_vuzpQf32 (void)
{
float32x4x2_t out_float32x4x2_t;
float32x4_t arg0_float32x4_t;
float32x4_t arg1_float32x4_t;
out_float32x4x2_t = vuzpq_f32 (arg0_float32x4_t, arg1_float32x4_t);
}
/* { dg-final { scan-assembler "vuzp\.32\[ \]+\[qQ\]\[0-9\]+, \[qQ\]\[0-9\]+!?\(\[ \]+@\[a-zA-Z0-9 \]+\)?\n" } } */
/* { dg-final { cleanup-saved-temps } } */
| gpl-2.0 |
muehlburger/gnucash | common/test-core/test-stuff.h | 5135 | /* Modified by bstanley 20010320
* Added do_test macro, do_test_call and do_test_call_args,
* print_test_results, set_success_print.
*
* Modified by bstanley 20010323
* removed testing functionality which depends on the rest of gnucash -
* separated into gnc-test-stuff.h
*
*/
/********************************************************************\
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
* published by the Free Software Foundation; either version 2 of *
* the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License*
* along with this program; if not, contact: *
* *
* Free Software Foundation Voice: +1-617-542-5942 *
* 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
* Boston, MA 02110-1301, USA [email protected] *
* *
\********************************************************************/
/* Outline of a test program using the new testing functions:
#include "test-stuff.h"
int main( int argc, char* argv[] )
{
int a, b;
g_log_set_always_fatal( G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING );
a = b = 1;
do_test( a == b, "integer equality" );
do_test( a != b, "integer inequality? (should fail)" );
do_test_args( a == b, "fancy info", __FILE__, __LINE__, "a = %d, b = %b", a, b );
print_test_results();
return get_rv();
}
*/
/* If you want to see test passes, use
set_success_print(TRUE);
before you execute the tests.
Otherwise, only failures are printed out.
*/
#ifndef TEST_STUFF_H
#define TEST_STUFF_H
#include <glib.h>
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
/* Privately used to indicate a test result. You may use these if you
* wish, but it's easier to use the do_test macro above.
*/
gboolean do_test_call(
gboolean result,
const char* test_title,
const char* filename,
int line );
gboolean do_test_args(
gboolean result,
const char* test_title,
const char* filename,
int line,
const char* format, ... );
/**
* Prints out the number of tests passed and failed.
*/
void print_test_results(void);
/**
* Use this to set whether successful tests
* should print a message.
* Default is false.
* Successful test messages are useful while initally constructing the
* test suite, but when it's completed, no news is good news.
* A successful test run will be indicated by the message
* from print_test_results().
*/
void set_success_print( gboolean in_should_print );
/* Value to return from main. Set to 1 if there were any fails, 0 otherwise. */
int get_rv(void);
/** Testing primitives.
* Sometimes you just have to put the results of
* a test into different forks of the code.
*/
void success_call(
const char *test_title,
const char *file,
int line );
void success_args(
const char *test_title,
const char *file,
int line,
const char *format,
... );
void failure_call(
const char *test_title,
const char *file,
int line);
void failure_args(
const char *test_title,
const char *file,
int line,
const char *format,
... );
/**
* Use this to indicate the result of a test.
* The result is TRUE for success, FALSE for failure.
* title describes the test
* Tests are automatically identified by their source file and line.
*/
#define do_test( result, title ) do_test_call( result, title, __FILE__, __LINE__ )
#define success( title ) success_call( title, __FILE__, __LINE__ );
#define failure( title ) failure_call( title, __FILE__, __LINE__ );
/** This one doesn't work because macros can't take a variable number of arguments.
* well, apparently gcc can, but it's non-standard.
* Apparently C99 can, too, but it's not exactly standard either.
#define do_test_args( result, title, format ) do_test_call( result, title, __FILE__, __LINE__, format, ... );
*/
gboolean get_random_boolean(void);
gint get_random_int_in_range(int start, int end);
void random_character_include_funky_chars (gboolean use_funky_chars);
gchar get_random_character(void);
gchar* get_random_string(void);
gchar * get_random_string_length_in_range(int minlen, int maxlen);
gchar* get_random_string_without(const char *exclude_chars);
gint32 get_random_gint32 (void);
gint64 get_random_gint64(void);
double get_random_double(void);
const char* get_random_string_in_array(const char* str_list[]);
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif /* TEST_STUFF_H */
| gpl-2.0 |
Subsets and Splits